amee 2.0.25

data/lib/amee/profile_item.rb

@@ -0,0 +1,374 @@
+module AMEE
+  module Profile
+    class Item < AMEE::Profile::Object
+
+      def initialize(data = {})
+        @values = data ? data[:values] : []
+        @total_amount = data[:total_amount]
+        @total_amount_unit = data[:total_amount_unit]
+        @start_date = data[:start_date] || data[:valid_from]
+        @end_date = data[:end_date] || (data[:end] == true ? @start_date : nil )
+        @data_item_uid = data[:data_item_uid]
+        super
+      end
+
+      attr_reader :values
+      attr_reader :total_amount
+      attr_reader :total_amount_unit
+      attr_reader :start_date
+      attr_reader :end_date
+      attr_reader :data_item_uid
+
+      # V1 compatibility
+      def valid_from
+        start_date
+      end
+      def end
+        end_date.nil? ? false : start_date == end_date
+      end
+
+      def duration
+        end_date.nil? ? nil : (end_date - start_date).to_f
+      end
+
+      def self.from_json(json)
+        # Parse json
+        doc = JSON.parse(json)
+        data = {}
+        data[:profile_uid] = doc['profile']['uid']
+        data[:data_item_uid] = doc['profileItem']['dataItem']['uid']
+        data[:uid] = doc['profileItem']['uid']
+        data[:name] = doc['profileItem']['name']
+        data[:path] = doc['path']
+        data[:total_amount] = doc['profileItem']['amountPerMonth']
+        data[:total_amount_unit] = "kg/month"
+        data[:valid_from] = DateTime.strptime(doc['profileItem']['validFrom'], "%Y%m%d")
+        data[:end] = doc['profileItem']['end'] == "false" ? false : true
+        data[:values] = []
+        doc['profileItem']['itemValues'].each do |item|
+          value_data = {}
+          item.each_pair do |key,value|
+            case key
+              when 'name', 'path', 'uid', 'value'
+                value_data[key.downcase.to_sym] = value
+            end
+          end
+          data[:values] << value_data
+        end
+        # Create object
+        Item.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ProfileItem from JSON data. Check that your URL is correct.\n#{json}")
+      end
+
+      def self.from_v2_json(json)
+        # Parse json
+        doc = JSON.parse(json)
+        data = {}
+        data[:profile_uid] = doc['profile']['uid']
+        data[:data_item_uid] = doc['profileItem']['dataItem']['uid']
+        data[:uid] = doc['profileItem']['uid']
+        data[:name] = doc['profileItem']['name']
+        data[:path] = doc['path']
+        data[:total_amount] = doc['profileItem']['amount']['value'].to_f
+        data[:total_amount_unit] = doc['profileItem']['amount']['unit']
+        data[:start_date] = DateTime.parse(doc['profileItem']['startDate'])
+        data[:end_date] = DateTime.parse(doc['profileItem']['endDate']) rescue nil
+        data[:values] = []
+        doc['profileItem']['itemValues'].each do |item|
+          value_data = {}
+          item.each_pair do |key,value|
+            case key
+              when 'name', 'path', 'uid', 'value', 'unit'
+                value_data[key.downcase.to_sym] = value
+              when 'perUnit'
+                value_data[:per_unit] = value
+            end
+          end
+          data[:values] << value_data
+        end
+        # Create object
+        Item.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ProfileItem from V2 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[:profile_uid] = REXML::XPath.first(doc, "/Resources/ProfileItemResource/Profile/@uid").to_s
+        data[:data_item_uid] = REXML::XPath.first(doc, "/Resources/ProfileItemResource/DataItem/@uid").to_s
+        data[:uid] = REXML::XPath.first(doc, "/Resources/ProfileItemResource/ProfileItem/@uid").to_s
+        data[:name] = REXML::XPath.first(doc, '/Resources/ProfileItemResource/ProfileItem/Name').text
+        data[:path] = REXML::XPath.first(doc, '/Resources/ProfileItemResource/Path').text || ""
+        data[:total_amount] = REXML::XPath.first(doc, '/Resources/ProfileItemResource/ProfileItem/AmountPerMonth').text.to_f rescue nil
+        data[:total_amount_unit] = "kg/month"
+        data[:valid_from] = DateTime.strptime(REXML::XPath.first(doc, "/Resources/ProfileItemResource/ProfileItem/ValidFrom").text, "%Y%m%d")
+        data[:end] = REXML::XPath.first(doc, '/Resources/ProfileItemResource/ProfileItem/End').text == "false" ? false : true
+        data[:values] = []
+        REXML::XPath.each(doc, '/Resources/ProfileItemResource/ProfileItem/ItemValues/ItemValue') do |item|
+          value_data = {}
+          item.elements.each do |element|
+            key = element.name
+            value = element.text
+            case key
+              when 'Name', 'Path', 'Value'
+                value_data[key.downcase.to_sym] = value              
+            end
+          end
+          value_data[:uid] = item.attributes['uid'].to_s
+          data[:values] << value_data
+        end
+        # Create object
+        Item.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ProfileItem from XML data. Check that your URL is correct.\n#{xml}")
+      end
+
+      def self.from_v2_xml(xml)
+        # Parse XML
+        doc = REXML::Document.new(xml)
+        data = {}
+        data[:profile_uid] = REXML::XPath.first(doc, "/Resources/ProfileItemResource/Profile/@uid").to_s
+        data[:data_item_uid] = REXML::XPath.first(doc, "/Resources/ProfileItemResource/DataItem/@uid").to_s
+        data[:uid] = REXML::XPath.first(doc, "/Resources/ProfileItemResource/ProfileItem/@uid").to_s
+        data[:name] = REXML::XPath.first(doc, '/Resources/ProfileItemResource/ProfileItem/Name').text
+        data[:path] = REXML::XPath.first(doc, '/Resources/ProfileItemResource/Path').text || ""
+        data[:total_amount] = REXML::XPath.first(doc, '/Resources/ProfileItemResource/ProfileItem/Amount').text.to_f rescue nil
+        data[:total_amount_unit] = REXML::XPath.first(doc, '/Resources/ProfileItemResource/ProfileItem/Amount/@unit').to_s rescue nil
+        data[:start_date] = DateTime.parse(REXML::XPath.first(doc, "/Resources/ProfileItemResource/ProfileItem/StartDate").text)
+        data[:end_date] = DateTime.parse(REXML::XPath.first(doc, "/Resources/ProfileItemResource/ProfileItem/EndDate").text) rescue nil
+        data[:values] = []
+        REXML::XPath.each(doc, '/Resources/ProfileItemResource/ProfileItem/ItemValues/ItemValue') do |item|
+          value_data = {}
+          item.elements.each do |element|
+            key = element.name
+            value = element.text
+            case key
+              when 'Name', 'Path', 'Value', 'Unit'
+                value_data[key.downcase.to_sym] = value
+              when 'PerUnit'
+                value_data[:per_unit] = value
+            end
+          end
+          value_data[:uid] = item.attributes['uid'].to_s
+          data[:values] << value_data
+        end
+        # Create object
+        Item.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ProfileItem from V2 XML data. Check that your URL is correct.\n#{xml}")
+      end
+
+      def self.from_v2_atom(response)
+        # Parse XML
+        doc = REXML::Document.new(response)
+        data = {}
+        data[:profile_uid] = REXML::XPath.first(doc, "/entry/@xml:base").to_s.match("/profiles/(.*?)/")[1]
+        #data[:data_item_uid] = REXML::XPath.first(doc, "/Resources/ProfileItemResource/DataItem/@uid").to_s
+        data[:uid] = REXML::XPath.first(doc, "/entry/id").text.match("urn:item:(.*)")[1]
+        data[:name] = REXML::XPath.first(doc, '/entry/title').text
+        data[:path] = REXML::XPath.first(doc, "/entry/@xml:base").to_s.match("/profiles/.*?(/.*)")[1]
+        data[:total_amount] = REXML::XPath.first(doc, '/entry/amee:amount').text.to_f rescue nil
+        data[:total_amount_unit] = REXML::XPath.first(doc, '/entry/amee:amount/@unit').to_s rescue nil
+        data[:start_date] = DateTime.parse(REXML::XPath.first(doc, "/entry/amee:startDate").text)
+        data[:end_date] = DateTime.parse(REXML::XPath.first(doc, "/entry/amee:endDate").text) rescue nil
+        data[:values] = []
+        REXML::XPath.each(doc, '/entry/amee:itemValue') do |item|
+          value_data = {}
+          value_data[:name] = item.elements['amee:name'].text
+          value_data[:value] = item.elements['amee:value'].text unless item.elements['amee:value'].text == "N/A"
+          value_data[:path] = item.elements['link'].attributes['href'].to_s
+          value_data[:unit] = item.elements['amee:unit'].text rescue nil
+          value_data[:per_unit] = item.elements['amee:perUnit'].text rescue nil
+          data[:values] << value_data
+        end
+        # Create object
+        Item.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ProfileItem from V2 ATOM data. Check that your URL is correct.\n#{response}")
+      end
+
+      def self.parse(connection, response)
+        # Parse data from response
+        if response.is_v2_json?
+          item = Item.from_v2_json(response)
+        elsif response.is_json?
+          item = Item.from_json(response)
+        elsif response.is_v2_atom?
+          item = Item.from_v2_atom(response)
+        elsif response.is_v2_xml?
+          item = Item.from_v2_xml(response)
+        else
+          item = Item.from_xml(response)
+        end
+        # Store connection in object for future use
+        item.connection = connection
+        # Done
+        return item
+      end
+
+     def self.get(connection, path, options = {})
+        unless options.is_a?(Hash)
+          raise AMEE::ArgumentError.new("Third argument must be a hash of options!")
+        end
+        # Convert to AMEE options
+        if options[:start_date] && category.connection.version < 2
+          options[:profileDate] = options[:start_date].amee1_month
+        elsif options[:start_date] && category.connection.version >= 2
+          options[:startDate] = options[:start_date].xmlschema
+        end
+        options.delete(:start_date)
+        if options[:end_date] && category.connection.version >= 2
+          options[:endDate] = options[:end_date].xmlschema
+        end
+        options.delete(:end_date)
+        if options[:duration] && category.connection.version >= 2
+          options[:duration] = "PT#{options[:duration] * 86400}S"
+        end
+        # Load data from path
+        response = connection.get(path, options).body
+        return Item.parse(connection, response)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ProfileItem. Check that your URL is correct.\n#{response}")
+      end
+
+      def self.create(category, data_item_uid, options = {})
+        create_without_category(category.connection, category.full_path, data_item_uid, options)
+      end
+
+      def self.create_without_category(connection, path, data_item_uid, 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 dates
+        if options[:start_date] && connection.version < 2
+          options[:validFrom] = options[:start_date].amee1_date
+        elsif options[:start_date] && connection.version >= 2
+          options[:startDate] = options[:start_date].xmlschema
+        end
+        if options[:end_date] && connection.version >= 2
+          options[:endDate] = options[:end_date].xmlschema
+        end        
+        if options[:duration] && connection.version >= 2
+          options[:duration] = "PT#{options[:duration] * 86400}S"
+        end
+        # Send data to path
+        options.merge! :dataItemUid => data_item_uid
+        response = connection.post(path, options)
+        if response['Location']
+          location = response['Location'].match("http://.*?(/.*)")[1]
+        else
+          category = Category.parse(connection, response.body, nil)
+          location = category.full_path + "/" + category.items[0][:path]
+        end
+        if get_item == true
+          get_options = {}
+          get_options[:returnUnit] = options[:returnUnit] if options[:returnUnit]
+          get_options[:returnPerUnit] = options[:returnPerUnit] if options[:returnPerUnit]
+          get_options[:format] = format if format
+          return AMEE::Profile::Item.get(connection, location, get_options)
+        else
+          return location
+        end
+      rescue
+        raise AMEE::BadData.new("Couldn't create ProfileItem. Check that your information is correct.\n#{response}")
+      end
+
+      def self.create_batch(category, items, options = {})
+        create_batch_without_category(category.connection, category.full_path, items)
+      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!({:ProfileItems => items})
+        post_data = options.to_xml(:root => "ProfileCategory", :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::Profile::Category.parse_batch(connection, response)
+        else
+          return true
+        end
+      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?
+        # Set dates
+        if options[:start_date] && connection.version < 2
+          options[:validFrom] = options[:start_date].amee1_date
+        elsif options[:start_date] && connection.version >= 2
+          options[:startDate] = options[:start_date].xmlschema
+        end
+        options.delete(:start_date)
+        if options[:end_date] && connection.version >= 2
+          options[:endDate] = options[:end_date].xmlschema
+        end        
+        options.delete(:end_date)
+        if options[:duration] && connection.version >= 2
+          options[:duration] = "PT#{options[:duration] * 86400}S"
+        end
+        # 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 ProfileItem. Check that your information is correct.\n#{response}")
+      end
+
+      def update(options = {})
+        AMEE::Profile::Item.update(connection, full_path, options)
+      end
+
+      def self.update_batch(category, items)
+        update_batch_without_category(category.connection, category.full_path, items)
+      end
+
+      def self.update_batch_without_category(connection, category_path, items)
+        if connection.format == :json
+          put_data = ({:profileItems => items}).to_json
+        else
+          put_data = ({:ProfileItems => items}).to_xml(:root => "ProfileCategory", :skip_types => true, :skip_nil => true)
+        end
+        # Post to category
+        response = connection.raw_put(category_path, put_data).body
+        # Send back a category object containing all the created items
+        unless response.empty?
+          return AMEE::Profile::Category.parse(connection, response, nil)
+        else
+          return true
+        end
+      end
+
+      def self.delete(connection, path)
+        connection.delete(path)
+      rescue
+        raise AMEE::BadData.new("Couldn't delete ProfileItem. Check that your information is correct.")
+      end
+
+      def value(name_or_path)
+        val = values.find{ |x| x[:name] == name_or_path || x[:path] == name_or_path}
+        val ? val[:value] : nil
+      end
+
+    end
+  end
+end

data/lib/amee/profile_item_value.rb

@@ -0,0 +1,106 @@
+module AMEE
+  module Profile
+    class ItemValue < AMEE::Profile::Object
+
+      def initialize(data = {})
+        @value = data ? data[:value] : nil
+        @type = data ? data[:type] : nil
+        @unit = data ? data[:unit] : nil
+        @per_unit = data ? data[:per_unit] : nil
+        @from_profile = data ? data[:from_profile] : nil
+        @from_data = data ? data[:from_data] : nil
+        super
+      end
+
+      attr_reader :type
+      attr_accessor :unit
+      attr_accessor :per_unit
+
+      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 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(/^\/profiles/, '')
+        data[:value] = doc['value']
+        data[:unit] = doc['unit']
+        data[:per_unit] = doc['perUnit']
+        data[:type] = doc['itemValueDefinition']['valueDefinition']['valueType']
+        # Create object
+        ItemValue.new(data)
+      rescue 
+        raise AMEE::BadData.new("Couldn't load ProfileItemValue 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/ProfileItemValueResource/ItemValue/@uid").to_s
+        data[:created] = DateTime.parse(REXML::XPath.first(doc, "/Resources/ProfileItemValueResource/ItemValue/@Created").to_s)
+        data[:modified] = DateTime.parse(REXML::XPath.first(doc, "/Resources/ProfileItemValueResource/ItemValue/@Modified").to_s)
+        data[:name] = REXML::XPath.first(doc, '/Resources/ProfileItemValueResource/ItemValue/Name').text
+        data[:path] = path.gsub(/^\/profiles/, '')
+        data[:value] = REXML::XPath.first(doc, '/Resources/ProfileItemValueResource/ItemValue/Value').text
+        data[:unit] = REXML::XPath.first(doc, '/Resources/ProfileItemValueResource/ItemValue/Unit').text rescue nil
+        data[:per_unit] = REXML::XPath.first(doc, '/Resources/ProfileItemValueResource/ItemValue/PerUnit').text rescue nil
+        data[:type] = REXML::XPath.first(doc, '/Resources/ProfileItemValueResource/ItemValue/ItemValueDefinition/ValueDefinition/ValueType').text
+        data[:from_profile] = REXML::XPath.first(doc, '/Resources/ProfileItemValueResource/ItemValue/ItemValueDefinition/FromProfile').text == "true" ? true : false
+        data[:from_data] = REXML::XPath.first(doc, '/Resources/ProfileItemValueResource/ItemValue/ItemValueDefinition/FromData').text == "true" ? true : false
+        # Create object
+        ItemValue.new(data)
+      rescue
+        raise AMEE::BadData.new("Couldn't load ProfileItemValue from XML. Check that your URL is correct.\n#{xml}")
+      end
+
+      def self.get(connection, path)
+        # Load Profile from path
+        response = connection.get(path).body
+        # Parse data from response
+        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 ProfileItemValue. Check that your URL is correct.\n#{response}")
+      end
+
+      def save!
+        options = {:value => value}
+        options[:unit] = unit if unit
+        options[:perUnit] = per_unit if per_unit
+        response = @connection.put(full_path, options).body
+      end
+
+    end
+  end
+end