hookercookerman-amee 0.0.2

data/lib/amee/data_api/data_category.rb

@@ -0,0 +1,50 @@
+require "amee/data_api/data_item"
+require "amee/data_api/item_definition"
+module Amee
+  module DataApi
+    class DataCategory
+      include Amee::Model
+      self.path_prefix = "/data"
+    
+      list_populators :data_categories => {:class => Amee::DataApi::DataCategory}, 
+                      :data_items => {:class => Amee::DataApi::DataItem}
+      item_populators :item_definition => {:class => Amee::DataApi::ItemDefinition}
+      
+      # essentially the parent category                
+      attr_accessor :data_category, :pager
+      
+      # we can only drill with a data_category that has data_items
+      #
+      # @param [Hash] selection of what we wish to drill down
+      #
+      # @return [Amee::DataApi::Drill] if we can drill down we get a drill object
+      # @return [nil] if we cannot drill then nil will be the name of the day
+      def drill(selections = {})
+        if can_drill?
+          session.drill(self.full_path, :selections => selections)
+        end
+      end
+      
+      def can_drill?
+        !data_items.empty?
+      end
+
+      
+      # lets delagate this one
+      def drill_down
+        item_definition && item_definition.drill_down
+      end
+      
+      def paginate(options = {})
+
+      end
+      
+      def populate!
+        session.api_call(:get, "data.category", self.full_path) do |response|
+          populate_from_hash!(response)
+        end
+      end
+      
+    end
+  end
+end

data/lib/amee/data_api/data_item.rb

@@ -0,0 +1,28 @@
+require "amee/data_api/data_item_value"
+require "amee/data_api/item_definition"
+module Amee
+  module DataApi
+    class DataItem
+      require "amee/data_api/data_category"
+      include Amee::Model
+      self.path_prefix  = "/data"
+
+          
+      attr_accessor :start_date, :end_date, :label, :choices, :kg_c_o2_per_k_wh, :source
+      list_populators :item_values => {:class => Amee::DataApi::DataItemValue}      
+      item_populators :data_category => {:class => Amee::DataApi::DataCategory},
+                        :item_definition => {:class => Amee::DataApi::ItemDefinition}
+        
+      def populate!
+        session.api_call(:get, "data.item", self.full_path) do |response|
+          populate_from_hash!(response)
+        end
+      end
+      
+      def kg_co2_per_kwh
+        kg_c_o2_per_k_wh
+      end
+    
+    end
+  end
+end

data/lib/amee/data_api/data_item_value.rb

@@ -0,0 +1,13 @@
+require "amee/data_api/item_value_definition"
+module Amee
+  module DataApi
+    class DataItemValue
+      include ::Amee::Model
+      self.path_prefix  = "/data"
+    
+      attr_accessor :display_name, :description, :value, :display_path, :unit, :per_unit, :data_item
+      item_populators :item_value_definition => {:class => Amee::DataApi::ItemValueDefinition}
+        
+    end
+  end
+end

data/lib/amee/data_api/drill_down.rb

@@ -0,0 +1,23 @@
+module Amee
+  module DataApi
+    class DrillDown
+      include ::Amee::Model
+      self.path_prefix  = "/data"
+      
+      # choices are an array of hashes with keys "value" and "name"
+      # same for the selections as well
+      attr_accessor :choice_name, :choices, :selections
+      item_populators :data_category => {:class => Amee::DataApi::DataCategory}
+      
+      def data_item_uid
+        if uid_found?
+          choices.first["value"]
+        end
+      end
+      
+      def uid_found?
+        choice_name == "uid"
+      end
+    end
+  end
+end

data/lib/amee/data_api/item_definition.rb

@@ -0,0 +1,11 @@
+module Amee
+  module DataApi
+    class ItemDefinition
+      include ::Amee::Model
+      path_prefix = "/data"
+      
+      attr_accessor :drill_down
+      
+    end
+  end
+end

data/lib/amee/data_api/item_value_definition.rb

@@ -0,0 +1,13 @@
+require "amee/data_api/value_definition"
+module Amee
+  module DataApi
+    class ItemValueDefinition
+      include Amee::Model
+      self.path_prefix = "/data"
+    
+      attr_accessor :from_profile, :from_data
+      item_populators :value_definition => {:class => Amee::DataApi::ValueDefinition}
+    
+    end
+  end
+end

data/lib/amee/data_api/value_definition.rb

@@ -0,0 +1,10 @@
+module Amee
+  module DataApi
+    class ValueDefinition
+      include ::Amee::Model
+      self.path_prefix = "/data"
+    
+      attr_accessor :value_type, :description
+    end
+  end
+end

data/lib/amee/logging.rb

@@ -0,0 +1,43 @@
+# Approach taken from facebookers logging
+# need to really look into what we want from Amee logging
+require 'benchmark'
+module Amee
+  @@logger = nil
+  def self.logger=(logger)
+    @@logger = logger
+  end
+  def self.logger
+    @@logger
+  end
+
+  module Logging
+    def self.log_amee_api(method, parser_name, path, options)
+      message = method 
+      dump = format_da_dump(parser_name, path, options)
+      if block_given?
+        result = nil
+        seconds = Benchmark.realtime { result = yield }
+        log_info(message, dump, seconds) 
+        result
+      else
+        log_info(message, dump) 
+        nil
+      end
+    rescue Exception => e
+      exception = "#{e.class.name}: #{e.message}: #{dump}"
+      log_info(message, exception)
+      raise
+    end
+    
+    def self.format_da_dump(parser_name, path, options)
+      "AMEE: PARSER NAME: #{parser_name} PATH: #{path} OPTIONS: #{options.inspect}"
+    end
+    
+    def self.log_info(message, dump, seconds = 0)
+      return unless Amee.logger
+      log_message = "#{message} (#{seconds}) #{dump}"
+      Amee.logger.info(log_message)
+    end
+    
+  end  
+end

data/lib/amee/model.rb

@@ -0,0 +1,128 @@
+# Approach taken from facebooker
+module Amee
+  module Model
+    def self.included(base)
+      base.extend ClassMethods
+      base.__send__(:attr_writer, :session)
+      base.__send__(:attr_accessor, :path)
+      base.__send__(:attr_accessor, :uid)
+      base.__send__(:attr_accessor, :name)
+      base.__send__(:attr_accessor, :modified)
+      base.__send__(:attr_accessor, :created)
+      base.__send__(:attr_accessor, :resource_path)
+      
+      base.class_eval do
+        class  << base; attr_reader :lazy_populators end
+        class  << base; attr_accessor :path_prefix end
+        path_prefix = ""
+      end
+    end
+    
+    module ClassMethods
+
+      def from_hash(hash, session = nil)
+        instance = new(hash, session)
+        yield instance if block_given?
+        instance
+      end
+      
+      def item_populators(hash)
+        @lazy_populators ||= [] << hash.keys
+        populator_getters(hash.keys)
+        hash.each_pair do |key, value|
+          
+          define_method("#{key}=") do |definition|
+            if session && !definition.nil?
+              if self.resource_path
+                definition["resource_path"] = self.resource_path+"/#{definition["path"]}" 
+              end
+              instance_variable_set("@#{key}", value[:class].new(definition, session))
+            end 
+          end
+          
+        end
+      end
+      
+      def list_populators(hash)
+        @lazy_populators ||= [] << hash.keys
+        populator_getters(hash.keys)
+        hash.each_pair do |key, value|
+          
+          define_method("#{key}=") do |list|
+            instance_variable_set("@#{key}", list.map do |item|
+              if self.resource_path
+                item["resource_path"] = self.resource_path+"/#{item["path"]}" 
+              end
+              value[:class].new(item, session)
+            end) if session
+          end
+            
+        end
+      end
+      
+      def populator_getters(pops)
+        pops.each do |symbol|
+           define_method(symbol) do
+             if !populated? && self.resource_path
+               populate! 
+             end
+             instance_variable_get("@#{symbol}")
+           end
+         end
+      end
+      
+    end # ClassMethods
+    
+      def session
+        @session || (raise "Must bind this object to a Amee session before using")
+      end
+
+      def initialize(hash = {}, session = nil)
+        @session = session
+        populate_from_hash!(hash)
+      end
+      
+      def full_path
+        self.class.path_prefix + resource_path
+      end
+      
+      def populated?
+        @populated && lazy_populators_populated?
+      end
+      
+      def populate!
+        raise NotImplementError, "#{self.class} included me and has not overriden me"
+      end
+      
+      def populate_from_hash!(hash)
+        unless hash.nil? || hash.empty?
+          populate_paths(hash["resource_path"], hash["path"])
+          hash.each do |key, value|
+            set_attr_method = "#{Amee::Utils::String.snake_case(key)}="
+            if !value.nil? && respond_to?(set_attr_method)
+              self.__send__(set_attr_method, value) 
+            else
+              # attempt to set attribute basically
+            end
+          end      
+          @populated = true
+        end
+      end
+      
+      # we want the resource paths populated along with the path
+      # before we populate any other attribute as
+      # they may use these attributes
+      def populate_paths(resource_path, path)
+        self.resource_path, self.path = resource_path, path
+      end
+      
+      # if the all the lazy populators have been set then
+      # we now when are populated!
+      def lazy_populators_populated?
+        if self.class.lazy_populators
+          self.class.lazy_populators.find_all {|pop| !instance_variable_get("@#{pop}").nil?} == self.class.lazy_populators
+        end
+      end
+      
+  end
+end

data/lib/amee/parser.rb

@@ -0,0 +1,137 @@
+# Approach taken from facebooker
+module Amee
+  class Parser
+    def self.parse(method, data)
+      parser = Parser::PARSERS[method]
+      parser.process(
+        data
+      )
+    end
+  end
+  
+  class DataCategory < Parser
+    def self.process(data)
+      category = data["dataCategory"]
+      parent_category = data["dataCategory"]["dataCategory"] if data["dataCategory"]
+      pager = {"pager" => data["children"].delete("pager")}
+      categories = {"data_categories" => data["children"].delete("dataCategories")}
+      data_items = {"data_items" => data["children"]["dataItems"].delete("rows")} if data["children"]["dataItems"]
+      category.merge(categories).
+      merge(data_items).
+      merge(pager).
+      merge({"resource_path" => data["path"]})
+    end
+  end
+  
+  class DataItem < Parser
+    def self.process(data)
+      data_item = data["dataItem"]
+      item_values = {"item_values" => data["dataItem"].delete("itemValues")}
+      data_item.merge(item_values).
+      merge({"choices" => data["userValueChoices"]["choices"]}).
+      merge({"resource_path" => data["path"]})
+    end
+  end
+  
+  class DataItemValue < Parser
+    def self.process(data)
+      data_item_value = data["itemValue"]
+      data_item_value.merge({"resource_path" => data["path"]})
+    end
+  end
+  
+  class Drill < Parser
+    def self.process(data)
+      choices = {"choices", data["choices"].delete("choices")}
+      data.merge(choices).merge({"choice_name" => data["choices"].delete("name")})
+    end
+  end
+  
+  class Profiles < Parser
+    def self.process(data)
+      data["profiles"]
+    end
+  end
+  
+  class ProfileCategory < Parser
+    def self.process(data)
+      profile_categories = {"profile_categories" => data["children"].delete("dataCategories")}
+      profile_items = {"profile_items" => data["children"].delete("profileItems")}
+      data.merge(profile_items).merge(profile_categories).
+      merge({"resource_path" => data["path"]})
+    end
+  end
+  
+  class ProfileItem < Parser
+    def self.process(data)
+      data["profileItem"].merge({"resource_path" => data["path"]})
+    end
+  end
+  
+  class CreateProfile < Parser
+    def self.process(data)
+      data["profile"].
+      merge({"resource_path" => data["path"]})
+    end
+  end
+  
+  class UpdateProfile < Parser
+    def self.process(data)
+      data["profile"].
+      merge({"resource_path" => data["path"]})
+    end
+  end
+  
+  class DeleteProfile < Parser
+    def self.process(data)
+      data
+    end
+  end
+  
+  class GetProfile < Parser
+    def self.process(data)
+      categories = {"profile_categories" => data["children"].delete("dataCategories")}
+      data["profile"].merge(categories).
+      merge({"resource_path" => data["path"]})
+    end
+  end
+  
+  class CreateProfileItem < Parser
+    def self.process(data)
+      data
+    end
+  end
+  
+  class DeleteProfileItem < Parser
+    def self.process(data)
+      data
+    end
+  end
+  
+  
+  class Raw < Parser
+    def self.process(data)
+      data
+    end
+  end
+  
+  class Parser
+    PARSERS = {
+      'data.category' => DataCategory,
+      'data.item' => DataItem,
+      "data.item_value" => DataItemValue,
+      "raw" => Raw,
+      "profiles" => Profiles,
+      "create.profile" =>CreateProfile,
+      "update.profile" => UpdateProfile,
+      "delete.profile" => DeleteProfile,
+      "create.profile_item" => CreateProfileItem,
+      "profile_category" => ProfileCategory,
+      "profile_item" => ProfileItem,
+      "delete.profile_item" => DeleteProfileItem,
+      "get.profile" => GetProfile,
+      "profile.category" => ProfileCategory,
+      "data.drill" => Drill
+    }
+  end
+end