forecasted 0.0.1

data/lib/forecast/base.rb

@@ -0,0 +1,111 @@
+module Forecast
+  class Base
+    attr_reader :request, :credentials
+
+    # @see Forecast.client
+    # @see Forecast.hardy_client
+    # def initialize({forecast_api_id: nil, access_token: nil})
+    def initialize(ops={})
+      @credentials = if ops[:forecast_account_id] and ops[:access_token]
+
+        #
+        # httparty stops the party (haha) if the access_token is not a String
+        #
+        string_ops = {
+            forecast_account_id: ops[:forecast_account_id].to_s,
+            access_token: ops[:access_token],
+        }
+
+        OAuthCredentials.new(string_ops)
+      else
+        fail 'You must provide either :forecast_account_id and :access_token'
+      end
+    end
+
+    # people - @todo
+    # # All API Actions surrounding Users
+    # #
+    # # == Examples
+    # #  harvest.users.all() # Returns all users in the system
+    # #
+    # #  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', :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)
+    # #  user.email = 'edgar@ruth.com'
+    # #  updated_user = harvest.users.update(user) # returns an updated version of Harvest::User
+    # #
+    # #  user = harvest.users.find(205)
+    # #  harvest.users.delete(user) # returns 205
+    # #
+    # #  user = harvest.users.find(301)
+    # #  deactivated_user = harvest.users.deactivate(user) # returns an updated deactivated user
+    # #  activated_user = harvest.users.activate(user) # returns an updated activated user
+    # #
+    # #  user = harvest.users.find(401)
+    # #  harvest.users.reset_password(user) # will trigger the reset password feature of harvest and shoot the user an email
+    # #
+    # # @see Harvest::Behavior::Crud
+    # # @see Harvest::Behavior::Activatable
+    # # @return [Harvest::API::Users]
+    # def users
+    #   @users ||= Harvest::API::Users.new(credentials)
+    # end
+
+    # All API Actions surrounding Projects
+    #
+    # == Examples
+    #  forecast.projects.all() # Returns all projects in the system
+    #
+    #  harvest.projects.find(100) # Returns the project with id = 100
+    #
+    #  project = Harvest::Project.new(:name => 'SuprGlu' :client_id => 10)
+    #  saved_project = harvest.projects.create(project) # returns a saved version of Harvest::Project
+    #
+    #  project = harvest.projects.find(205)
+    #  project.name = 'SuprSticky'
+    #  updated_project = harvest.projects.update(project) # returns an updated version of Harvest::Project
+    #
+    #  project = harvest.project.find(205)
+    #  harvest.projects.delete(project) # returns 205
+    #
+    #  project = harvest.projects.find(301)
+    #  deactivated_project = harvest.projects.deactivate(project) # returns an updated deactivated project
+    #  activated_project = harvest.projects.activate(project) # returns an updated activated project
+    #
+    #  project = harvest.projects.find(401)
+    #  harvest.projects.create_task(project, 'Bottling Glue') # creates and assigns a task to the project
+    #
+    # @see Harvest::Behavior::Crud
+    # @see Harvest::Behavior::Activatable
+    # @return [Harvest::API::Projects]
+    def projects
+      @projects ||= Forecast::API::Projects.new(credentials)
+    end
+
+    # All API Actions surrounding Assignments
+    #
+    # == Examples
+    #  forecast.projects.all() # Returns all projects in the system
+    #  forecast.projects.all({start_date: '2016-11-28', end_date: '2017-01-01', state: 'active'})
+    #
+    #  forecast.projects.find(100) # Returns the project with id = 100
+    #
+    #
+    # @see Forecast::Behavior::Crud
+    # @return [Forecast::API::Projects]
+    def assignments
+      @assignments ||= Forecast::API::Assignments.new(credentials)
+    end
+
+    # def milestones
+    #   @milestones ||= Forecast::API::Milestones.new(credentials)
+    # end
+
+    def aggregates
+      @aggregates ||= Forecast::API::Aggregates.new(credentials)
+    end
+  end
+end

data/lib/forecast/behavior/activatable.rb

@@ -0,0 +1,31 @@
+module Forecast
+  module Behavior
+
+    # Activate/Deactivate behaviors that can be brought into API collections
+    module Activatable
+      # Deactivates the item. Does nothing if the item is already deactivated
+      #
+      # @param [Harvest::BaseModel] model the model you want to deactivate
+      # @return [Harvest::BaseModel] the deactivated model
+      def deactivate(model)
+        if model.active?
+          request(:post, credentials, "#{api_model.api_path}/#{model.to_i}/toggle")
+          model.is_active = false
+        end
+        model
+      end
+
+      # Activates the item. Does nothing if the item is already activated
+      #
+      # @param [Harvest::BaseModel] model the model you want to activate
+      # @return [Harvest::BaseModel] the activated model
+      def activate(model)
+        if !model.active?
+          request(:post, credentials, "#{api_model.api_path}/#{model.to_i}/toggle")
+          model.is_active = true
+        end
+        model
+      end
+    end
+  end
+end

data/lib/forecast/behavior/crud.rb

@@ -0,0 +1,75 @@
+module Forecast
+  module Behavior
+    module Crud
+
+      # Retrieves all items
+      # @return [Array<Forecast::BaseModel>] an array of models depending on
+      # where you're calling it from (e.g. [Forecast::Client] from
+      # Forecast::Base#clients)
+
+      # def all(user = nil, query_options = {})
+      def all(query_options = {})
+
+        # query = query_options.merge!(of_user_query(user))
+        query = query_options
+
+        response = request(:get, credentials, api_model.api_path, :query => query)
+
+        api_model.parse(response.parsed_response)
+      end
+
+      # Retrieves an item by id
+      # @overload find(id)
+      #   @param [Integer] the id of the item you want to retreive
+      # @overload find(id)
+      #   @param [String] id the String version of the id
+      # @overload find(model)
+      #   @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, user = nil)
+        raise "id required" unless id
+        # response = request(:get, credentials, "#{api_model.api_path}/#{id}", :query => of_user_query(user))
+        response = request(:get, credentials, "#{api_model.api_path}/#{id}")
+        api_model.parse(response.parsed_response)
+      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, user = nil)
+        model = api_model.wrap(model)
+        response = request(:post, credentials, "#{api_model.api_path}", :body => model.to_json, :query => of_user_query(user))
+        id = response.headers["location"].match(/\/.*\/(\d+)/)[1]
+        if user
+          find(id, user)
+        else
+          find(id)
+        end
+      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, 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
+
+      # Deletes an item
+      # @overload delete(model)
+      #  @param [Harvest::BaseModel] model the item you want to delete
+      # @overload delete(id)
+      #  @param [Integer] id the id of the item you want to delete
+      # @overload delete(id)
+      #  @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, user = nil)
+        request(:delete, credentials, "#{api_model.api_path}/#{model.to_i}", :query => of_user_query(user))
+        model.to_i
+      end
+    end
+  end
+end

data/lib/forecast/client.rb

@@ -0,0 +1,22 @@
+module Forecast
+  # The model that contains information about a client
+  #
+  # == Fields
+  # [+id+] (READONLY) the id of the client
+  # [+name+] (REQUIRED) the name of the client
+  # [+details+] the details of the client
+  # [+currency+] what type of currency is associated with the client
+  # [+currency_symbol+] what currency symbol is associated with the client
+  # [+active?+] true|false on whether the client is active
+  # [+highrise_id+] (READONLY) the highrise id associated with this client
+  # [+update_at+] (READONLY) the last modification timestamp
+  class Client < Hashie::Mash
+    include Forecast::Model
+
+    api_path '/clients'
+
+    # def is_active=(val)
+    #   self.active = val
+    # end
+  end
+end

data/lib/forecast/credentials.rb

@@ -0,0 +1,42 @@
+module Forecast
+  # class BasicAuthCredentials
+  #   # def initialize(forecast_account_id: nil, username: nil, password: nil)
+  #   #   @forecast_account_id, @username, @password = forecast_account_id, username, password
+  #   # end
+
+  #   # def set_authentication(request_options)
+  #   #   request_options[:headers] ||= {}
+  #   #   request_options[:headers]["Authorization"] = "Basic #{basic_auth}"
+  #   #   request_options[:headers]["forecast-account-id"] = @forecast_account_id
+  #   # end
+
+  #   # @westonplatter - forecaset doesn't have subdomains at this point
+  #   # def host
+  #   #   "https://#{@subdomain}.forecastapp.com"
+  #   # end
+
+  #   private
+
+  #   # def basic_auth
+  #   #   Base64.encode64("#{@username}:#{@password}").delete("\r\n")
+  #   # end
+  # end
+
+  class OAuthCredentials
+    def initialize(ops={})
+      @access_token = ops[:access_token] || nil
+      @forecast_account_id = ops[:forecast_account_id] || nil
+    end
+
+    def set_authentication(request_options)
+      request_options[:headers] ||= {}
+      request_options[:headers]['Forecast-Account-Id'] = @forecast_account_id
+      request_options[:headers]['Authorization'] = "Bearer #{@access_token}"
+      request_options[:headers]['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36'
+    end
+
+    def host
+      "https://api.forecastapp.com"
+    end
+  end
+end

data/lib/forecast/errors.rb

@@ -0,0 +1,26 @@
+module Forecast
+  class HTTPError < StandardError
+    attr_reader :response
+    attr_reader :params
+    attr_reader :hint
+
+    def initialize(response, params = {}, hint = nil)
+      @response = response
+      @params = params
+      @hint = hint
+      super(response)
+    end
+
+    def to_s
+      "#{self.class.to_s} : #{response.code} #{response.body}" + (hint ? "\n#{hint}" : "")
+    end
+  end
+
+  class RateLimited < HTTPError; end
+  class NotFound < HTTPError; end
+  class Unavailable < HTTPError; end
+  class InformHarvest < HTTPError; end
+  class BadRequest < HTTPError; end
+  class ServerError < HTTPError; end
+  class AuthenticationFailed < HTTPError ; end
+end

data/lib/forecast/expense.rb

@@ -0,0 +1,27 @@
+# module Harvest
+#   class Expense < Hashie::Mash
+#     include Harvest::Model
+
+#     api_path '/expenses'
+#     delegate_methods(:billed? => :is_billed,
+#                      :closed? => :is_closed)
+
+#     def initialize(args = {}, _ = nil)
+#       args          = args.to_hash.stringify_keys
+#       self.spent_at = args.delete("spent_at") if args["spent_at"]
+#       super
+#     end
+
+#     def spent_at=(date)
+#       self["spent_at"] = Date.parse(date.to_s)
+#     end
+
+#     def as_json(args = {})
+#       super(args).to_hash.stringify_keys.tap do |hash|
+#         hash[json_root].update("spent_at" => (spent_at.nil? ? nil : spent_at.xmlschema))
+#         hash[json_root].delete("has_receipt")
+#         hash[json_root].delete("receipt_url")
+#       end
+#     end
+#   end
+# end

data/lib/forecast/expense_category.rb

@@ -0,0 +1,10 @@
+# module Harvest
+#   class ExpenseCategory < Hashie::Mash
+#     include Harvest::Model
+#     api_path '/expense_categories'
+
+#     def active?
+#       !deactivated
+#     end
+#   end
+# end

data/lib/forecast/hardy_client.rb

@@ -0,0 +1,80 @@
+module Forecast
+  class HardyClient < Delegator
+    def initialize(client, max_retries)
+      super(client)
+      @_sd_obj = @client = client
+      @max_retries = max_retries
+      (@client.public_methods - Object.public_instance_methods).each do |name|
+        instance_eval <<-END
+          def #{name}(*args)
+            wrap_collection do
+              @client.send('#{name}', *args)
+            end
+          end
+        END
+      end
+    end
+
+    def __getobj__; @_sd_obj; end
+    def __setobj__(obj); @_sd_obj = obj; end
+
+    def wrap_collection
+      collection = yield
+      HardyCollection.new(collection, self, @max_retries)
+    end
+
+    class HardyCollection < Delegator
+      def initialize(collection, client, max_retries)
+        super(collection)
+        @_sd_obj = @collection = collection
+        @client = client
+        @max_retries = max_retries
+        (@collection.public_methods - Object.public_instance_methods).each do |name|
+          instance_eval <<-END
+            def #{name}(*args)
+              retry_rate_limits do
+                @collection.send('#{name}', *args)
+              end
+            end
+          END
+        end
+      end
+
+      def __getobj__; @_sd_obj; end
+      def __setobj__(obj); @_sd_obj = obj; end
+
+      def retry_rate_limits
+        retries = 0
+
+        retry_func = lambda do |e|
+          if retries < @max_retries
+            retries += 1
+            true
+          else
+            raise e
+          end
+        end
+
+        begin
+          yield
+        rescue Forecast::RateLimited => e
+          seconds = if e.response.headers["retry-after"]
+            e.response.headers["retry-after"].to_i
+          else
+            16
+          end
+          sleep(seconds)
+          retry
+        rescue Forecast::Unavailable, Harvest::InformHarvest => e
+          would_retry = retry_func.call(e)
+          sleep(16) if @client.account.rate_limit_status.over_limit?
+          retry if would_retry
+        rescue Net::HTTPError, Net::HTTPFatalError => e
+          retry if retry_func.call(e)
+        rescue SystemCallError => e
+          retry if e.is_a?(Errno::ECONNRESET) && retry_func.call(e)
+        end
+      end
+    end
+  end
+end

data/lib/forecast/invoice.rb

@@ -0,0 +1,107 @@
+# module Harvest
+
+#   # == Fields
+#   # [+due_at+] when the invoice is due
+#   # [+due_at_human_format+] when the invoice is due in human representation (e.g., due upon receipt) overrides +due_at+
+#   # [+client_id+] (REQUIRED) the client id of the invoice
+#   # [+currency+] the invoice currency
+#   # [+issued_at+] when the invoice was issued
+#   # [+subject+] subject line for the invoice
+#   # [+notes+] notes on the invoice
+#   # [+number+] invoice number
+#   # [+kind+] (REQUIRED) the type of the invoice +free_form|project|task|people|detailed+
+#   # [+projects_to_invoice+] comma separated project ids to gather data from
+#   # [+import_hours+] import hours from +project|task|people|detailed+ one of +yes|no+
+#   # [+import_expenses+] import expenses from +project|task|people|detailed+ one of +yes|no+
+#   # [+period_start+] start of the invoice period
+#   # [+period_end+] end of the invoice period
+#   # [+expense_period_start+] start of the invoice expense period
+#   # [+expense_period_end+] end of the invoice expense period
+#   # [+csv_line_items+] csv formatted line items for the invoice +kind,description,quantity,unit_price,amount,taxed,taxed2,project_id+
+#   # [+created_at+] (READONLY) when the invoice was created
+#   # [+updated_at+] (READONLY) when the invoice was updated
+#   # [+id+] (READONLY) the id of the invoice
+#   # [+amount+] (READONLY) the amount of the invoice
+#   # [+due_amount+] (READONLY) the amount due on the invoice
+#   # [+created_by_id+] who created the invoice
+#   # [+purchase_order+] purchase order number/text
+#   # [+client_key+] unique client key
+#   # [+state+] (READONLY) state of the invoice
+#   # [+tax+] applied tax percentage
+#   # [+tax2+] applied tax 2 percentage
+#   # [+tax_amount+] amount to tax
+#   # [+tax_amount2+] amount to tax 2
+#   # [+discount_amount+] discount amount to apply to invoice
+#   # [+discount_type+] discount type
+#   # [+recurring_invoice_id+] the id of the original invoice
+#   # [+estimate_id+] id of the related estimate
+#   # [+retainer_id+] id of the related retainer
+#   class Invoice < Hashie::Mash
+#     include Harvest::Model
+
+#     api_path '/invoices'
+
+#     attr_reader :line_items
+
+#     def self.parse(json)
+#       parsed   = String === json ? JSON.parse(json) : json
+#       invoices = Array.wrap(parsed).map {|attrs| new(attrs["invoices"])}
+#       invoice  = Array.wrap(parsed).map {|attrs| new(attrs["invoice"])}
+#       if invoices.first && invoices.first.length > 0
+#         invoices
+#       else
+#         invoice
+#       end
+#     end
+
+#     def initialize(args = {}, _ = nil)
+#       if args
+#         args            = args.to_hash.stringify_keys
+#         self.line_items = args.delete("csv_line_items")
+#         self.line_items = args.delete("line_items")
+#         self.line_items = [] if self.line_items.nil?
+#       end
+#       super
+#     end
+
+#     def line_items=(raw_or_rich)
+#       unless raw_or_rich.nil?
+#         @line_items = case raw_or_rich
+#         when String
+#           @line_items = decode_csv(raw_or_rich).map {|row| Harvest::LineItem.new(row) }
+#         else
+#           raw_or_rich
+#         end
+#       end
+#     end
+
+#     def as_json(*options)
+#       json = super(*options)
+#       json[json_root]["csv_line_items"] = encode_csv(@line_items)
+#       json
+#     end
+
+#     private
+#       def decode_csv(string)
+#         csv = CSV.parse(string)
+#         headers = csv.shift
+#         csv.map! {|row| headers.zip(row) }
+#         csv.map {|row| row.inject({}) {|h, tuple| h.update(tuple[0] => tuple[1]) } }
+#       end
+
+#       def encode_csv(line_items)
+#         if line_items.empty?
+#           ""
+#         else
+#           header = %w(kind description quantity unit_price amount taxed taxed2 project_id)
+
+#           CSV.generate do |csv|
+#             csv << header
+#             line_items.each do |item|
+#               csv << header.inject([]) {|row, attr| row << item[attr] }
+#             end
+#           end
+#         end
+#       end
+#   end
+# end

data/lib/forecast/invoice_category.rb

@@ -0,0 +1,9 @@
+# module Harvest
+#   class InvoiceCategory < Hashie::Mash
+#     include Harvest::Model
+
+#     api_path '/invoice_item_categories'
+#     def self.json_root; "category"; end
+
+#   end
+# end

data/lib/forecast/invoice_message.rb

@@ -0,0 +1,8 @@
+# module Harvest
+#   class InvoiceMessage < Hashie::Mash
+#     include Harvest::Model
+
+#     api_path '/messages'
+#     def self.json_root; 'message'; end
+#   end
+# end

data/lib/forecast/invoice_payment.rb

@@ -0,0 +1,8 @@
+# module Harvest
+#   class InvoicePayment < Hashie::Mash
+#     include Harvest::Model
+
+#     api_path '/payments'
+#     def self.json_root; 'payment'; end
+#   end
+# end

data/lib/forecast/line_item.rb

@@ -0,0 +1,4 @@
+# module Harvest
+#   class LineItem < Hashie::Mash
+#   end
+# end