dgrid 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OWM5ODE0NDQwYTg3YmI3OGI3YTI4NTk1ZGI5MzU3OTg4YWM3OWVlNA==
+  data.tar.gz: !binary |-
+    NjExMjkyNjY5ZGIxOTQyMWRhY2Q4M2Y1NDZlMTk1YzVjNDk4NjYwOA==
+SHA512:
+  metadata.gz: !binary |-
+    OWJhZTA5MzQzN2ZkNDVhYjg2ZTAzZDNhYjQ0NDRjYjFkNzJiNzM2MzhhNjQw
+    YzMwYzJlMDY4N2JmMWMwMDA2YjAzYjE5M2I1YjAyYjhjYTk4OTI2MGFjYjE4
+    MjY1Yzk4ZjkwYTljMzE1YWUyYmU5NjM2MTMwNzU1YjQyOWQ5NzU=
+  data.tar.gz: !binary |-
+    OWNhY2NiYTgxYzRiYTJkOGQ0MDIyZjA2Y2E1Yzk5MmYxZDE0MGY5N2U3Zjdh
+    NDc0MTI3NDI4NzZhOTEwZGRlNzJhZjdjYjAxNzJmOTIyNzg4NjNhMDBjNWQy
+    ZThkZmIzMjVhZDkyNmM3MDY2OTUxMzMzZjkyZDM2NjE0ODAwMGI=

data/lib/dgrid.rb

@@ -0,0 +1 @@
+require 'dgrid/api'

data/lib/dgrid/api.rb

@@ -0,0 +1,20 @@
+# gem dependencies
+require 'set'
+require 'date'
+require 'dgrid/argument_validation'
+require 'dgrid/set_members_from_hash'
+
+# gem components
+require 'dgrid/api/gps_coordinates'
+require 'dgrid/api/connection'
+require 'dgrid/api/entity'
+require 'dgrid/api/named_entity'
+require 'dgrid/api/person'
+require 'dgrid/api/place'
+require 'dgrid/api/organization'
+require 'dgrid/api/incident'
+require 'dgrid/api/item'
+require 'dgrid/api/keyword'
+require 'dgrid/api/lens'
+require 'dgrid/api/link'
+require 'dgrid/api/workspace'

data/lib/dgrid/api/connection.rb

@@ -0,0 +1,444 @@
+
+require 'yaml'
+require 'net/http/post/multipart'
+
+module Dgrid
+  module API
+    require 'json'
+    class Workspace # just a forward declaration
+    end
+
+    class HTTPError < Exception
+    end
+
+    class NotFoundError < HTTPError
+    end
+
+    class ServerError < HTTPError
+    end
+
+    class AuthError < HTTPError
+    end
+
+    # Decorates URI::* with a params method that parses the query
+    # into a hash of parameters.
+    # Frankly this should be in URI::* and I am very tempted to
+    # monkey-patch it in there but Erik held me back. :)
+    class AugmentedURI
+      def initialize(url_string)
+        @delegate = URI.parse(url_string)
+      end
+
+      def method_missing(*args, &block)
+        @delegate.send(*args,&block)
+      end
+
+      def params
+        Hash[ @delegate.query.split('&').map {|x| x.split('=')} ]
+      end
+    end
+
+    class RestAdapter
+      def rest_post(path, params = {})
+        raise "you must override rest_post in subclasses"
+      end
+
+      def rest_get(path, params = {})
+        raise "you must override rest_get in subclasses"
+      end
+    end
+
+    class ServerRestAdapter < RestAdapter
+      require 'rest-client'
+
+
+      @@BASE_URLS = { :development => "http://localhost:3000",
+                      :preview => "https://bridge-preview.decisiongrid.com/",
+                      :production => "https://app.decisiongrid.com/" }
+
+      def initialize
+        @environment = select_environment
+        # FIXME:  Remove this once the server has been made less picky.
+        # HACK
+        # Prior to 12/2013, the server rejected all requests from any
+        # unsupported browser.  Forging chrome identity was a hack
+        # workaround for this ill-advised "feature" (bug).
+        @user_agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/28.0.1500.95 Safari/537.36'
+      end
+
+      def rest_post(path, params = {})
+        full_url = "#{base_url}/#{path}"
+        debug_puts "about to post to #{full_url} with #{params.to_json}"
+        response = ::RestClient.post(full_url, params.to_json,
+                                     { :content_type => :json,
+                                       :accept => :json,
+                                       :user_agent => @user_agent},
+                                     &method(:permit_redirects))
+         debug_puts "post response was #{response}"
+        process_rest_response(response)
+      end
+
+      def rest_get(path, params = {})
+        url_params_list = []
+        params.each { |k,v| url_params_list << "#{k}=#{v}" } 
+        url_params = url_params_list.join('&')
+        full_url = (path =~ /^https?:\/\//) ? path : "#{base_url}/#{path}"
+        full_url += ("?#{url_params}") if url_params.length > 0
+        debug_puts "about to get #{full_url}"
+        response = RestClient.get(full_url, 
+                                  { :content_type => :json,
+                                    :accept => :json, :user_agent => @user_agent},
+                                     &method(:permit_redirects))
+        debug_puts "get response was #{response}"
+        process_rest_response(response)
+      end
+
+      def rest_delete(path, params = {})
+        url_params_list = []
+        params.each { |k,v| url_params_list << "#{k}=#{v}" } 
+        url_params = url_params_list.join('&')
+        full_url = "#{base_url}/#{path}"
+        full_url += ("?#{url_params}") if url_params.length > 0
+        debug_puts "about to delete #{full_url}"
+        response = RestClient.delete(full_url,
+                                     { :content_type => :json,
+                                       :accept => :json,
+                                       :user_agent => @user_agent},
+                                     &method(:permit_redirects))
+        debug_puts "delete response was #{response}"
+        process_rest_response(response, expect_json = false)
+      end
+
+      protected
+        attr_accessor :environment
+
+        # A block to pass to RestClient transactions that prevents them from freaking out
+        # about redirect responses.
+        def permit_redirects(response,request,result,&block)
+          redirect_response_codes = [301, 302, 307]
+          if redirect_response_codes.include? response.code
+            return response # do not throw exception just because of redirect 
+          else
+            response.return!(request,result,&block) # do the usual thing for all other cases
+          end
+        end
+
+
+        def select_environment
+          env_str = ENV.include?('DGRID_ENV') ? ENV['DGRID_ENV'] : 'development'
+          case env_str.downcase
+          when 'development'
+            return :development
+          when 'preview'
+            return :preview
+          when 'production'
+            return :production
+          else
+            raise "invalid DGRID_ENV: #{env_str}"
+          end
+        end
+
+        def base_url
+          @@BASE_URLS[@environment]
+        end
+
+        def process_rest_response(response, expect_json = true)
+          case response.code
+            # TODO enumerate more codes if needed
+            when 400
+              raise NotFoundError
+            when 401
+              raise AuthError
+            when 500..599
+              raise ServerError
+            when 200..299
+              # various success codes
+            when 300..308
+              # TODO:  should we really be accepting all of these
+              #        redirects as success?
+              return Hash.new # avoid json parsing errors below
+            else
+              raise HTTPError
+          end
+          if expect_json
+            json = response.body
+            obj = JSON.parse(json)
+            obj
+          else
+            response.body
+          end
+        end
+
+        def debug_puts(message)
+          STDERR.puts message
+        end
+
+    end
+
+    class Connection
+      include ::Dgrid::ArgumentValidation
+      include ::Dgrid::SetMembersFromHash
+
+      @@default_rest_adapter = ServerRestAdapter
+      def self.default_rest_adapter=(new_default)
+        @@default_rest_adapter = new_default
+      end
+
+      option :username, String, :required
+      option :password, String, :required
+      option :rest_adapter, RestAdapter
+      def initialize(options, &block)
+        @auth, other_members = split_hash(options,[:username,:password])
+        set_members_from_hash(other_members)
+        @rest_adapter ||= @@default_rest_adapter.new
+
+        confirm_authentication
+        yield self if block_given?
+      end
+
+
+      argument :name, String
+      def create_workspace(name, &block)
+        workspace = Workspace.new(self,name)
+        if has_multi_workspace?
+          workspace_params = rest_post('/workspaces', :name => name)
+          workspace.id = workspace_params['id']
+          @workspaces_response = nil # clear cache of workspaces_response
+        else
+          workspace.id = '0'
+        end
+        yield workspace if block_given?
+        workspace
+      end
+
+      #argument :entity, Entity
+      def create_entity(entity, workspace_id)
+        singular_name = entity.class.name.split('::').last.downcase # e.g Dgrid::API::Person => 'person'
+        plural_name = entity.class.pluralized
+        path_parts =[plural_name]
+        if has_multi_workspace?
+          path_parts = ['workspaces',workspace_id ] + path_parts
+        end
+        path = path_parts.join('/')
+        params = entity.to_hash
+        returned_params = rest_post(path,params)
+        entity_params = returned_params[singular_name]
+        raise "Did not get an id for new #{singular_name} #{entity.to_s} in #{entity_params.to_s}" unless entity_params.include?("id") && entity_params["id"]
+        entity.id = entity_params["id"]
+        entity
+      end
+
+      #argument :entity, Entity
+      #argument :workspace_id, String
+      def delete_entity_from_workspace(entity,workspace_id)
+        raise "Entity must have id to be deleted" unless entity.id
+        plural_name = entity.class.pluralized
+        path_parts =[plural_name, entity.id]
+        if has_multi_workspace?
+          path_parts = ['workspaces',workspace_id ] + path_parts
+        end
+        path = path_parts.join('/')
+        returned_params = rest_delete(path)
+      end
+
+
+      #argument :entity1, Entity
+      #argument :entity2, Entity
+      #argument :workspace_id, String
+      #option :link_type, String
+      def create_link(entity1, entity2, workspace_id, options)
+        # FIXME  It is completely unknown if this is the correct url structure
+        raise UnimplementedFunctionality
+        path_parts =['links']
+        params = {:left_guid => left_entity.id, :right_guid => right_entity.id, :description => options[:link_type]}
+        if has_multi_workspace?
+          path_parts = ['workspaces',workspace_id ] + path_parts
+        end
+        path = path_parts.join('/')
+        returned_params = rest_post(path,params)
+      end
+
+      def attach_file_to_entity_in_workspace(entity,filename,workspace_id)
+        # TODO Need to support other entity types than incident
+        raise "Only attaching to incidents supported at this time" unless entity.is_a?(Incident)
+
+        raise "File #{filename} not found" unless File.exists?(filename)
+        raise "Cannot attach files to an unsaved #{entity.class.name} " if entity.new_record?
+
+        # TODO Use workspace-independent route when it becomes available in the server
+        new_attachment_path = "/workspaces/#{workspace_id}/"
+        new_attachment_path += "#{entity.class.pluralized}/#{entity.id}/attachments/new"
+
+        presigned_post = rest_get(new_attachment_path)
+        post_response = post_form_with_file(presigned_post, filename)
+        redirected_to = post_response.header['location']
+        # Need to parse the redirect url so we can augment the params with
+        # auth info in rest_get.
+        redirected_url = AugmentedURI.new(redirected_to)
+        redirection_path = redirected_url.path
+        redirection_params = redirected_url.params
+        redirection_response = rest_get(redirection_path,redirection_params)
+      end
+
+
+      # Make entity subordinate to another within the specified workspace
+      # argument :entity, Entity
+      # argument :other, Entity
+      # argument :workspace_id, String
+      def subordinate_entity_to_other_entity_in_workspace(entity, other, workspace_id)
+        raise "Cannot subordiante unsaved #{entity} to #{other.type} #{other}" if entity.new_record?
+        raise "Cannot subordiante #{entity} to unsaved #{other.type} #{other}" if other.new_record?
+        entity_type = entity.class.pluralized
+        path_parts =[other.class.pluralized, other.id, entity_type, entity.id,'add']
+
+        if has_multi_workspace?
+          path_parts = ['workspaces',workspace_id ] + path_parts
+        end
+
+        path = path_parts.join('/')
+        returned_params = rest_get(path)
+      end
+
+      # list of current workspace objects
+      def workspaces
+        result = []
+        if has_multi_workspace?
+          workspaces_response = workspaces_rest_call
+          workspaces_list = workspaces_response['workspaces']
+          workspaces_list.each do |ws_params|
+            ws = Workspace.new(self, ws_params['name'], ws_params['description'])
+            ws.id = ws_params['id']
+            result << ws
+          end
+        else
+          ws =  Workspace.new(self,'Default Workspace');
+          ws.id = '0';
+          result << ws
+        end
+        result
+      end
+
+      def get_workspace(name)
+        workspace = self.workspaces.detect {|ws| ws.name.downcase == name.downcase}
+        yield workspace if block_given?
+        workspace
+      end
+
+      def get_in_workspace(workspace_id, type, base_path_parts = [] )
+        params = type == 'links'? {:flat => 1} : {}
+        path_parts = base_path_parts + [type]
+        if has_multi_workspace?
+          path_parts = ['workspaces', workspace_id] + path_parts
+        end
+        path = path_parts.join('/')
+        returned_params = rest_get(path, params)
+
+        # FIXME Remove this once the production bug is fixed.
+        # HACK
+        # This is a workaround for a production bug that existed for
+        # a few weeks in November of 2013
+        hack_to_work_around_lenses_items_index_change(returned_params)
+
+
+        # FIXME
+        # HACK
+        # This is an ugly hack to deal with inconsistency in REST results
+        # We should probably fix the REST routes and undo this
+        if returned_params.include?('item_ids') && base_path_parts.include?('lenses')
+          type = 'item_ids'
+        elsif returned_params.include?('incident_ids') && base_path_parts.include?('items')
+          type = 'incident_ids'
+        end
+        returned_params[type]
+      end
+
+      %w(items links people places organizations incidents keywords).each do |type|
+        define_method("get_#{type}_in_workspace") { |workspace_id|
+          get_in_workspace(workspace_id, type)
+        }
+      end
+
+      def get_incidents_in_item(workspace_id, item_id)
+        get_in_workspace(workspace_id, 'incidents', ['items', item_id])
+      end
+
+      def get_items_in_lens(workspace_id, lens_id)
+        get_in_workspace(workspace_id, 'items', ['lenses',lens_id])
+      end
+
+      protected
+        attr_accessor :auth, :rest_adapter
+        def workspaces_rest_call
+          if @workspaces_response.nil?
+            weird_required_params = {as_selection: 1}
+            @workspaces_response = rest_get('/workspaces', weird_required_params)
+          end
+          @workspaces_response
+        end
+
+        def post_form_with_file(post_form_params, filename)
+          raise "File #{filename} not found" unless File.exists?(filename)
+          post_params = post_form_params.clone
+          post_action = post_params.delete('action')
+          post_url = URI.parse(post_action)
+          mime_type = 'application/octet-stream'
+          post_params['file'] = UploadIO.new(File.new(filename), mime_type ,filename)
+          req = Net::HTTP::Post::Multipart.new(post_url.path, post_params)
+          n = Net::HTTP.new(post_url.host,post_url.port)
+          n.use_ssl = ('https' == post_url.scheme.downcase )
+          response = n.start do |http|
+            http.request(req)
+          end
+        end
+
+        def rest_post(path,params = {})
+          full_params = params.merge(@auth)
+          rest_adapter.rest_post(path,full_params)
+        end
+
+        def rest_get(path,params = {})
+          full_params = params.merge(@auth)
+          rest_adapter.rest_get(path,full_params)
+        end
+
+        def rest_delete(path,params = {})
+          full_params = params.merge(@auth)
+          rest_adapter.rest_delete(path,full_params)
+        end
+
+        def confirm_authentication
+          rest_get('/profile') # confirm proper credentials by trying to do something
+        end
+
+        def has_multi_workspace?
+          @workspace_mode ||= determine_workspace_mode
+          return :multi_workspace == @workspace_mode
+        end
+
+        def determine_workspace_mode
+          begin
+            workspaces_rest_call
+            return :multi_workspace
+          rescue NotFoundError => e
+            return :single_workspace
+          rescue RestClient::ResourceNotFound => e
+            return :single_workspace
+          end
+        end
+
+        # Transform data returned by one rest call back to its rightful
+        # form.
+        # There was a bug introduced in November 2013 which changed
+        # the structure of data returned by the /workspaces/id/lenses/id/items
+        # route.  This method modifies the returned_params to look the way
+        # they should ( {'items_ids' => {....} } )
+        def hack_to_work_around_lenses_items_index_change(returned_params)
+          if returned_params.include?('lensings') && !returned_params.include?('item_ids')
+            returned_params['item_ids'] = returned_params['lensings'].map {|lensing| lensing['item_id']}
+            # STDERR.puts "transformed this: #{returned_params['lensings'].inspect} into this: #{returned_params['item_ids']}"
+          end
+        end
+
+    end
+  end
+end # module Dgrid