hookercookerman-amee 0.0.2

data/lib/amee/profile_api/profile.rb

@@ -0,0 +1,39 @@
+require "amee/profile_api/profile_category"
+require "amee/profile_api/profile_item"
+module Amee
+  module ProfileApi
+    class Profile
+      include ::Amee::Model
+      self.path_prefix = "/profiles"
+      
+      attr_accessor :profile_date, :amount_per_month
+      list_populators :profile_categories => {:class => Amee::ProfileApi::ProfileCategory}
+      item_populators :data_category => {:class => Amee::ProfileApi::ProfileCategory}
+         
+      def self.create(session)
+         self.from_hash(session.new_profile, session)
+       end
+      
+      def create_profile_data_item(path_or_category, data_item_uid, params = {})
+        path = self.full_path + path_or_category.is_a?(String) ? "/#{path_or_category}" : "/#{path_or_category.full_path}"
+        Amee::ProfileApi::ProfileDataItem.create(session, path, data_item_uid, params)
+      end
+      
+      def get_profile_item(path, options = {})
+        session.get_profile_item(path, options)
+      end
+      
+      def update_profile_item(path, fields)
+        session.update_profile_item(full_path, :fields => fields)
+      end
+ 
+      def destroy
+        session.delete_profile(self.uid)
+      end
+      
+      def full_path
+        "#{self.class.path_prefix}/#{self.uid}"
+      end
+    end
+  end
+end

data/lib/amee/profile_api/profile_category.rb

@@ -0,0 +1,42 @@
+require "amee/profile_api/profile_item"
+require "amee/data_api/data_category"
+module Amee
+  module ProfileApi
+    class ProfileCategory
+      include ::Amee::Model
+      self.path_prefix = "/profiles"
+      
+      
+      attr_accessor :profile, :total_amount_per_month, :total_amount
+      
+      list_populators :profile_items => {:class => Amee::ProfileApi::ProfileItem},
+                      :profile_categories => {:class => Amee::ProfileApi::ProfileCategory}
+                      
+      item_populators :data_category => {:class => Amee::DataApi::DataCategory}
+              
+      def populate!
+        session.api_call(:get, "profile.category", self.full_path) do |response|
+          populate_from_hash!(response)
+        end
+      end
+      
+      def profile_uid
+        profile["uid"]
+      end
+      
+      def total_co2_unit
+        total_amount["unit"]
+      end
+      
+      def total_co2_value
+        total_amount["value"]
+      end
+      
+      def full_path
+        "#{self.class.path_prefix}/#{profile_uid}" + resource_path
+      end
+      
+    end
+    
+  end
+end

data/lib/amee/profile_api/profile_item.rb

@@ -0,0 +1,47 @@
+require "amee/data_api/data_category"
+require "amee/data_api/data_item_value"
+module Amee
+  module ProfileApi
+    class ProfileItem
+      include Amee::Model
+      self.path_prefix = "/profiles"
+      
+      attr_accessor :end, :amount, :data_item, :profile, :valid_from, :start_date, :end_date, :data_item, :amount_per_month, :total_amount
+      
+      list_populators :item_values => {:class => Amee::DataApi::DataItemValue}   
+      item_populators :data_category => {:class => Amee::DataApi::DataCategory},
+                      :item_definition => {:class => Amee::DataApi::ItemDefinition}
+        
+      
+      def self.create(session, path, data_item_uid, fields ={})
+        hash = session.create_profile_data_category(path, data_item_uid, :fields => fields)
+        self.from_hash(hash, session)
+      end
+      
+      def update(fields)
+        session.update_profile_item(self.full_path, :fields => fields)
+      end
+      
+      def destroy
+        session.delete_profile_item(self.full_path)
+      end
+      
+      def co2_unit
+        amount["unit"]
+      end
+      
+      def co2_value
+        amount["value"]
+      end
+      
+      def profile_uid
+        profile["uid"]
+      end
+      
+      def full_path
+        "#{self.class.path_prefix}/#{profile_uid}" + resource_path
+      end
+      
+    end
+  end
+end

data/lib/amee/service.rb

@@ -0,0 +1,78 @@
+require 'net/http'
+module Amee
+  class Service
+    include HTTParty
+    base_uri Amee::Config[:server]
+    format :json
+    
+    def initialize(auth_token)
+      @auth_token = auth_token
+    end
+    
+    def post(method, path, options = {})
+      perform_request(:post, method, path, options)
+    end
+    
+    def get(method, path, options = {})
+      perform_request(:get, method, path, options)
+    end
+    
+    def put(method, path, options = {})
+      perform_request(:put, method, path, options)
+    end
+    
+    def delete(method, path, options = {})
+      perform_request(:delete, method, path, options)
+    end
+    
+    def self.auth_token(username, password, path)
+      response = Net::HTTP.post_form(
+        URI.parse(self.base_uri + path),
+        {'username'=> username, 'password'=>password}
+      )
+      response['authToken']
+    end
+    
+    private
+    # we want to attach the authToken to the headers of the request 
+    # and then check the status code
+    def perform_request(type, method, path, options)
+      attach_headers(options)
+      response = self.class.send(type, path, options)
+      check_response(response.code)
+      Parser.parse(method, response)
+    end
+    
+    def attach_headers(options)
+      (options[:headers] ||= {}).merge!(
+        {
+          "authToken" => @auth_token, 
+          'Accept' => options[:accept] || Amee::Config[:accept]
+        }
+      )
+    end
+    
+    # checking the status code of the response; if we are not authenticated
+    # then authenticate the session
+    #
+    # @raise [Amee::PermissionDenied] if the status code is 403
+    # @raise [Amee::UnAuthorized] if a auth_token could not be generated
+    # @raise [Amee::SessionExpired] if a we get a 401
+    # @raise [Amee::UnknownError] if we get something strange
+    def check_response(code)
+      case code
+        when 200, 201
+          true
+        when 403
+          raise Amee::Session::PermissionDenied.new("You do not have permission to perform the requested operation")
+        when 401
+          raise Amee::Session::Expired.new("Session has expired")
+        when 404
+          raise Amee::Session::NotFound.new("resource was not found")
+        else
+          raise Amee::Session::UnknownError.new("super strange type unknown error")
+      end
+    end
+      
+  end
+end

data/lib/amee/session.rb

@@ -0,0 +1,222 @@
+module Amee
+  class Session
+    
+    class Expired < StandardError; end
+    class UnAuthorized < StandardError; end
+    class NotAuthenticated < StandardError; end
+    class PermissionDenied < StandardError; end
+    class NotFound < StandardError; end
+    class UnknownError < StandardError; end
+    attr_accessor :auth_token, :cache
+    
+    def self.create(username = nil, password = nil)
+      username ||= Amee::Config[:username]
+      password ||= Amee::Config[:password]
+      raise ArgumentError unless !username.nil? && !password.nil?
+      new(username, password)
+    end
+    
+    def initialize(username, password, authenticate = true)
+      @username = username
+      @password = password
+      @cache = create_cache_store if caching?
+      authenticate! if authenticate
+    end
+    
+    # We create a cache store vie using the config cache_store and parameters if 
+    # they exist; Moneta Stores are only supported
+    # @return [Moneta::Store]
+    def create_cache_store
+      @cache = Amee::Config[:cache_store].send(:new, *Amee::Config[:cache_store_parameters] || nil)
+    end
+    
+    # @return [Boolean] are we caching?
+    def caching?
+      Amee::Config[:cache]
+    end
+    
+    def authenticate!
+      @auth_token = nil
+      unless @auth_token = Amee::Service.auth_token(@username, @password, Amee::Config[:auth_path])
+        raise Amee::Session::UnAuthorized.new "Please provide your correct username and password. "
+      end
+    end
+    
+    def authenticated?
+      !@auth_token.nil?
+    end
+    
+    def service 
+      if authenticated?
+        @service ||= Amee::Service.new(@auth_token)
+      else
+        raise Amee::Session::NotAuthenticated.new "Session is not authenticated"
+      end
+    end
+    
+    # we send the service the HTTP method along with the parser we want to use 
+    # and the path 
+    #
+    # @param [Symbol] method the HTTP method that we want to use
+    # @param [String] parser_name the parser name we want to use
+    # @param [String] path 
+    # @param [Hash] options 
+    # @param [Boolean] use_auth_token NOTE not using this right now
+    def api_call_without_logging(method, parser_name, path, options, use_auth_token =true, &proc)
+      result = service.send(method, parser_name, path, options)
+      result = yield result if block_given?
+      store_resource(path,result, options[:cache]||{}) if method == :get && caching?
+      result
+    end
+    
+    
+    # this over long ie bad method is to either get the cache for a api call
+    # or actually call the amee api; if the session has expired we will try 
+    # to get a new one
+    def api_call(method, parser_name, path, options ={}, use_auth_token =true, &proc)
+      if (cache = @cache[path]) && caching?
+        return cache
+      else
+        attempts = 0
+        begin
+          if Amee::Config[:logging]
+            Amee::Logging.log_amee_api(method, parser_name, path, options) do
+              api_call_without_logging(method, parser_name, path, options, use_auth_token =true, &proc)
+            end
+          else
+            api_call_without_logging(method, parser_name, path, options, use_auth_token =true, &proc)
+          end
+        rescue Amee::Session::Expired
+          attempts +=1 
+          if attempts < 2
+            self.authenticate!
+            retry
+          else
+            raise
+          end
+        end
+      end
+    end
+        
+    # @return [Amee::DataApi::DataCategory]
+    def get_data_category(path, options = {})
+      api_call(:get, "data.category", path, options) do |response|
+        Amee::DataApi::DataCategory.from_hash(response, self)
+      end
+    end
+    
+    # @return [Amee::DataApi::DrillDown]
+    def drill(path, options = {})
+      api_call(:get, "data.drill", "#{path}/drill", :query => options[:selections]) do |response|
+        Amee::DataApi::DrillDown.from_hash(response, self)
+      end
+    end
+    
+    # @return [Amee::DataApi::DataItem]
+    def get_data_item(path, options = {})
+      api_call(:get, "data.item", path, options) do |response|
+        Amee::DataApi::DataItem.from_hash(response, self)
+      end
+    end
+    
+    # @return [Amee::DataApi::DataItemValue]
+    def get_data_item_value(path, options ={})
+      api_call(:get, "data.item_value", path, options) do |response|
+        Amee::DataApi::DataItemValue.from_hash(response, self)
+      end
+    end
+    
+    # @return [Amee::ProfileApi::Profile]
+    def create_profile
+      @cache.clear
+      api_call(:post, "create.profile", "/profiles", :query => {:profile => true}) do |response|
+        Amee::ProfileApi::Profile.from_hash(response, self)
+      end
+    end
+    
+    # @return [Amee::ProfileApi::Profile]
+    def get_profile(uid)
+      api_call(:get, "get.profile", "/profiles/#{uid}") do |response|
+        Amee::ProfileApi::Profile.from_hash(response, self)
+      end
+    end
+    
+    # @return [Amee::ProfileApi::ProfileItem]
+    def update_profile_item(path, options = {})
+      @cache.clear
+      api_call(:put, "profile_item", path, :query => {:representation => options[:representation] || true}.merge(options[:fields])) do |response|
+        Amee::ProfileApi::ProfileItem.from_hash(response, self)
+      end
+    end
+    
+    # @return [String] locaion of the new resource
+    def create_profile_item(path, uid, options = {})
+      @cache.clear
+      api_call(:post, "create.profile_item", path, 
+        :query => {:dataItemUid => uid}.merge(options[:fields])) do |response|
+          location = response.headers["location"]
+          location.is_a?(Array) ? location.first : location
+        end
+    end
+    
+    # does not create a profile object compared to the create version
+    # @return [Hash]
+    def new_profile
+      @cache.clear
+      api_call(:post, "create.profile", "/profiles", :query => {:profile => true}) do |response|
+        response
+      end
+    end
+    
+    # @return [Boolean]
+    def delete_profile(uid)
+      @cache.clear
+      api_call(:delete, "delete.profile", "/profiles/#{uid}") do |response|
+        true
+      end
+    end
+    
+    # @return [Boolean]
+    def delete_profile_item(path)
+      @cache.clear
+      api_call(:delete, "delete.profile_item", path) do |response|
+        true
+      end
+    end
+    
+    # @return [Amee::ProfileApi::ProfileCategory]
+    def get_profile_category(path, options = {})
+      api_call(:get, "profile_category", path, options) do |response|
+        Amee::ProfileApi::ProfileCategory.from_hash(response, self)
+      end
+    end
+    
+    # @return [Amee::ProfileApi::ProfileItem]
+    def get_profile_item(path, options = {})
+      api_call(:get, "profile_item", path, options) do |response|
+        Amee::ProfileApi::ProfileItem.from_hash(response, self)
+      end
+    end
+    
+    # @return [Array[Amee::Profile]]
+    def profiles
+      api_call(:get, "profiles", "/profiles") do |response|
+        response.map do |profile|
+          Amee::ProfileApi::Profile.from_hash(profile, self) unless profile.empty?
+        end
+      end
+    end
+    
+    # @return [Hash]
+    def get_raw(path, options = {})
+      api_call(:get, "raw", path)
+    end
+    
+    # @param [String] path the path of the resource
+    # @param [Hash] cache_options this is the cache options
+    def store_resource(path, result, cache_options = {})
+      @cache.store(path, result, :expires_in => cache_options[:expires_in] || Amee::Config[:expires_in])
+    end
+      
+  end
+end

data/lib/amee/utils/string.rb

@@ -0,0 +1,11 @@
+module Amee
+  module Utils
+    class String
+      def self.snake_case(string)
+        return string.downcase if string =~ /^[A-Z]+$/
+        string.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+          return $+.downcase
+      end
+    end 
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/amee.rb'}"
+puts "Loading amee gem"
+exec "#{irb} #{libs} --simple-prompt"