amee 2.0.25

data/lib/amee/data_category.rb

@@ -0,0 +1,196 @@
+require 'date'
+
+module AMEE
+  module Data
+    class Category < AMEE::Data::Object
+
+      def initialize(data = {})
+        @children = data ? data[:children] : []
+        @items = data ? data[:items] : []
+        super
+      end
+
+      attr_reader :children
+      attr_reader :items
+
+      def self.from_json(json)
+        # Parse json
+        doc = JSON.parse(json)
+        data = {}
+        data[:uid] = doc['dataCategory']['uid']
+        data[:created] = DateTime.parse(doc['dataCategory']['created'])
+        data[:modified] = DateTime.parse(doc['dataCategory']['modified'])
+        data[:name] = doc['dataCategory']['name']
+        data[:path] = doc['path']
+        data[:children] = []
+        doc['children']['dataCategories'].each do |child|
+          category_data = {}
+          category_data[:name] = child['name']
+          category_data[:path] = child['path']
+          category_data[:uid] = child['uid']
+          data[:children] << category_data
+        end
+        data[:items] = []
+        if doc['children']['dataItems']['rows']
+          doc['children']['dataItems']['rows'].each do |item|
+            item_data = {}
+            item.each_pair do |key, value|
+              item_data[key.to_sym] = value
+            end
+            data[:items] << item_data
+          end
+        end
+        # Create object
+        Category.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataCategory 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[:uid] = REXML::XPath.first(doc, "/Resources/DataCategoryResource/DataCategory/@uid").to_s
+        data[:created] = DateTime.parse(REXML::XPath.first(doc, "/Resources/DataCategoryResource/DataCategory/@created").to_s)
+        data[:modified] = DateTime.parse(REXML::XPath.first(doc, "/Resources/DataCategoryResource/DataCategory/@modified").to_s)
+        data[:name] = REXML::XPath.first(doc, '/Resources/DataCategoryResource/DataCategory/?ame').text
+        data[:path] = REXML::XPath.first(doc, '/Resources/DataCategoryResource//?ath').text || ""
+        data[:children] = []
+        REXML::XPath.each(doc, '/Resources/DataCategoryResource//Children/DataCategories/DataCategory') do |child|
+          category_data = {}
+          category_data[:name] = (child.elements['Name'] || child.elements['name']).text
+          category_data[:path] = (child.elements['Path'] || child.elements['path']).text
+          category_data[:uid] = child.attributes['uid'].to_s
+          data[:children] << category_data
+        end
+        data[:items] = []
+        REXML::XPath.each(doc, '/Resources/DataCategoryResource//Children/DataItems/DataItem') do |item|
+          item_data = {}
+          item_data[:uid] = item.attributes['uid'].to_s
+          item.elements.each do |element|
+            item_data[element.name.to_sym] = element.text
+          end
+          if item_data[:path].nil?
+            item_data[:path] = item_data[:uid]
+          end
+          data[:items] << item_data
+        end
+        # Create object
+        Category.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataCategory from XML data. Check that your URL is correct.\n#{xml}")
+      end
+      
+      def self.get(connection, path, orig_options = {})
+        unless orig_options.is_a?(Hash)
+          raise AMEE::ArgumentError.new("Third argument must be a hash of options!")
+        end
+        # Convert to AMEE options
+        options = orig_options.clone
+        if orig_options[:items_per_page]
+          options[:itemsPerPage] = orig_options[:items_per_page]
+        else
+          options[:itemsPerPage] = 10
+        end
+
+        # Load data from path
+        response = connection.get(path, options).body
+
+        # Parse data from response
+        if response.is_json?
+          cat = Category.from_json(response)
+        else
+          cat = Category.from_xml(response)
+        end
+        # Store connection in object for future use
+        cat.connection = connection
+        # Done
+        return cat
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataCategory. Check that your URL is correct.\n#{response}")
+      end
+      
+      def self.root(connection)
+        self.get(connection, '/data')
+      end
+      
+      def child(child_path)
+        AMEE::Data::Category.get(connection, "#{full_path}/#{child_path}")
+      end
+
+      def drill
+        AMEE::Data::DrillDown.get(connection, "#{full_path}/drill")
+      end
+
+      def item(options)
+        # Search fields - from most specific to least specific
+        item = items.find{ |x| (x[:uid] && x[:uid] == options[:uid]) ||
+                               (x[:name] && x[:name] == options[:name]) ||
+                               (x[:path] && x[:path] == options[:path]) ||
+                               (x[:label] && x[:label] == options[:label]) }
+        # Pass through some options
+        new_opts = {}
+        new_opts[:format] = options[:format] if options[:format]
+        item ? AMEE::Data::Item.get(connection, "#{full_path}/#{item[:path]}", new_opts) : nil
+      end
+
+      def self.create(category, options = {})
+
+        connection = category.connection
+        path = category.full_path
+        
+        # Do we want to automatically fetch the item afterwards?
+        get_item = options.delete(:get_item)
+
+        get_item = true if get_item.nil?
+        # Store format if set
+        format = options[:format]
+        unless options.is_a?(Hash)
+          raise AMEE::ArgumentError.new("Third argument must be a hash of options!")
+        end
+        # Send data to path
+        options[:newObjectType] = "DC"
+        response = connection.post(path, options)
+        if response['Location']
+          location = response['Location'].match("http://.*?(/.*)")[1]
+        else
+          category = Category.parse(connection, response.body)
+          location = category.full_path
+        end
+        if get_item == true
+          get_options = {}
+          get_options[:format] = format if format
+          return AMEE::Data::Category.get(connection, location, get_options)
+        else
+          return location
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't create DataCategory. Check that your information is correct.\n#{response}")
+      end
+
+     def self.delete(connection, path)
+       connection.delete(path)
+     rescue
+       raise AMEE::BadData.new("Couldn't delete DataCategory. Check that your information is correct.")
+     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 Category.get(connection, path)
+         else
+           return Category.parse(connection, response.body)
+         end
+       end
+     rescue
+       raise AMEE::BadData.new("Couldn't update Data Category. Check that your information is correct.")
+     end
+       
+    end
+  end
+end

data/lib/amee/data_item.rb

@@ -0,0 +1,218 @@
+module AMEE
+  module Data
+    class Item < AMEE::Data::Object
+
+      def initialize(data = {})
+        @values = data[:values]
+        @choices = data[:choices]
+        @label = data[:label]
+        @item_definition = data[:item_definition]
+        @total_amount = data[:total_amount]
+        @total_amount_unit = data[:total_amount_unit]
+        super
+      end
+
+      attr_reader :values
+      attr_reader :choices
+      attr_reader :label
+      attr_reader :item_definition
+      attr_reader :total_amount
+      attr_reader :total_amount_unit
+      
+      def self.from_json(json)
+        # Read JSON
+        doc = JSON.parse(json)
+        data = {}
+        data[:uid] = doc['dataItem']['uid']
+        data[:created] = DateTime.parse(doc['dataItem']['created'])
+        data[:modified] = DateTime.parse(doc['dataItem']['modified'])
+        data[:name] = doc['dataItem']['name']
+        data[:path] = doc['path']
+        data[:label] = doc['dataItem']['label']
+        data[:item_definition] = doc['dataItem']['itemDefinition']['uid']
+        # Read v2 total
+        data[:total_amount] = doc['amount']['value'] rescue nil
+        data[:total_amount_unit] = doc['amount']['unit'] rescue nil
+        # Read v1 total
+        if data[:total_amount].nil?
+          data[:total_amount] = doc['amountPerMonth'] rescue nil
+          data[:total_amount_unit] = "kg/month"
+        end
+        # Get values
+        data[:values] = []
+        doc['dataItem']['itemValues'].each do |value|
+          value_data = {}
+          value_data[:name] = value['name']
+          value_data[:path] = value['path']
+          value_data[:value] = value['value']
+          value_data[:drill] = value['itemValueDefinition']['drillDown'] rescue nil
+          value_data[:uid] = value['uid']
+          data[:values] << value_data
+        end
+        # Get choices
+        data[:choices] = []
+        doc['userValueChoices']['choices'].each do |choice|
+          choice_data = {}
+          choice_data[:name] = choice['name']
+          choice_data[:value] = choice['value']
+          data[:choices] << choice_data
+        end
+        # Create object
+        Item.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataItem from JSON. Check that your URL is correct.\n#{json}")
+      end
+      
+      def self.from_xml(xml)
+        # Parse data from response into hash
+        doc = REXML::Document.new(xml)
+        data = {}
+        data[:uid] = REXML::XPath.first(doc, "/Resources/DataItemResource/DataItem/@uid").to_s
+        data[:created] = DateTime.parse(REXML::XPath.first(doc, "/Resources/DataItemResource/DataItem/@created").to_s)
+        data[:modified] = DateTime.parse(REXML::XPath.first(doc, "/Resources/DataItemResource/DataItem/@modified").to_s)
+        data[:name] = (REXML::XPath.first(doc, '/Resources/DataItemResource/DataItem/Name') || REXML::XPath.first(doc, '/Resources/DataItemResource/DataItem/name')).text
+        data[:path] = (REXML::XPath.first(doc, '/Resources/DataItemResource/Path') || REXML::XPath.first(doc, '/Resources/DataItemResource/DataItem/path')).text
+        data[:label] = (REXML::XPath.first(doc, '/Resources/DataItemResource/DataItem/Label') || REXML::XPath.first(doc, '/Resources/DataItemResource/DataItem/label')).text
+        data[:item_definition] = REXML::XPath.first(doc, '/Resources/DataItemResource/DataItem/ItemDefinition/@uid').to_s
+        # Read v2 total
+        data[:total_amount] = REXML::XPath.first(doc, '/Resources/DataItemResource/Amount').text.to_f rescue nil
+        data[:total_amount_unit] = REXML::XPath.first(doc, '/Resources/DataItemResource/Amount/@unit').to_s rescue nil
+        # Read v1 total
+        if data[:total_amount].nil?
+          data[:total_amount] = REXML::XPath.first(doc, '/Resources/DataItemResource/AmountPerMonth').text.to_f rescue nil
+          data[:total_amount_unit] = "kg/month"
+        end
+        # Get values
+        data[:values] = []
+        REXML::XPath.each(doc, '/Resources/DataItemResource/DataItem/ItemValues/ItemValue') do |value|
+          value_data = {}
+          value_data[:name] = (value.elements['Name'] || value.elements['name']).text
+          value_data[:path] = (value.elements['Path'] || value.elements['path']).text
+          value_data[:value] = (value.elements['Value'] || value.elements['value']).text
+          value_data[:drill] = value.elements['ItemValueDefinition'].elements['DrillDown'].text == "false" ? false : true rescue nil
+          value_data[:uid] = value.attributes['uid'].to_s
+          data[:values] << value_data
+        end
+        # Get choices
+        data[:choices] = []
+        REXML::XPath.each(doc, '/Resources/DataItemResource/Choices/Choices/Choice') do |choice|
+          choice_data = {}
+          choice_data[:name] = (choice.elements['Name']).text
+          choice_data[:value] = (choice.elements['Value']).text || ""
+          data[:choices] << choice_data
+        end
+        # Create object
+        Item.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataItem 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
+        AMEE::Data::Item.parse(connection, response)
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataItem. Check that your URL is correct.\n#{response}")
+      end
+
+      def self.parse(connection, response)
+        # Parse data from response
+        if response.is_json?
+          item = Item.from_json(response)
+        else
+          item = Item.from_xml(response)
+        end
+        # Store connection in object for future use
+        item.connection = connection
+        # Done
+        return item
+      end
+
+      def self.create_batch_without_category(connection, category_path, items, options = {})
+        if connection.format == :json
+          options.merge! :profileItems => items
+          post_data = options.to_json
+        else
+        options.merge!({:DataItems => items})
+        post_data = options.to_xml(:root => "DataCategory", :skip_types => true, :skip_nil => true)
+        end
+        # Post to category
+        response = connection.raw_post(category_path, post_data).body
+        # Send back a category object containing all the created items
+        unless response.empty?
+          return AMEE::Data::Category.parse(connection, response)
+        else
+          return true
+        end
+      end
+
+      def self.create(category, options = {})
+        create_without_category(category.connection, category.full_path, options)
+      end
+
+      def self.create_without_category(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?
+        # Store format if set
+        format = options[:format]
+        unless options.is_a?(Hash)
+          raise AMEE::ArgumentError.new("Third argument must be a hash of options!")
+        end
+        # Create a data item!
+        options[:newObjectType] = "DI"
+        # Send data to path
+        response = connection.post(path, options)
+        if response['Location']
+          location = response['Location'].match("http://.*?(/.*)")[1]
+        else
+          category = Category.parse(connection, response.body)
+          location = category.full_path + "/" + category.items[0][:path]
+        end
+        if get_item == true
+          get_options = {}
+          get_options[:format] = format if format
+          return AMEE::Data::Item.get(connection, location, get_options)
+        else
+          return location
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't create DataItem. Check that your information 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 Item.get(connection, path)
+          else
+            return Item.parse(connection, response.body)
+          end
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't update DataItem. Check that your information is correct.\n#{response}")
+      end
+      
+      def update(options = {})
+        AMEE::Data::Item.update(connection, full_path, options)
+      end
+
+      def self.delete(connection, path)
+        connection.delete(path)
+      rescue
+        raise AMEE::BadData.new("Couldn't delete DataItem. Check that your information is correct.")
+      end
+      
+      def value(name_or_path_or_uid)
+        val = values.find{ |x| x[:name] == name_or_path_or_uid || x[:path] == name_or_path_or_uid || x[:uid] == name_or_path_or_uid}
+        val ? val[:value] : nil
+      end
+
+    end
+  end
+end

data/lib/amee/data_item_value.rb

@@ -0,0 +1,167 @@
+module AMEE
+  module Data
+    class ItemValue < AMEE::Data::Object
+
+      def initialize(data = {})
+        @value = data ? data[:value] : nil
+        @type = data ? data[:type] : nil
+        @from_profile = data ? data[:from_profile] : nil
+        @from_data = data ? data[:from_data] : nil
+        @start_date = data ? data[:start_date] : nil
+        super
+      end
+
+      attr_reader :type
+
+      def value
+        case type
+        when "DECIMAL"
+          @value.to_f
+        else
+          @value
+        end
+      end
+
+      def value=(val)
+        @value = val
+      end
+
+      def from_profile?
+        @from_profile
+      end
+      
+      def from_data?
+        @from_data
+      end
+      
+      def start_date
+        @start_date
+      end
+      
+      def self.from_json(json, path)
+        # Read JSON
+        doc = JSON.parse(json)['itemValue']
+        data = {}
+        data[:uid] = doc['uid']
+        data[:created] = DateTime.parse(doc['created'])
+        data[:modified] = DateTime.parse(doc['modified'])
+        data[:name] = doc['name']
+        data[:path] = path.gsub(/^\/data/, '')
+        data[:value] = doc['value']
+        data[:type] = doc['itemValueDefinition']['valueDefinition']['valueType']
+        data[:start_date] = DateTime.parse(doc['startDate']) rescue nil
+        # Create object
+        ItemValue.new(data)
+      rescue 
+        raise AMEE::BadData.new("Couldn't load DataItemValue from JSON. Check that your URL is correct.\n#{json}")
+      end
+      
+      def self.from_xml(xml, path)
+        # Read XML
+        doc = REXML::Document.new(xml)
+        data = {}
+        data[:uid] = REXML::XPath.first(doc, "/Resources/DataItemValueResource/ItemValue/@uid").to_s
+        data[:created] = DateTime.parse(REXML::XPath.first(doc, "/Resources/DataItemValueResource/ItemValue/@Created").to_s)
+        data[:modified] = DateTime.parse(REXML::XPath.first(doc, "/Resources/DataItemValueResource/ItemValue/@Modified").to_s)
+        data[:name] = REXML::XPath.first(doc, '/Resources/DataItemValueResource/ItemValue/Name').text
+        data[:path] = path.gsub(/^\/data/, '')
+        data[:value] = REXML::XPath.first(doc, '/Resources/DataItemValueResource/ItemValue/Value').text
+        data[:type] = REXML::XPath.first(doc, '/Resources/DataItemValueResource/ItemValue/ItemValueDefinition/ValueDefinition/ValueType').text
+        data[:from_profile] = REXML::XPath.first(doc, '/Resources/DataItemValueResource/ItemValue/ItemValueDefinition/FromProfile').text == "true" ? true : false
+        data[:from_data] = REXML::XPath.first(doc, '/Resources/DataItemValueResource/ItemValue/ItemValueDefinition/FromData').text == "true" ? true : false
+        data[:start_date] = DateTime.parse(REXML::XPath.first(doc, "/Resources/DataItemValueResource/ItemValue/StartDate").text) rescue nil
+        # Create object
+        ItemValue.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataItemValue from XML. 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
+        data = {}
+        value = ItemValue.parse(connection, response, path)
+        # Done
+        return value
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataItemValue. Check that your URL is correct.")
+      end
+
+      def save!
+        response = @connection.put(full_path, :value => value).body
+      end
+
+      def self.parse(connection, response, path) 
+        if response.is_json?
+          value = ItemValue.from_json(response, path)
+        else
+          value = ItemValue.from_xml(response, path)
+        end
+        # Store connection in object for future use
+        value.connection = connection
+        # Done
+        return value
+      rescue
+        raise AMEE::BadData.new("Couldn't load DataItemValue. Check that your URL is correct.\n#{response}")
+      end
+      
+      def self.create(data_item, options = {})
+        # Do we want to automatically fetch the item afterwards?
+        get_item = options.delete(:get_item)
+        get_item = true if get_item.nil?
+        # Store format if set
+        format = options[:format]
+        unless options.is_a?(Hash)
+          raise AMEE::ArgumentError.new("Third argument must be a hash of options!")
+        end
+        # Set startDate
+        if (options[:start_date])
+          options[:startDate] = options[:start_date].xmlschema
+          options.delete(:start_date)
+        end
+      
+        response = data_item.connection.post(data_item.full_path, options)
+        location = response['Location'].match("http://.*?(/.*)")[1]
+
+        if get_item == true
+          get_options = {}
+          get_options[:format] = format if format
+          return AMEE::Data::ItemValue.get(data_item.connection, location)
+        else
+          return location
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't create DataItemValue. Check that your information is correct.")
+      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 AMEE::Data::ItemValue.get(connection, path)
+          else
+            return AMEE::Data::ItemValue.parse(connection, response.body)
+          end
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't update DataItemValue. Check that your information is correct.\n#{response}")
+      end
+      
+      def update(options = {})
+        AMEE::Data::ItemValue.update(connection, full_path, options)
+      end
+      
+      def self.delete(connection, path)
+        connection.delete(path)
+      rescue
+        raise AMEE::BadData.new("Couldn't delete DataItemValue. Check that your information is correct.")
+      end      
+    
+    end
+  end
+end