atomsphere 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 25eae7b31f1b5dd9f640ec1a7942192a1fbec4c2aeffda74f9af08ce31879224
+  data.tar.gz: d4e1d956c1abbf2e74125b24c725b0664b8be0fc57078804e2eb120f43ab822b
+SHA512:
+  metadata.gz: 675f2fca40b7842b44b4abdb04993cd8af67f37095d3fcc1f039ba75f151b3166a4bfaa5fc63b94ee0b3f58d91eac332ce1bbcc3454cdc7c1a819e5a8b6459f4
+  data.tar.gz: edfc117e3812d520b4de08efbb1eee30052f6b58bd4bb42d15ab15200516f58b06bed5c9694de61728e0a17141afe85bfd619ef6bcb24adae12bf09b62117bf6

data/.gitignore

@@ -0,0 +1,5 @@
+/vendor/bundle
+/.env
+/.bundle
+/tmp
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'facets'
+gem 'rotp'
+
+group :development do
+  gem 'pry'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Warren Guy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+# Boomi Atomsphere API client for Ruby
+
+Unofficial Ruby client for the Dell Boomi Atomsphere API. Implements the JSON flavour of Boomi's "RESTish" API.
+
+## Status
+
+Implements authentication (including OTP), querying, and some actions. See *Usage* below.
+
+## Usage
+
+```ruby
+require 'atomsphere'
+```
+
+### Configuration
+
+```ruby
+Atomsphere.configure do |config|
+  config.account_id = '' # Boomi account ID
+  config.username   = '' # user name
+  config.password   = '' # user password
+  config.otp_secret = '' # base32 OTP secret for two-factor auth
+end
+```
+
+Alternatively, environment variables may be used:
+ * `BOOMI_ACCOUNT_ID`
+ * `BOOMI_USERNAME`
+ * `BOOMI_PASSWORD`
+ * `BOOMI_OTP_SECRET`
+
+### Querying
+
+```ruby
+# create a new query
+query = Atomsphere::Query.new
+
+# specify the object type to query
+query.object_type = 'Process'
+
+# filter for query names starting with 'Netsuite'
+query.filter = Atomsphere::Query::GroupingExpression.new(
+  operator: :and,
+  nested_expression: [
+    Atomsphere::Query::SimpleExpression.new(
+      operator: :equals,
+      property: :name,
+      argument: ['Netsuite%']
+    )
+  ]
+)
+
+# run the query (fetches first page)
+query.run
+
+# see results from all pages that have been fetched
+query.results
+
+# fetch the next page (returns `false` if `last_page?` is `true`)
+query.next_page
+
+# fetch and show all pages of results (warning: loops over `next_page`)
+query.all_results
+```
+
+### Actions
+
+```ruby
+Atomsphere.get_assignable_roles
+Atomsphere.execute_process atom_id: '12345-uuid-12345', process_id: '12345-uuid-12345'
+Atomsphere.change_listener_status listener_id: '12345-uuid-12345', container_id: '12345-uuid-12345', action: :pause
+```
+
+## License
+
+MIT License
+
+Copyright (c) 2019 Warren Guy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/atomsphere.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name          = 'atomsphere'
+  s.version       = '0.1.6'
+  s.licenses      = ['MIT']
+  s.summary       = "Unofficial Ruby client for the Dell Boomi Atomsphere API"
+  s.authors       = ["Warren Guy"]
+  s.email         = 'warren@guy.net.au'
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+  s.homepage      = 'https://github.com/warrenguy/atomsphere-ruby'
+  s.metadata      = { "source_code_uri" => "https://github.com/warrenguy/atomsphere-ruby" }
+
+  s.required_ruby_version = '>= 2.2'
+  s.add_runtime_dependency 'rotp', '~>4'
+  s.add_runtime_dependency 'facets', '~>3'
+end

data/lib/atomsphere.rb

@@ -0,0 +1,6 @@
+module Atomsphere
+  VERSION = '0.1.6'
+  ROOT = "#{File.expand_path(__dir__)}/atomsphere"
+
+  %w(configuration query api action).each{ |m| require "#{ROOT}/#{m}" }
+end

data/lib/atomsphere/action.rb

@@ -0,0 +1,129 @@
+require 'facets/string/camelcase'
+require 'facets/string/snakecase'
+
+module Atomsphere
+  module Action
+    module ClassMethods
+      def self.included base
+      end
+
+      def initialize params={}
+        set_params params
+        validate!
+      end
+
+      def fields
+        %w(required one_of optional).map do |m|
+          self.class.class_variable_get :"@@#{m}"
+        end.flatten
+      end
+
+      def run
+        @api_response ||= api_client.send(*[
+          api_method,
+          action,
+          api_method.eql?(:get) ? nil : request
+        ].compact)
+
+        @response ||= @api_response.to_hash
+        self
+      end
+
+      private
+      %w(required one_of optional).each do |m|
+        define_method(:"#{m}") { self.class.class_variable_get(:"@@#{m}") }
+      end
+
+      def action
+        if self.class.class_variable_defined? :@@action
+          self.class.class_variable_get :@@action
+        else
+          self.class.name.split('::').last.lower_camelcase
+        end
+      end
+
+      def api_method
+        if self.class.class_variable_defined? :@@api_method
+          self.class.class_variable_get :@@api_method
+        else
+          :post
+        end
+      end
+      
+      def set_params params
+        fields.each{ |f| send(:"#{f}=", params[f]) }
+      end
+
+      def api_client
+        Api::Client.new
+      end
+
+      def validate!
+        required.each do |f|
+          raise ArgumentError, "#{f} is required" unless send(:"#{f}")
+        end
+
+        one_of.each do |fs|
+          unless fs.map{ |f| send(:"#{f}") }.compact.size == 1
+            raise ArgumentError, "requires one of: #{fs.join(', ')}"
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      def self.extended base
+        %w(required one_of optional).each do |m|
+          base.class_variable_set :"@@#{m}", []
+        end
+
+        method_name = base.name.split('::').last.snakecase
+        Atomsphere.define_singleton_method(method_name) do |*params|
+          base.new(*params).run
+        end
+      end
+
+      def action a
+        class_variable_set :@@action, a
+      end
+
+      def api_method m
+        class_variable_set :@@api_method, m
+      end
+
+      def required *params
+        params.each do |param|
+          class_variable_get(:@@required) << param
+          attr_accessor param
+        end
+      end
+
+      def optional *params
+        params.each do |param|
+          class_variable_get(:@@optional) << param
+          attr_accessor param
+        end
+      end
+
+      def one_of *params
+        if params.size < 2
+          raise ArgumentError, "one_of requires two or more parameters"
+        end
+
+        class_variable_get(:@@one_of) << [*params]
+        params.each{ |param| attr_accessor param }
+      end
+    end
+
+    class Action
+      def self.inherited(other)
+        other.extend InstanceMethods
+        other.include ClassMethods
+      end
+
+      attr_reader :api_response, :response
+    end
+  end
+end
+
+Dir["#{Atomsphere::ROOT}/action/*.rb"].each{ |f| require f }

data/lib/atomsphere/action/change_listener_status.rb

@@ -0,0 +1,11 @@
+module Atomsphere
+  module Action
+    class ChangeListenerStatus < Action
+      required :listener_id, :container_id, :action
+
+      def request
+        Hash[fields.map{ |f| [f, send(f)] }]
+      end
+    end
+  end
+end

data/lib/atomsphere/action/execute_process.rb

@@ -0,0 +1,26 @@
+module Atomsphere
+  module Action
+    class ExecuteProcess < Action
+      required :atom_id
+      one_of :process_id, :process_name
+
+      def request
+        {
+          ProcessProperties: {
+            '@type': 'ProcessProperties',
+            ProcessProperty: [
+              {
+                '@type': '',
+                Name: 'priority',
+                Value: 'medium'
+              }
+            ]
+          },
+          atomId: atom_id
+        }.merge(!process_id.nil? ?
+          { processId: process_id } :
+          { processName: process_name })
+      end
+    end
+  end
+end

data/lib/atomsphere/action/get_assignable_roles.rb

@@ -0,0 +1,7 @@
+module Atomsphere
+  module Action
+    class GetAssignableRoles < Action
+      api_method :get
+    end
+  end
+end

data/lib/atomsphere/api.rb

@@ -0,0 +1,6 @@
+module Atomsphere
+  module Api
+  end
+
+  %w(response client).each{ |m| require "#{ROOT}/api/#{m}" }
+end

data/lib/atomsphere/api/client.rb

@@ -0,0 +1,90 @@
+require 'net/https'
+require 'uri'
+require 'json'
+require 'rotp'
+
+module Atomsphere
+  module Api
+    class Client
+      def initialize
+        validate!
+      end
+
+      def post path, data
+        header = {
+          'Content-Type' => 'application/json',
+          'Accept'       => ' application/json'
+        }
+
+        request = Net::HTTP::Post.new api_uri(path), header
+        request.body = (String === data ? data : data.to_json)
+        request.basic_auth config.username, config.password
+
+        http_request request
+      end
+
+      def get path
+        header = {'Accept' => 'application/json'}
+
+        request = Net::HTTP::Get.new api_uri(path), header
+        request.basic_auth config.username, config.password
+
+        http_request request
+      end
+
+      def bulk_get path, ids
+        request = { type: 'GET', request: ids.map{ |id| {id: id} } }
+        path = [*path] << :bulk
+        post path, request
+      end
+
+      %w(query create update execute).each do |v|
+        define_method :"#{v}" do |path, data|
+          [*path] << v
+          post path, data
+        end
+      end
+
+      private
+      def validate!
+        raise ArgumentError, "Atomsphere not configured" if config.nil?
+
+        required_vars = Atomsphere::Configuration::REQUIRED
+        if (missing_vars = required_vars.select{ |v| config.send(v).nil? }).size > 0
+          raise ArgumentError, "Atomsphere configuration incomplete," +
+            " required vars missing: #{missing_vars.join('; ')}"
+        end
+      end
+
+      def config
+        @config ||= Atomsphere.configuration
+      end
+
+      def totp
+        ROTP::TOTP.new(config.otp_secret) if config.otp_secret
+      end
+
+      def generate_otp
+        totp.now
+      end
+
+      def api_uri path=nil
+        URI.parse config.base_uri + 
+          config.account_id + 
+          '/' + (Array === path ? path.join('/') : path.to_s)
+      end
+
+      def http
+        h = Net::HTTP.new api_uri.host, api_uri.port
+        h.use_ssl = true
+
+        h
+      end
+
+      def http_request request
+        request['X-Boomi-OTP'] = generate_otp if config.otp_secret
+        response = Response.new(request, http.request(request))
+      end
+    end
+  end
+end

data/lib/atomsphere/api/response.rb

@@ -0,0 +1,23 @@
+require 'json'
+
+module Atomsphere
+  module Api
+    class Response
+      attr_reader :request, :code, :response
+
+      def initialize(request, response)
+        @request  = request
+        @response = response
+        @code     = response.code if response
+      end
+
+      def to_hash
+        begin
+          JSON.parse @response.body
+        rescue JSON::ParserError
+          @response.body
+        end if @response
+      end
+    end
+  end
+end

data/lib/atomsphere/configuration.rb

@@ -0,0 +1,32 @@
+module Atomsphere
+  class Configuration
+    REQUIRED = :username, :password, :account_id
+    OPTIONAL = :base_uri, :otp_secret
+    VARS = REQUIRED + OPTIONAL
+
+    VARS.each { |v| attr_accessor v }
+
+    def initialize
+      @base_uri = 'https://api.boomi.com/api/rest/v1/'
+    end
+  end
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield configuration
+
+    configuration
+  end
+end
+
+Hash[Atomsphere::Configuration::VARS.map do |v|
+  [v, "BOOMI_#{v.upcase}"]
+end].each do |v, e|
+  Atomsphere.configure do |config|
+    config.send :"#{v}=", ENV[e]
+  end if ENV.keys.include? e
+end

data/lib/atomsphere/query.rb

@@ -0,0 +1,84 @@
+module Atomsphere
+  class Query
+    attr_accessor :object_type, :filter
+    attr_reader   :query_token, :result_pages, :page
+
+    def initialize object_type=nil
+      @object_type ||= object_type
+      @page = nil
+      @result_pages = []
+      @filter = GroupingExpression.new
+    end
+
+    def validate!
+      methods.select{ |m| m =~ /^validate_[a-z0-9_]\!$/ }.each{ |v| send(v) }
+      filter.validate!
+      true
+    end
+
+    def run
+      @result_pages[0] ||= api_client.post [object_type, :query], to_hash
+      @page = 0
+
+      result_pages[0]
+    end
+    
+    def results
+      result_pages.map(&:to_hash).map{ |h| h['result'] }.flatten(1)
+    end
+
+    def all_results
+      next_page until last_page?
+      results
+    end
+
+    def last_page?
+      !page.nil? && query_token.nil?
+    end
+
+    def next_page
+      return false if last_page?
+      return run if page.nil?
+
+      begin
+        @result_pages[@page += 1] = api_client.post [object_type, :queryMore], query_token
+      rescue => e
+        @page -= 1
+        raise e
+      end
+
+      result_pages[page]
+    end
+
+    def to_hash
+      validate!
+
+      { QueryFilter: filter.to_hash }
+    end
+
+    def to_json
+      JSON.pretty_generate to_hash
+    end
+
+    private
+    def validate_object_type!
+      raise ArgumentError, "object_type is required" if @object_type.nil?
+    end
+
+    def validate_filter!
+      unless filter.is_a? GroupingExpression
+        raise ArgumentError, 'filter must be a GroupingExpression'
+      end
+    end
+
+    def api_client
+      Api::Client.new
+    end
+
+    def query_token
+      page.nil? ? nil : result_pages.last.to_hash['queryToken']
+    end
+  end
+
+  %w(grouping_expression simple_expression).each{ |m| require "#{ROOT}/query/#{m}" }
+end

data/lib/atomsphere/query/grouping_expression.rb

@@ -0,0 +1,66 @@
+require 'json'
+
+module Atomsphere
+  class Query
+    class GroupingExpression
+      attr_accessor :operator, :nested_expression
+
+      OPERATORS = :and, :or
+
+      def initialize(params={})
+        params = {
+          operator: :and,
+          nested_expression: []
+        }.merge(params)
+
+        @operator = params[:operator]
+        @nested_expression = params[:nested_expression]
+      end
+
+      def validate!
+        methods.select{ |m| m =~ /^validate_[a-z0-9_]\!$/ }.each{ |v| send(v) }
+        @nested_expression.each(&:validate!)
+        true
+      end
+
+      def to_hash
+        {
+          expression: {
+            operator: operator.to_s,
+            nestedExpression: nested_expression.
+              map(&:to_hash).
+              map{ |h| h[:expression] }
+          }
+        }
+      end
+
+      def to_json
+        JSON.pretty_generate to_hash
+      end
+
+      private
+      def validate_operators!
+        unless OPERATORS.include? @operator
+          raise ArgumentError, "operator must be one of #{OPERATORS.join(', ')}"
+        end
+      end
+
+      def validate_expressions!
+        raise ArgumentError, "nested_expression must be an array" unless @nested_expression.is_a?(Array)
+
+        not_expressions = @nested_expression.map(&:class).reject do |k|
+          [GroupingExpression, SimpleExpression].include? k
+        end
+
+        if not_expressions.size > 0
+          raise ArgumentError,
+            "invalid expression class(es): #{not_expressions.map(&:class).join(', ')}"
+        end
+      end
+
+      def validate_expressions_size!
+        raise ArgumentError, "at least one expression required" if (@nested_expression.size < 1)
+      end
+    end
+  end
+end

data/lib/atomsphere/query/simple_expression.rb

@@ -0,0 +1,71 @@
+require 'json'
+
+module Atomsphere
+  class Query
+    class SimpleExpression
+      attr_accessor :operator, :property, :argument
+
+      OPERATORS = {
+        equals:       1,
+        like:         1,
+        not_equals:   1,
+        is_null:      0,
+        is_not_null:  0,
+        starts_with:  1,
+        between:      2,
+        greater_than: 1,
+        less_than:    1,
+        greater_than_or_equal: 1,
+        less_than_or_equal: 1
+      }
+
+      def initialize(params={})
+        params = {
+          operator: :equals,
+          property: nil,
+          argument: []
+        }.merge(params)
+
+        %w(operator property argument).each do |v|
+          send :"#{v}=", params[v.to_sym]
+        end
+      end
+
+      def validate!
+        methods.select{ |m| m =~ /^validate_[a-z0-9_]\!$/ }.each{ |v| send(v) }
+        true
+      end
+
+      def to_hash
+        {
+          expression: {
+            operator: operator.upcase,
+            property: property,
+            argument: [*argument]
+          }
+        }
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      private
+      def validate_operator!
+        unless OPERATORS.include? operator
+          raise ArgumentError, "operator must be one of #{OPERATORS.join(', ')}"
+        end
+      end
+
+      def validate_property!
+        raise ArgumentError, "property must be specified" unless @property
+      end
+
+      def validate_argument!
+        unless argument.is_a?(Array) && argument.size.eql?(OPERATORS[operator])
+          raise ArgumentError, "'#{operator}' expects #{OPERATORS[operator]} argument(s)"
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: atomsphere
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- Warren Guy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rotp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: facets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: 
+email: warren@guy.net.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- atomsphere.gemspec
+- lib/atomsphere.rb
+- lib/atomsphere/action.rb
+- lib/atomsphere/action/change_listener_status.rb
+- lib/atomsphere/action/execute_process.rb
+- lib/atomsphere/action/get_assignable_roles.rb
+- lib/atomsphere/api.rb
+- lib/atomsphere/api/client.rb
+- lib/atomsphere/api/response.rb
+- lib/atomsphere/configuration.rb
+- lib/atomsphere/query.rb
+- lib/atomsphere/query/grouping_expression.rb
+- lib/atomsphere/query/simple_expression.rb
+homepage: https://github.com/warrenguy/atomsphere-ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/warrenguy/atomsphere-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: Unofficial Ruby client for the Dell Boomi Atomsphere API
+test_files: []