forecasted 0.0.1

data/lib/forecast/api/assignments.rb

@@ -0,0 +1,63 @@
+require 'business_time'
+
+module Forecast
+
+  FORECAST_DATE_FORMAT = "%Y-%m-%d"
+
+  module API
+    class Assignments < Base
+      api_model Forecast::Assignment
+      include Forecast::Behavior::Crud
+
+      def by_project(project_id, query_options={})
+        query = {project_id: project_id}.merge(query_options)
+        self.all(query)
+      end
+
+      def sum_allocation_seconds(query)
+        axs = self.all(query)
+
+        total_time = 0
+
+        axs.each do |x|
+          start_date = Date.strptime(x.start_date, FORECAST_DATE_FORMAT)
+          end_date = Date.strptime(x.end_date, FORECAST_DATE_FORMAT)
+
+          num_days = start_date.business_days_until(end_date) + 1
+
+          total_time += (1.0 * x.allocation * num_days)
+        end
+
+        return total_time
+      end
+
+      def last_by_project(project_id)
+        x = self.by_project(project_id)
+        self.last_by_date(x)
+      end
+
+
+      def create(*) ; raise "not implemented" ; end
+      def update(*) ; raise "not implemented" ; end
+      def delete(*) ; raise "not implemented" ; end
+
+
+      def last_by_date(array_hm)
+        array_hm.sort_by do |x|
+          Date.strptime(x.end_date, FORECAST_DATE_FORMAT)
+        end.last
+      end
+
+      def business_days_between(date1, date2)
+        business_days = 0
+        date = date2
+        while date > date1
+         business_days = business_days + 1 unless date.saturday? or date.sunday?
+         date = date - 1.day
+        end
+        business_days
+      end
+
+    end
+  end
+end

data/lib/forecast/api/base.rb

@@ -0,0 +1,68 @@
+module Forecast
+  module API
+    class Base
+      attr_reader :credentials
+
+      def initialize(credentials)
+        @credentials = credentials
+      end
+
+      class << self
+        def api_model(klass)
+          class_eval <<-END
+            def api_model
+              #{klass}
+            end
+          END
+        end
+      end
+
+      protected
+        def request(method, credentials, path, options = {})
+          params = {
+            path:    path,
+            options: options,
+            method:  method
+          }
+
+          httparty_options = {
+            query:  options[:query],
+            body:   options[:body],
+            format: :plain,
+            headers: {
+              "Accept"       => "application/json",
+              "Content-Type" => "application/json; charset=utf-8",
+              "User-Agent"   => "Forecasted/#{Forecast::VERSION}"
+            }.update(options[:headers] || {})
+          }
+
+          credentials.set_authentication(httparty_options)
+          response = HTTParty.send(method, "#{credentials.host}#{path}", httparty_options)
+          params[:response] = response.inspect.to_s
+
+          case response.code
+          when 200..201
+            response
+          when 400
+            raise Forecast::BadRequest.new(response, params)
+          when 401
+            raise Forecast::AuthenticationFailed.new(response, params)
+          when 404
+            raise Forecast::NotFound.new(response, params, "Do you have sufficient privileges?")
+          when 500
+            raise Forecast::ServerError.new(response, params)
+          when 502
+            raise Forecast::Unavailable.new(response, params)
+          when 503
+            raise Forecast::RateLimited.new(response, params)
+          else
+            raise Forecast::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/forecast/api/clients.rb

@@ -0,0 +1,10 @@
+module Harvest
+  module API
+    class Clients < Base
+      api_model Harvest::Client
+      
+      include Harvest::Behavior::Crud
+      include Harvest::Behavior::Activatable
+    end
+  end
+end

data/lib/forecast/api/expense_categories.rb

@@ -0,0 +1,9 @@
+module Harvest
+  module API
+    class ExpenseCategories < Base
+      api_model Harvest::ExpenseCategory
+      
+      include Harvest::Behavior::Crud
+    end
+  end
+end

data/lib/forecast/api/expenses.rb

@@ -0,0 +1,27 @@
+module Harvest
+  module API
+    class Expenses < Base
+      api_model Harvest::Expense
+      
+      include Harvest::Behavior::Crud
+      
+      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}", :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 = ""
+        body << "------------------------------b7edea381b46\r\n"
+        body << %Q{Content-Disposition: form-data; name="expense[receipt]"; filename="#{filename}"\r\n}
+        body << "Content-Type: image/png\r\n"
+        body << "\r\n#{receipt.read}\r\n"
+        body << "------------------------------b7edea381b46\r\n"
+        
+        request(:post, credentials, "#{api_model.api_path}/#{expense.to_i}/receipt", :headers => {'Content-Type' => 'multipart/form-data; boundary=------------------------------b7edea381b46'}, :body => body)
+      end
+    end
+  end
+end

data/lib/forecast/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/forecast/api/invoice_messages.rb

@@ -0,0 +1,75 @@
+module Harvest
+  module API
+    class InvoiceMessages < Base
+      api_model Harvest::InvoiceMessage
+      include Harvest::Behavior::Crud
+
+      def all(invoice)
+        response = request(:get, credentials, "/invoices/#{invoice.to_i}/messages")
+        api_model.parse(response.parsed_response)
+      end
+
+      def find(invoice, message)
+        response = request(:get, credentials, "/invoices/#{invoice.to_i}/messages/#{message.to_i}")
+        api_model.parse(response.parsed_response).first
+      end
+
+      def create(message)
+        message = api_model.wrap(message)
+        response = request(:post, credentials, "/invoices/#{message.invoice_id}/messages", :body => message.to_json)
+        id = response.headers["location"].match(/\/.*\/(\d+)\/.*\/(\d+)/)[2]
+        find(message.invoice_id, id)
+      end
+
+      def delete(message)
+        request(:delete, credentials, "/invoices/#{message.invoice_id}/messages/#{message.to_i}")
+        message.id
+      end
+
+      # Create a message for marking an invoice as sent.
+      #
+      # @param [Harvest::InvoiceMessage] The message you want to send
+      # @return [Harvest::InvoiceMessage] The sent message
+      def mark_as_sent(message)
+        send_status_message(message, 'mark_as_sent')
+      end
+
+      # Create a message and mark an open invoice as closed (writing an invoice off)
+      #
+      # @param [Harvest::InvoiceMessage] The message you want to send
+      # @return [Harvest::InvoiceMessage] The sent message
+      def mark_as_closed(message)
+        send_status_message(message, 'mark_as_closed')
+      end
+
+      # Create a message and mark a closed (written-off) invoice as open
+      #
+      # @param [Harvest::InvoiceMessage] The message you want to send
+      # @return [Harvest::InvoiceMessage] The sent message
+      def re_open(message)
+        send_status_message(message, 're_open')
+      end
+
+      # Create a message for marking an open invoice as draft
+      #
+      # @param [Harvest::InvoiceMessage] The message you want to send
+      # @return [Harvest::InvoiceMessage] The sent message
+      def mark_as_draft(message)
+        send_status_message(message, 'mark_as_draft')
+      end
+
+      private
+
+      def send_status_message(message, action)
+        message = api_model.wrap(message)
+        response = request( :post, 
+                            credentials, 
+                            "/invoices/#{message.invoice_id}/messages/#{action}",
+                            :body => message.to_json
+                          )
+        message
+      end
+
+    end
+  end
+end

data/lib/forecast/api/invoice_payments.rb

@@ -0,0 +1,31 @@
+module Harvest
+  module API
+    class InvoicePayments < Base
+      api_model Harvest::InvoicePayment
+      include Harvest::Behavior::Crud
+
+      def all(invoice)
+        response = request(:get, credentials, "/invoices/#{invoice.to_i}/payments")
+        api_model.parse(response.parsed_response)
+      end
+
+      def find(invoice, payment)
+        response = request(:get, credentials, "/invoices/#{invoice.to_i}/payments/#{payment.to_i}")
+        api_model.parse(response.parsed_response).first
+      end
+
+      def create(payment)
+        payment = api_model.wrap(payment)
+        response = request(:post, credentials, "/invoices/#{payment.invoice_id}/payments", :body => payment.to_json)
+        id = response.headers["location"].match(/\/.*\/(\d+)\/.*\/(\d+)/)[2]
+        find(payment.invoice_id, id)
+      end
+
+      def delete(payment)
+        request(:delete, credentials, "/invoices/#{payment.invoice_id}/payments/#{payment.to_i}")
+        payment.id
+      end
+
+    end
+  end
+end

data/lib/forecast/api/invoices.rb

@@ -0,0 +1,35 @@
+module Harvest
+  module API
+    class Invoices < Base
+      api_model Harvest::Invoice
+      include Harvest::Behavior::Crud
+
+      # == Retrieves invoices
+      #
+      # == Available options
+      # - :status - invoices by status
+      # - :page
+      # - :updated_since
+      # - :timeframe (must be a nested hash with :to and :from)
+      #
+      # @overload all()
+      # @overload all(options)
+      #   @param [Hash] filtering options
+      #
+      # @return [Array<Harvest::Invoice>] an array of invoices
+      def all(options = {})
+        query = {}
+        query[:status]        = options[:status]        if options[:status]
+        query[:page]          = options[:page]          if options[:page]
+        query[:updated_since] = options[:updated_since] if options[:updated_since]
+        if options[:timeframe]
+          query[:from] = options[:timeframe][:from]
+          query[:to]   = options[:timeframe][:to]
+        end
+
+        response = request(:get, credentials, "/invoices", :query => query)
+        api_model.parse(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/forecast/api/milestones.rb

@@ -0,0 +1,21 @@
+module Forest
+  module API
+    class Milestones < Base
+
+      # renamed from contant
+      # api_model Harvest::Contact
+
+      # include Harvest::Behavior::Crud
+
+      # def all(client_id = nil)
+      #   response = if client_id
+      #     request(:get, credentials, "/clients/#{client_id}/contacts")
+      #   else
+      #     request(:get, credentials, "/contacts")
+      #   end
+
+      #   api_model.parse(response.parsed_response)
+      # end
+    end
+  end
+end

data/lib/forecast/api/projects.rb

@@ -0,0 +1,23 @@
+module Forecast
+  module API
+    class Projects < Base
+      api_model Forecast::Project
+
+      include Forecast::Behavior::Crud
+
+      def find_by_harvest_id(harvest_project_id)
+        selected = self.all.select{|x| x.harvest_id == harvest_project_id}
+
+        if selected.size > 1
+          raise "Forecasted::Error - more than 1 harvest_id forecast project"
+        else
+          return selected.first
+        end
+      end
+
+      def create ; raise "not implemented" ; end
+      def update ; raise "not implemented" ; end
+      def delete ; raise "not implemented" ; end
+    end
+  end
+end

data/lib/forecast/api/reports.rb

@@ -0,0 +1,53 @@
+module Harvest
+  module API
+    class Reports < Base
+
+      TIME_FORMAT = '%Y%m%d'
+
+      def time_by_project(project, start_date, end_date, options = {})
+        query = { from: start_date.strftime(TIME_FORMAT), to: end_date.strftime(TIME_FORMAT) }
+        query[:user_id]       = options.delete(:user).to_i if options[:user]
+        query[:billable]      = (options.delete(:billable) ? "yes" : "no") unless options[:billable].nil?
+        query[:updated_since] = options.delete(:updated_since).to_s if options[:updated_since]
+        query.update(options)
+
+        response = request(:get, credentials, "/projects/#{project.to_i}/entries", query: query)
+        Harvest::TimeEntry.parse(JSON.parse(response.body).map {|h| h["day_entry"]})
+      end
+
+      def time_by_user(user, start_date, end_date, options = {})
+        query = { from: start_date.strftime(TIME_FORMAT), to: end_date.strftime(TIME_FORMAT) }
+        query[:project_id]    = options.delete(:project).to_i if options[:project]
+        query[:billable]      = (options.delete(:billable) ? "yes" : "no") unless options[:billable].nil?
+        query[:updated_since] = options.delete(:updated_since).to_s if options[:updated_since]
+        query.update(options)
+
+        response = request(:get, credentials, "/people/#{user.to_i}/entries", query: query)
+        Harvest::TimeEntry.parse(JSON.parse(response.body).map {|h| h["day_entry"]})
+      end
+
+      def expenses_by_user(user, start_date, end_date, options = {})
+        query = { from: start_date.strftime(TIME_FORMAT), to: end_date.strftime(TIME_FORMAT) }
+        query[:updated_since] = options.delete(:updated_since).to_s if options[:updated_since]
+        query.update(options)
+
+        response = request(:get, credentials, "/people/#{user.to_i}/expenses", query: query)
+        Harvest::Expense.parse(response.parsed_response)
+      end
+
+      def expenses_by_project(project, start_date, end_date, options = {})
+        query = { from: start_date.strftime(TIME_FORMAT), to: end_date.strftime(TIME_FORMAT) }
+        query[:updated_since] = options.delete(:updated_since).to_s if options[:updated_since]
+        query.update(options)
+
+        response = request(:get, credentials, "/projects/#{project.to_i}/expenses", query: query)
+        Harvest::Expense.parse(response.parsed_response)
+      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/forecast/api/tasks.rb

@@ -0,0 +1,36 @@
+module Harvest
+  module API
+    class Tasks < Base
+      api_model Harvest::Task
+
+      include Harvest::Behavior::Crud
+
+      # Deactivating tasks is not yet supported by the Harvest API.
+
+      # Deactivates the task. Does nothing if the task is already deactivated
+      # 
+      # @param [Harvest::Task] task the task you want to deactivate
+      # @return [Harvest::Task] the deactivated task
+      #def deactivate(task)
+      #  if task.active?
+      #    request(:post, credentials, "#{api_model.api_path}/#{task.to_i}/deactivate", :headers => {'Content-Length' => '0'})
+      #    task.active = false
+      #  end
+      #  task
+      #end
+      
+      # Activates the task. Does nothing if the task is already activated
+      # 
+      # @param [Harvest::Task] task the task you want to activate
+      # @return [Harvest::Task] the activated task
+      def activate(task)
+        if !task.active?
+          request(:post, credentials, "#{api_model.api_path}/#{task.to_i}/activate", :headers => {'Content-Length' => '0'})
+          task.active = true
+        end
+        task
+      end
+
+    end
+  end
+end

data/lib/forecast/api/time.rb

@@ -0,0 +1,48 @@
+module Harvest
+  module API
+    class Time < Base
+      
+      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, user = nil)
+        Harvest::TimeEntry.parse(daily(date, user)["day_entries"])
+      end
+
+      def trackable_projects(date = ::Time.now, user = nil)
+        Harvest::TrackableProject.parse(daily(date, user)["projects"])
+      end
+      
+      def toggle(id, user = nil)
+        response = request(:get, credentials, "/daily/timer/#{id}", :query => of_user_query(user))
+        Harvest::TimeEntry.parse(response.parsed_response).first
+      end
+
+      def create(entry, user = nil)
+        response = request(:post, credentials, '/daily/add', :body => entry.to_json, :query => of_user_query(user))
+        Harvest::TimeEntry.parse(response.parsed_response).first
+      end
+
+      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, user = nil)
+        request(:delete, credentials, "/daily/delete/#{entry.to_i}", :query => of_user_query(user))
+        entry.id
+      end
+
+
+      private
+
+      def daily(date, user)
+        date = ::Time.parse(date) if String === date
+        response = request(:get, credentials, "/daily/#{date.yday}/#{date.year}", :query => of_user_query(user))
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/forecast/api/user_assignments.rb

@@ -0,0 +1,34 @@
+module Harvest
+  module API
+    class UserAssignments < Base
+      
+      def all(project)
+        response = request(:get, credentials, "/projects/#{project.to_i}/user_assignments")
+        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.parsed_response).first
+      end
+      
+      def create(user_assignment)
+        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)
+        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
+      
+      def delete(user_assignment)
+        request(:delete, credentials, "/projects/#{user_assignment.project_id}/user_assignments/#{user_assignment.to_i}")
+        user_assignment.id
+      end
+    end
+  end
+end

data/lib/forecast/api/users.rb

@@ -0,0 +1,21 @@
+module Harvest
+  module API
+    class Users < Base
+      api_model Harvest::User
+    
+      include Harvest::Behavior::Crud
+      include Harvest::Behavior::Activatable
+      
+      # Triggers Harvest to reset the user's password and sends them an email to change it.
+      # @overload reset_password(id)
+      #   @param [Integer] id the id of the user you want to reset the password for
+      # @overload reset_password(user)
+      #   @param [Harvest::User] user the user you want to reset the password for
+      # @return [Harvest::User] the user you passed in
+      def reset_password(user)
+        request(:post, credentials, "#{api_model.api_path}/#{user.to_i}/reset_password")
+        user
+      end
+    end
+  end
+end

data/lib/forecast/assignment.rb

@@ -0,0 +1,7 @@
+module Forecast
+  class Assignment < Hashie::Mash
+    include Forecast::Model
+
+    api_path '/assignments'
+  end
+end