harvested 0.3.3 → 0.4.0

data/lib/ext/date.rb

@@ -0,0 +1,9 @@
+# Shamelessly ripped from https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/date/conversions.rb
+
+unless ::Date.respond_to?(:to_time)
+  class ::Date
+    def to_time(*)
+      ::Time.utc(year, month, day)
+    end
+  end
+end

data/lib/ext/hash.rb

@@ -0,0 +1,17 @@
+# Shamelessly ripped from https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/keys.rb
+
+unless Hash.respond_to?(:stringify_keys)
+  class Hash
+    # Return a new hash with all keys converted to strings.
+    def stringify_keys
+      dup.stringify_keys!
+    end
+    
+    def stringify_keys!
+      keys.each do |key|
+        self[key.to_s] = delete(key)
+      end
+      self
+    end
+  end
+end

data/lib/ext/time.rb

@@ -0,0 +1,5 @@
+unless Time.respond_to?(:to_time)
+  class Time
+    def to_time; self; end
+  end
+end

data/lib/harvest/api/account.rb

@@ -8,7 +8,14 @@ module Harvest
       # @return [Harvest::RateLimitStatus]
       def rate_limit_status
         response = request(:get, credentials, '/account/rate_limit_status')
-        Harvest::RateLimitStatus.parse(response.body)
+        Harvest::RateLimitStatus.parse(response.body).first
+      end
+      
+      # Returns the current logged in user
+      # @return [Harvest::User]
+      def who_am_i
+        response = request(:get, credentials, '/account/who_am_i')
+        Harvest::User.parse(response.body).first
       end
     end
   end

data/lib/harvest/api/base.rb

@@ -2,11 +2,11 @@ module Harvest
   module API
     class Base
       attr_reader :credentials
-      
+
       def initialize(credentials)
         @credentials = credentials
       end
-      
+
       class << self
         def api_model(klass)
           class_eval <<-END
@@ -16,27 +16,49 @@ module Harvest
           END
         end
       end
-      
+
       protected
         def request(method, credentials, path, options = {})
-          response = HTTParty.send(method, "#{credentials.host}#{path}", :query => options[:query], :body => options[:body], :headers => {"Accept" => "application/xml", "Content-Type" => "application/xml; charset=utf-8", "Authorization" => "Basic #{credentials.basic_auth}", "User-Agent" => "Harvestable/#{Harvest::VERSION}"}.update(options[:headers] || {}), :format => :plain)
+          params = {}
+          params[:path] = path
+          params[:options] = options
+          params[:method] = method
+
+          response = HTTParty.send(method, "#{credentials.host}#{path}",
+            :query => options[:query],
+            :body => options[:body],
+            :format => :plain,
+            :headers => {
+              "Accept" => "application/json",
+              "Content-Type" => "application/json; charset=utf-8",
+              "Authorization" => "Basic #{credentials.basic_auth}",
+              "User-Agent" => "Harvestable/#{Harvest::VERSION}",
+            }.update(options[:headers] || {})
+          )
+
+          params[:response] = response.inspect.to_s
+
           case response.code
           when 200..201
             response
           when 400
-            raise Harvest::BadRequest.new(response)
+            raise Harvest::BadRequest.new(response, params)
           when 404
-            raise Harvest::NotFound.new(response)
+            raise Harvest::NotFound.new(response, params)
           when 500
-            raise Harvest::ServerError.new(response)
+            raise Harvest::ServerError.new(response, params)
           when 502
-            raise Harvest::Unavailable.new(response)
+            raise Harvest::Unavailable.new(response, params)
           when 503
-            raise Harvest::RateLimited.new(response)
+            raise Harvest::RateLimited.new(response, params)
           else
-            raise Harvest::InformHarvest.new(response)
+            raise Harvest::InformHarvest.new(response, params)
           end
         end
+
+        def of_user_query(user)
+          query = user.nil? ? {} : {"of_user" => user.to_i}
+        end
     end
   end
 end

data/lib/harvest/api/contacts.rb

@@ -12,7 +12,7 @@ module Harvest
           request(:get, credentials, "/contacts")
         end
         
-        api_model.parse(response.body)
+        api_model.parse(response.parsed_response)
       end
     end
   end

data/lib/harvest/api/expenses.rb

@@ -5,13 +5,12 @@ module Harvest
       
       include Harvest::Behavior::Crud
       
-      def all(date = ::Time.now)
+      def all(date = ::Time.now, user = nil)
         date = ::Time.parse(date) if String === date
-        response = request(:get, credentials, "#{api_model.api_path}/#{date.yday}/#{date.year}")
-        api_model.parse(response.body)
+        response = request(:get, credentials, "#{api_model.api_path}/#{date.yday}/#{date.year}", :query => of_user_query(user))
+        api_model.parse(response.parsed_response)
       end
       
-      
       # This is currently broken, but will come back to it
       def attach(expense, filename, receipt)
         body = ""

data/lib/harvest/api/invoice_categories.rb

@@ -0,0 +1,26 @@
+module Harvest
+  module API
+    class InvoiceCategories < Base
+      api_model Harvest::InvoiceCategory
+      include Harvest::Behavior::Crud
+      
+      def find(*)
+        raise "find is unsupported for InvoiceCategories"
+      end
+      
+      def create(model)
+        model = api_model.wrap(model)
+        response = request(:post, credentials, "#{api_model.api_path}", :body => model.to_json)
+        id = response.headers["location"].match(/\/.*\/(\d+)/)[1]
+        all.detect {|c| c.id == id.to_i }
+      end
+      
+      def update(model, user = nil)
+        model = api_model.wrap(model)
+        request(:put, credentials, "#{api_model.api_path}/#{model.to_i}", :body => model.to_json, :query => of_user_query(user))
+        all.detect {|c| c.id == model.id }
+      end
+      
+    end
+  end
+end

data/lib/harvest/api/invoices.rb

@@ -0,0 +1,16 @@
+module Harvest
+  module API
+    class Invoices < Base
+      api_model Harvest::Invoice
+      include Harvest::Behavior::Crud
+      
+      def create(*)
+        raise "Creating and updating invoices are not implemented due to API issues"
+      end
+      
+      def update(*)
+        raise "Creating and updating invoices are not implemented due to API issues"
+      end
+    end
+  end
+end

data/lib/harvest/api/projects.rb

@@ -13,8 +13,8 @@ module Harvest
       #
       # @return [Harvest::Project]
       def create_task(project, task_name)
-        response = request(:post, credentials, "/projects/#{project.to_i}/task_assignments/add_with_create_new_task", :body => task_xml(task_name))
-        id = response.headers["location"].first.match(/\/.*\/(\d+)\/.*\/(\d+)/)[1]
+        response = request(:post, credentials, "/projects/#{project.to_i}/task_assignments/add_with_create_new_task", :body => {"task" => {"name" => task_name}}.to_json)
+        id = response.headers["location"].match(/\/.*\/(\d+)\/.*\/(\d+)/)[1]
         find(id)
       end
       
@@ -41,14 +41,6 @@ module Harvest
         end
         project
       end
-      
-      private
-        def task_xml(name)
-          builder = Builder::XmlMarkup.new
-          builder.task do |t|
-            t.name(name)
-          end
-        end
     end
   end
 end

data/lib/harvest/api/reports.rb

@@ -2,38 +2,35 @@ module Harvest
   module API
     class Reports < Base
       
-      def time_by_project(project, start_date, end_date, user = nil)
+      def time_by_project(project, start_date, end_date, options = {})
         query = {:from => start_date.strftime("%Y%m%d"), :to => end_date.strftime("%Y%m%d")}
-        query[:user_id] = user.to_i if user
+        query[:user_id] = options[:user].to_i if options[:user]
+        query[:billable] = (options[:billable] ? "yes" : "no") unless options[:billable].nil?
         
         response = request(:get, credentials, "/projects/#{project.to_i}/entries", :query => query)
-        Harvest::TimeEntry.parse(massage_xml(response.body))
+        Harvest::TimeEntry.parse(JSON.parse(response.body).map {|h| h["day_entry"]})
       end
       
-      def time_by_user(user, start_date, end_date, project = nil)
+      def time_by_user(user, start_date, end_date, options = {})
         query = {:from => start_date.strftime("%Y%m%d"), :to => end_date.strftime("%Y%m%d")}
-        query[:project_id] = project.to_i if project
+        query[:project_id] = options[:project].to_i if options[:project]
+        query[:billable] = (options[:billable] ? "yes" : "no") unless options[:billable].nil?
         
         response = request(:get, credentials, "/people/#{user.to_i}/entries", :query => query)
-        Harvest::TimeEntry.parse(massage_xml(response.body))
+        Harvest::TimeEntry.parse(JSON.parse(response.body).map {|h| h["day_entry"]})
       end
       
       def expenses_by_user(user, start_date, end_date)
         query = {:from => start_date.strftime("%Y%m%d"), :to => end_date.strftime("%Y%m%d")}
         
         response = request(:get, credentials, "/people/#{user.to_i}/expenses", :query => query)
-        Harvest::Expense.parse(response.body)
+        Harvest::Expense.parse(response.parsed_response)
       end
       
-      private
-        def massage_xml(original_xml)
-          # this needs to be done because of the differences in dashes and underscores in the harvest api
-          xml = original_xml
-          %w(day-entry adjustment-record created-at project-id spent-at task-id timer-started-at updated-at user-id).each do |dash_field|
-            xml = xml.gsub(dash_field, dash_field.gsub("-", "_"))
-          end
-          xml
-        end
+      def projects_by_client(client)
+        response = request(:get, credentials, "/projects?client=#{client.to_i}")
+        Harvest::Project.parse(response.parsed_response)
+      end
     end
   end
 end

data/lib/harvest/api/task_assignments.rb

@@ -4,27 +4,29 @@ module Harvest
       
       def all(project)
         response = request(:get, credentials, "/projects/#{project.to_i}/task_assignments")
-        Harvest::TaskAssignment.parse(response.body)
+        Harvest::TaskAssignment.parse(response.parsed_response)
       end
       
       def find(project, id)
         response = request(:get, credentials, "/projects/#{project.to_i}/task_assignments/#{id}")
-        Harvest::TaskAssignment.parse(response.body, :single => true)
+        Harvest::TaskAssignment.parse(response.parsed_response).first
       end
       
       def create(task_assignment)
-        response = request(:post, credentials, "/projects/#{task_assignment.project_id}/task_assignments", :body => task_assignment.task_xml)
-        id = response.headers["location"].first.match(/\/.*\/(\d+)\/.*\/(\d+)/)[2]
+        task_assignment = Harvest::TaskAssignment.wrap(task_assignment)
+        response = request(:post, credentials, "/projects/#{task_assignment.project_id}/task_assignments", :body => task_assignment.task_as_json.to_json)
+        id = response.headers["location"].match(/\/.*\/(\d+)\/.*\/(\d+)/)[2]
         find(task_assignment.project_id, id)
       end
       
       def update(task_assignment)
-        request(:put, credentials, "/projects/#{task_assignment.project_id}/task_assignments/#{task_assignment.to_i}", :body => task_assignment.to_xml)
+        task_assignment = Harvest::TaskAssignment.wrap(task_assignment)
+        request(:put, credentials, "/projects/#{task_assignment.project_id}/task_assignments/#{task_assignment.to_i}", :body => task_assignment.to_json)
         find(task_assignment.project_id, task_assignment.id)
       end
       
       def delete(task_assignment)
-        request(:delete, credentials, "/projects/#{task_assignment.project_id}/task_assignments/#{task_assignment.to_i}")
+        response = request(:delete, credentials, "/projects/#{task_assignment.project_id}/task_assignments/#{task_assignment.to_i}")
         task_assignment.id
       end
     end

data/lib/harvest/api/tasks.rb

@@ -2,7 +2,7 @@ module Harvest
   module API
     class Tasks < Base
       api_model Harvest::Task
-    
+
       include Harvest::Behavior::Crud
     end
   end

data/lib/harvest/api/time.rb

@@ -2,29 +2,29 @@ module Harvest
   module API
     class Time < Base
       
-      def find(id)
-        response = request(:get, credentials, "/daily/show/#{id}")
-        Harvest::TimeEntry.parse(response.body, :single => true)
+      def find(id, user = nil)
+        response = request(:get, credentials, "/daily/show/#{id.to_i}", :query => of_user_query(user))
+        Harvest::TimeEntry.parse(response.parsed_response).first
       end
       
-      def all(date = ::Time.now)
+      def all(date = ::Time.now, user = nil)
         date = ::Time.parse(date) if String === date
-        response = request(:get, credentials, "/daily/#{date.yday}/#{date.year}")
-        Harvest::TimeEntry.parse(response.body)
+        response = request(:get, credentials, "/daily/#{date.yday}/#{date.year}", :query => of_user_query(user))
+        Harvest::TimeEntry.parse(JSON.parse(response.body)["day_entries"])
       end
       
       def create(entry)
-        response = request(:post, credentials, '/daily/add', :body => entry.to_xml)
-        Harvest::TimeEntry.parse(response.body).first
+        response = request(:post, credentials, '/daily/add', :body => entry.to_json)
+        Harvest::TimeEntry.parse(response.parsed_response).first
       end
       
-      def update(entry)
-        request(:put, credentials, "/daily/update/#{entry.to_i}", :body => entry.to_xml)
-        find(entry.id)
+      def update(entry, user = nil)
+        request(:put, credentials, "/daily/update/#{entry.to_i}", :body => entry.to_json, :query => of_user_query(user))
+        find(entry.id, user)
       end
       
-      def delete(entry)
-        request(:delete, credentials, "/daily/delete/#{entry.to_i}")
+      def delete(entry, user = nil)
+        request(:delete, credentials, "/daily/delete/#{entry.to_i}", :query => of_user_query(user))
         entry.id
       end
     end

data/lib/harvest/api/user_assignments.rb

@@ -4,22 +4,24 @@ module Harvest
       
       def all(project)
         response = request(:get, credentials, "/projects/#{project.to_i}/user_assignments")
-        Harvest::UserAssignment.parse(response.body)
+        Harvest::UserAssignment.parse(response.parsed_response)
       end
       
       def find(project, id)
         response = request(:get, credentials, "/projects/#{project.to_i}/user_assignments/#{id}")
-        Harvest::UserAssignment.parse(response.body, :single => true)
+        Harvest::UserAssignment.parse(response.parsed_response).first
       end
       
       def create(user_assignment)
-        response = request(:post, credentials, "/projects/#{user_assignment.project_id}/user_assignments", :body => user_assignment.user_xml)
-        id = response.headers["location"].first.match(/\/.*\/(\d+)\/.*\/(\d+)/)[2]
+        user_assignment = Harvest::UserAssignment.wrap(user_assignment)
+        response = request(:post, credentials, "/projects/#{user_assignment.project_id}/user_assignments", :body => user_assignment.user_as_json.to_json)
+        id = response.headers["location"].match(/\/.*\/(\d+)\/.*\/(\d+)/)[2]
         find(user_assignment.project_id, id)
       end
       
       def update(user_assignment)
-        request(:put, credentials, "/projects/#{user_assignment.project_id}/user_assignments/#{user_assignment.id}", :body => user_assignment.to_xml)
+        user_assignment = Harvest::UserAssignment.wrap(user_assignment)
+        request(:put, credentials, "/projects/#{user_assignment.project_id}/user_assignments/#{user_assignment.id}", :body => user_assignment.to_json)
         find(user_assignment.project_id, user_assignment.id)
       end
       

data/lib/harvest/base.rb

@@ -133,7 +133,7 @@ module Harvest
     #  
     #  harvest.users.find(100) # Returns the user with id = 100
     #  
-    #  user = Harvest::User.new(:first_name => 'Edgar', :last_name => 'Ruth', :email => 'edgar@ruth.com', :password => 'mypassword', :password_confirmation => 'mypassword', :timezone => :cst, :admin => false, :telephone => '444-4444')
+    #  user = Harvest::User.new(:first_name => 'Edgar', :last_name => 'Ruth', :email => 'edgar@ruth.com', :password => 'mypassword', :timezone => :cst, :admin => false, :telephone => '444-4444')
     #  saved_user = harvest.users.create(user) # returns a saved version of Harvest::User
     #  
     #  user = harvest.users.find(205)
@@ -254,5 +254,13 @@ module Harvest
     def reports
       @reports ||= Harvest::API::Reports.new(credentials)
     end
+
+    def invoice_categories
+      @invoice_categories ||= Harvest::API::InvoiceCategories.new(credentials)
+    end
+
+    def invoices
+      @invoices ||= Harvest::API::Invoices.new(credentials)
+    end
   end
 end

data/lib/harvest/behavior/activatable.rb

@@ -10,7 +10,7 @@ module Harvest
       def deactivate(model)
         if model.active?
           request(:post, credentials, "#{api_model.api_path}/#{model.to_i}/toggle")
-          model.active = false
+          model.is_active = false
         end
         model
       end
@@ -22,7 +22,7 @@ module Harvest
       def activate(model)
         if !model.active?
           request(:post, credentials, "#{api_model.api_path}/#{model.to_i}/toggle")
-          model.active = true
+          model.is_active = true
         end
         model
       end

data/lib/harvest/behavior/crud.rb

@@ -3,9 +3,9 @@ module Harvest
     module Crud
       # Retrieves all items
       # @return [Array<Harvest::BaseModel>] an array of models depending on where you're calling it from (e.g. [Harvest::Client] from Harvest::Base#clients)
-      def all
-        response = request(:get, credentials, api_model.api_path)
-        api_model.parse(response.body)
+      def all(user = nil)
+        response = request(:get, credentials, api_model.api_path, :query => of_user_query(user))
+        api_model.parse(response.parsed_response)
       end
       
       # Retrieves an item by id
@@ -17,25 +17,27 @@ module Harvest
       #   @param [Harvest::BaseModel] id you can pass a model and it will return a refreshed version
       # 
       # @return [Harvest::BaseModel] the model depends on where you're calling it from (e.g. Harvest::Client from Harvest::Base#clients)
-      def find(id)
-        response = request(:get, credentials, "#{api_model.api_path}/#{id}")
-        api_model.parse(response.body, :single => true)
+      def find(id, user = nil)
+        response = request(:get, credentials, "#{api_model.api_path}/#{id}", :query => of_user_query(user))
+        api_model.parse(response.parsed_response).first
       end
       
       # Creates an item
       # @param [Harvest::BaseModel] model the item you want to create
       # @return [Harvest::BaseModel] the created model depending on where you're calling it from (e.g. Harvest::Client from Harvest::Base#clients)
       def create(model)
-        response = request(:post, credentials, "#{api_model.api_path}", :body => model.to_xml)
-        id = response.headers["location"].first.match(/\/.*\/(\d+)/)[1]
-        find(id)
+        model = api_model.wrap(model)
+        response = request(:post, credentials, "#{api_model.api_path}", :body => model.to_json)
+        id = response.headers["location"].match(/\/.*\/(\d+)/)[1]
+        find(id, model.impersonated_user_id)
       end
       
       # Updates an item
       # @param [Harvest::BaseModel] model the model you want to update
       # @return [Harvest::BaseModel] the created model depending on where you're calling it from (e.g. Harvest::Client from Harvest::Base#clients)
-      def update(model)
-        request(:put, credentials, "#{api_model.api_path}/#{model.to_i}", :body => model.to_xml)
+      def update(model, user = nil)
+        model = api_model.wrap(model)
+        request(:put, credentials, "#{api_model.api_path}/#{model.to_i}", :body => model.to_json, :query => of_user_query(user))
         find(model.id)
       end
       
@@ -48,8 +50,8 @@ module Harvest
       #  @param [String] id the String version of the id of the item you want to delete
       # 
       # @return [Integer] the id of the item deleted
-      def delete(model)
-        request(:delete, credentials, "#{api_model.api_path}/#{model.to_i}")
+      def delete(model, user = nil)
+        request(:delete, credentials, "#{api_model.api_path}/#{model.to_i}", :query => of_user_query(user))
         model.to_i
       end
     end