amee 2.0.25

data/lib/amee/data_object.rb

@@ -0,0 +1,11 @@
+module AMEE
+  module Data
+    class Object < AMEE::Object
+    
+      def full_path
+        "/data#{@path}"
+      end
+
+    end
+  end
+end

data/lib/amee/drill_down.rb

@@ -0,0 +1,102 @@
+require 'cgi'
+
+module AMEE
+  module Data
+    class DrillDown < AMEE::Data::Object
+
+      def initialize(data = {})
+        @choices = data ? data[:choices] : []
+        @choice_name = data[:choice_name]
+        @selections = data ? data[:selections] : []
+        super
+      end
+
+      attr_reader :choices
+      attr_reader :choice_name
+      attr_reader :selections
+
+      def path=(path)
+        @path = path
+      end
+
+      def data_item_uid
+        return nil if @choice_name != 'uid' || @choices.size != 1
+        @choices[0]
+      end
+
+      def choose(choice)
+        options = []
+        @selections.each_pair do |key, value|
+          options << "#{CGI::escape(key)}=#{CGI::escape(value)}"
+        end
+        options << "#{CGI::escape(@choice_name)}=#{CGI::escape(choice)}"
+        query_string = options.join "&"        
+        DrillDown.get(connection, "#{full_path}?#{query_string}")
+      end
+
+      def self.from_json(json)
+        # Parse json
+        doc = JSON.parse(json)
+        data = {}
+        data[:choice_name] = doc['choices']['name']
+        choices = []
+        doc['choices']['choices'].each do |c|
+          choices << c['value']
+        end
+        data[:choices] = choices
+        selections = {}
+        doc['selections'].each do |c|
+          selections[c['name']] = c['value']
+        end
+        data[:selections] = selections
+        # Create object
+        DrillDown.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load DrillDown resource from JSON data. Check that your URL is correct.\n#{json}")
+      end
+      
+      def self.from_xml(xml)
+        # Parse XML
+        doc = REXML::Document.new(xml)
+        data = {}
+        data[:choice_name] = REXML::XPath.first(doc, "/Resources/DrillDownResource/Choices/?ame").text
+        choices = []
+        REXML::XPath.each(doc, "/Resources/DrillDownResource/Choices//Choice") do |c|
+          choices << (c.elements['Value'] || c.elements['value']).text
+        end
+        data[:choices] = choices
+        selections = {}
+        REXML::XPath.each(doc, "/Resources/DrillDownResource/Selections/Choice") do |c|
+          name = (c.elements['Name'] || c.elements['name']).text
+          value = (c.elements['Value'] || c.elements['value']).text
+          selections[name] = value
+        end
+        data[:selections] = selections
+        # Create object
+        DrillDown.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load DrillDown resource from XML data. Check that your URL is correct.\n#{xml}")
+      end
+
+      def self.get(connection, path)
+        # Load data from path
+        response = connection.get(path).body
+        # Parse data from response
+        if response.is_json?
+          drill = DrillDown.from_json(response)
+        else
+          drill = DrillDown.from_xml(response)
+        end
+        # Store path in drill object - response does not include it
+        drill.path = path.split('?')[0].gsub(/^\/data/, '')
+        # Store connection in object for future use
+        drill.connection = connection
+        # Done
+        return drill
+      rescue
+        raise AMEE::BadData.new("Couldn't load DrillDown resource. Check that your URL is correct (#{path}).\n#{response}")
+      end
+      
+    end
+  end
+end

data/lib/amee/exceptions.rb

@@ -0,0 +1,27 @@
+module AMEE
+  
+  class ArgumentError < Exception
+  end
+
+  class BadData < Exception
+  end
+  
+  class AuthFailed < Exception  
+  end
+
+  class PermissionDenied < Exception
+  end
+
+  class ConnectionFailed < Exception
+  end
+  
+  class NotFound < Exception
+  end
+  
+  class DuplicateResource < Exception
+  end
+
+  class UnknownError < Exception
+  end
+  
+end

data/lib/amee/item_definition.rb

@@ -0,0 +1,158 @@
+module AMEE
+  module Admin
+
+    class ItemDefinitionList < Array
+
+      def initialize(connection, options = {})
+        # Load data from path
+        response = connection.get('/definitions/itemDefinitions', options).body
+        # Parse data from response
+        if response.is_json?
+          # Read JSON
+          doc = JSON.parse(response)
+          @pager = AMEE::Pager.from_json(doc['pager'])
+          doc['itemDefinitions'].each do |p|
+            data = {}
+            data[:uid] = p['uid']
+            data[:name] = p['name']
+            # Create ItemDefinition
+            item_definition = ItemDefinition.new(data)
+            # Store in array
+            self << item_definition
+          end
+        else
+          # Read XML
+          doc = REXML::Document.new(response)
+          @pager = AMEE::Pager.from_xml(REXML::XPath.first(doc, '/Resources/ItemDefinitionsResource/Pager'))
+          REXML::XPath.each(doc, '/Resources/ItemDefinitionsResource/ItemDefinitions/ItemDefinition') do |p|
+            data = {}
+            data[:uid] = p.attributes['uid'].to_s
+            data[:name] = p.elements['Name'].text || data[:uid]
+            # Create ItemDefinition
+            item_definition = ItemDefinition.new(data)
+            # Store connection in ItemDefinition object
+            item_definition.connection = connection
+            # Store in array
+            self << item_definition
+          end
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't load ItemDefinition list.\n#{response}")
+      end
+
+      attr_reader :pager
+
+    end
+
+    class ItemDefinition < AMEE::Object
+
+      def initialize(data = {})
+        @name = data[:name]
+        super
+      end
+
+      attr_reader :name
+
+      def self.list(connection)
+        ItemDefinitionList.new(connection)
+      end
+
+      def self.parse(connection, response, is_list = true)
+        # Parse data from response
+        if response.is_json?
+          item_definition = ItemDefinition.from_json(response)
+        else
+          item_definition = ItemDefinition.from_xml(response, is_list)
+        end
+        # Store connection in object for future use
+        item_definition.connection = connection
+        # Done
+        return item_definition
+      end
+
+      def self.from_json(json)
+        # Read JSON
+        doc = JSON.parse(json)
+        data = {}
+        data[:uid] = doc['itemDefinition']['uid']
+        data[:created] = DateTime.parse(doc['itemDefinition']['created'])
+        data[:modified] = DateTime.parse(doc['itemDefinition']['modified'])
+        data[:name] = doc['itemDefinition']['name']
+        # Create object
+        ItemDefinition.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ItemDefinition from JSON. Check that your URL is correct.\n#{json}")
+      end
+
+      def self.from_xml(xml, is_list = true)
+        prefix = is_list ? "/Resources/ItemDefinitionsResource/" : "/Resources/ItemDefinitionResource/"
+        # Parse data from response into hash
+        doc = REXML::Document.new(xml)
+        data = {}
+        data[:uid] = REXML::XPath.first(doc, prefix + "ItemDefinition/@uid").to_s
+        data[:created] = DateTime.parse(REXML::XPath.first(doc, prefix + "ItemDefinition/@created").to_s)
+        data[:modified] = DateTime.parse(REXML::XPath.first(doc, prefix + "ItemDefinition/@modified").to_s)
+        data[:name] = REXML::XPath.first(doc, prefix + "ItemDefinition/Name").text
+        # Create object
+        ItemDefinition.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ItemDefinition from XML. Check that your URL is correct.\n#{xml}")
+      end
+
+      def self.get(connection, path, options = {})
+        # Load data from path
+        response = connection.get(path, options).body
+        # Parse response
+        item_definition = ItemDefinition.parse(connection, response, false)
+        # Done
+        return item_definition
+      rescue
+        raise AMEE::BadData.new("Couldn't load ItemDefinition. Check that your URL is correct.\n#{response}")
+      end
+
+      def self.update(connection, path, options = {})
+        # Do we want to automatically fetch the item afterwards?
+        get_item = options.delete(:get_item)
+        get_item = true if get_item.nil?
+        # Go
+        response = connection.put(path, options)
+        if get_item
+          if response.body.empty?
+            return ItemDefinition.get(connection, path)
+          else
+            return ItemDefinition.parse(connection, response.body)
+          end
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't update ItemDefinition. Check that your information is correct.\n#{response}")
+      end
+
+      def self.create(connection, options = {})
+        unless options.is_a?(Hash)
+          raise AMEE::ArgumentError.new("Second argument must be a hash of options!")
+        end
+        # Send data
+        response = connection.post("/definitions/itemDefinitions", options).body
+        # Parse response
+        item_definition = ItemDefinition.parse(connection, response)
+        # Get the ItemDefinition again
+        return ItemDefinition.get(connection, "/definitions/itemDefinitions/" + item_definition.uid)
+      rescue
+        raise AMEE::BadData.new("Couldn't create ItemDefinition. Check that your information is correct.\n#{response}")
+      end
+
+      def self.delete(connection, item_definition)
+        # Deleting takes a while... up the timeout to 120 seconds temporarily
+        t = connection.timeout
+        connection.timeout = 120
+        connection.delete("/definitions/itemDefinitions/" + item_definition.uid)
+        connection.timeout = t
+      rescue
+        raise AMEE::BadData.new("Couldn't delete ProfileItem. Check that your information is correct.")
+      end
+
+    end
+
+  end
+
+end

data/lib/amee/object.rb

@@ -0,0 +1,21 @@
+module AMEE
+  class Object
+    
+    def initialize(data = nil)
+      @uid = data ? data[:uid] : nil
+      @created = data ? data[:created] : Time.now
+      @modified = data ? data[:modified] : @created
+      @path = data ? data[:path] : nil
+      @name = data ? data[:name] : nil
+      @connection = nil
+    end
+    
+    attr_accessor :connection
+    attr_reader :uid
+    attr_reader :created
+    attr_reader :modified
+    attr_reader :path
+    attr_reader :name
+    
+  end
+end

data/lib/amee/pager.rb

@@ -0,0 +1,59 @@
+module AMEE
+  class Pager
+
+    def initialize(data)
+      @start = data[:start]
+      @from = data[:from]
+      @to = data[:to]
+      @items = data[:items]
+      @current_page = data[:current_page]
+      @requested_page = data[:requested_page]
+      @next_page = data[:next_page]
+      @previous_page = data[:previous_page]
+      @last_page = data[:last_page]
+      @items_per_page = data[:items_per_page]
+      @items_found = data[:items_found]
+    end
+
+    attr_reader :start
+    attr_reader :from
+    attr_reader :to
+    attr_reader :items
+    attr_reader :current_page
+    attr_reader :requested_page
+    attr_reader :next_page
+    attr_reader :previous_page
+    attr_reader :last_page
+    attr_reader :items_per_page
+    attr_reader :items_found
+
+    def self.from_xml(node)
+      return Pager.new({:start => node.elements["Start"].text.to_i,
+                        :from => node.elements["From"].text.to_i,
+                        :to => node.elements["To"].text.to_i,
+                        :items => node.elements["Items"].text.to_i,
+                        :current_page => node.elements["CurrentPage"].text.to_i,
+                        :requested_page => node.elements["RequestedPage"].text.to_i,
+                        :next_page => node.elements["NextPage"].text.to_i,
+                        :previous_page => node.elements["PreviousPage"].text.to_i,
+                        :last_page => node.elements["LastPage"].text.to_i,
+                        :items_per_page => node.elements["ItemsPerPage"].text.to_i,
+                        :items_found => node.elements["ItemsFound"].text.to_i})
+    end
+
+    def self.from_json(node)
+      return Pager.new({:start => node["start"],
+                        :from => node["from"],
+                        :to => node["to"],
+                        :items => node["items"],
+                        :current_page => node["currentPage"],
+                        :requested_page => node["requestedPage"],
+                        :next_page => node["nextPage"],
+                        :previous_page => node["previousPage"],
+                        :last_page => node["lastPage"],
+                        :items_per_page => node["itemsPerPage"],
+                        :items_found => node["itemsFound"]})
+    end
+
+  end
+end

data/lib/amee/profile.rb

@@ -0,0 +1,108 @@
+module AMEE
+  module Profile
+    class ProfileList < Array
+      
+      def initialize(connection, options = {})
+        # Load data from path
+        response = connection.get('/profiles', options).body
+        # Parse data from response
+        if response.is_json?
+          # Read JSON
+          doc = JSON.parse(response)
+          @pager = AMEE::Pager.from_json(doc['pager'])
+          doc['profiles'].each do |p|
+            data = {}
+            data[:uid] = p['uid']
+            data[:created] = DateTime.parse(p['created'])
+            data[:modified] = DateTime.parse(p['modified'])
+            data[:name] = p['name']
+            data[:path] = "/#{p['path']}"
+            # Create profile
+            profile = Profile.new(data)
+            # Store in array
+            self << profile
+          end
+        else
+          # Read XML
+          doc = REXML::Document.new(response)
+          @pager = AMEE::Pager.from_xml(REXML::XPath.first(doc, '/Resources/ProfilesResource/Pager'))
+          REXML::XPath.each(doc, '/Resources/ProfilesResource/Profiles/Profile') do |p|
+            data = {}
+            data[:uid] = p.attributes['uid'].to_s
+            data[:created] = DateTime.parse(p.attributes['created'].to_s)
+            data[:modified] = DateTime.parse(p.attributes['modified'].to_s)
+            data[:name] = p.elements['Name'].text || data[:uid]
+            data[:path] = "/#{p.elements['Path'].text || data[:uid]}"
+            # Create profile
+            profile = Profile.new(data)
+            # Store connection in profile object
+            profile.connection = connection
+            # Store in array
+            self << profile
+          end
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't load Profile list.\n#{response}")
+      end
+      
+      attr_reader :pager
+      
+    end
+
+    class Profile < AMEE::Profile::Object
+
+      # backwards compatibility
+      def self.list(connection)
+        ProfileList.new(connection)
+      end
+
+      def self.create(connection)
+        # Create new profile
+        response = connection.post('/profiles', :profile => true).body
+        # Parse data from response
+        if response.is_json?
+          # Read JSON
+          doc = JSON.parse(response)
+          p = doc['profile']
+          data = {}
+          data[:uid] = p['uid']
+          data[:created] = DateTime.parse(p['created'])
+          data[:modified] = DateTime.parse(p['modified'])
+          data[:name] = p['name']
+          data[:path] = p['path']
+          # Create profile
+          profile = Profile.new(data)
+          # Done
+          return profile
+        else
+          # Read XML
+          doc = REXML::Document.new(response)
+          p = REXML::XPath.first(doc, '/Resources/ProfilesResource/Profile')
+          data = {}
+          data[:uid] = p.attributes['uid'].to_s
+          data[:created] = DateTime.parse(p.attributes['created'].to_s)
+          data[:modified] = DateTime.parse(p.attributes['modified'].to_s)
+          data[:name] = p.elements['Name'].text || data[:uid]
+          data[:path] = p.elements['Path'].text || data[:uid]
+          # Create profile
+          profile = Profile.new(data)
+          # Store connection in profile object
+          profile.connection = connection
+          # Done
+          return profile
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't create Profile.\n#{response}")
+      end
+
+      def self.delete(connection, uid)
+        # Deleting profiles takes a while... up the timeout to 60 seconds temporarily
+        t = connection.timeout
+        connection.timeout = 60
+        connection.delete("/profiles/#{uid}")
+        connection.timeout = t
+      end
+
+    end
+  end
+end