nylas 0.15.5

data/lib/calendar.rb

@@ -0,0 +1,15 @@
+require 'restful_model'
+require 'event'
+
+module Inbox
+  class Calendar < RestfulModel
+
+    parameter :name
+    parameter :description
+
+    def events
+      @events ||= RestfulModelCollection.new(Event, @_api, @namespace, {:calendar_id=>@id})
+    end
+
+  end
+end

data/lib/contact.rb

@@ -0,0 +1,10 @@
+require 'restful_model'
+
+module Inbox
+  class Contact < RestfulModel
+
+    parameter :name
+    parameter :email
+
+  end
+end

data/lib/draft.rb

@@ -0,0 +1,32 @@
+require 'restful_model'
+
+module Inbox
+  class Draft < Message
+
+    parameter :thread_id
+    parameter :version
+    parameter :reply_to_message_id
+
+    def attach(file)
+      file.save! unless file.id
+      @file_ids.push(file.id)
+    end
+
+    def send!
+      url = @_api.url_for_path("/n/#{@namespace_id}/send")
+      if @id
+        data = {:draft_id => @id, :version => @version}
+      else
+        data = as_json()
+      end
+
+      ::RestClient.post(url, data.to_json, :content_type => :json) do |response, request, result|
+        json = Inbox.interpret_response(result, response, :expected_class => Object)
+        self.inflate(json)
+      end
+
+      self
+    end
+
+  end
+end

data/lib/event.rb

@@ -0,0 +1,34 @@
+require 'restful_model'
+
+module Inbox
+  class Event < RestfulModel
+
+    parameter :title
+    parameter :description
+    parameter :location
+    parameter :read_only
+    parameter :participants
+    parameter :when
+    parameter :calendar_id
+    parameter :namespace_id
+    parameter :recurrence
+    parameter :cancelled
+    parameter :master_event_id
+    parameter :original_start_time
+
+    def as_json(options = {})
+      hash = super(options)
+
+      # Delete nil values from the hash
+      hash.delete_if { |key, value| value.nil? }
+
+      # The API doesn't like to receive: "object": "timespan" in the when block.
+      if hash.has_key?('when') and hash['when'].has_key?('object')
+        hash['when'].delete('object')
+      end
+
+      return hash
+    end
+
+  end
+end

data/lib/file.rb

@@ -0,0 +1,31 @@
+require 'restful_model'
+
+module Inbox
+  class File < RestfulModel
+
+    parameter :size
+    parameter :filename
+    parameter :content_type
+    parameter :is_embedded
+    parameter :message_id
+
+    # For uploading the file
+    parameter :file
+
+    def inflate(json)
+      super
+      content_type = json["content-type"] if json["content-type"]
+    end
+
+    def save!
+      ::RestClient.post(url, {:file => @file}) do |response, request, result|
+        json = Inbox.interpret_response(result, response, :expected_class => Object)
+        json = json[0] if (json.class == Array)
+        inflate(json)
+      end
+      self
+    end
+
+  end
+end
+

data/lib/inbox.rb

@@ -0,0 +1,141 @@
+require 'version'
+require 'rest-client'
+require 'restful_model_collection'
+require 'json'
+require 'namespace'
+require 'account'
+
+module Inbox
+
+  class AccessDenied < StandardError; end
+  class ResourceNotFound < StandardError; end
+  class NoAuthToken < StandardError; end
+  class UnexpectedAccountAction < StandardError; end
+  class UnexpectedResponse < StandardError; end
+  class APIError < StandardError
+    attr_accessor :error_type
+    def initialize(type, error)
+      super(error)
+      self.error_type = type
+    end
+  end
+  class InvalidRequest < APIError; end
+  class MessageRejected < APIError; end
+  class SendingQuotaExceeded < APIError; end
+  class ServiceUnavailable < APIError; end
+
+  def self.interpret_http_status(result)
+    # Handle HTTP errors and RestClient errors
+    raise ResourceNotFound.new if result.code.to_i == 404
+    raise AccessDenied.new if result.code.to_i == 403
+  end
+
+  def self.interpret_response(result, result_content, options = {})
+    # Handle HTTP errors
+    Inbox.interpret_http_status(result)
+
+    # Handle content expectation errors
+    raise UnexpectedResponse.new if options[:expected_class] && result_content.empty?
+    json = JSON.parse(result_content)
+    if json.is_a?(Hash) && (json['type'] == 'api_error' or json['type'] == 'invalid_request_error')
+      if result.code.to_i == 400
+        exc = InvalidRequest
+      elsif result.code.to_i == 402
+        exc = MessageRejected
+      elsif result.code.to_i == 429
+        exc = SendingQuotaExceeded
+      elsif result.code.to_i == 503
+        exc = ServiceUnavailable
+      else
+        exc = APIError
+      end
+      raise exc.new(json['type'], json['message'])
+    end
+    raise UnexpectedResponse.new(result.msg) if result.is_a?(Net::HTTPClientError)
+    raise UnexpectedResponse.new if options[:expected_class] && !json.is_a?(options[:expected_class])
+    json
+
+  rescue JSON::ParserError => e
+    # Handle parsing errors
+    raise UnexpectedResponse.new(e.message)
+  end
+
+
+  class API
+    attr_accessor :api_server
+    attr_reader :access_token
+    attr_reader :app_id
+    attr_reader :app_secret
+
+    def initialize(app_id, app_secret, access_token = nil, api_server = 'https://api.nylas.com',
+                   service_domain = 'api.nylas.com')
+      raise "When overriding the Inbox API server address, you must include https://" unless api_server.include?('://')
+      @api_server = api_server
+      @access_token = access_token
+      @app_secret = app_secret
+      @app_id = app_id
+      @service_domain = service_domain
+      @version = Inbox::VERSION
+
+      if ::RestClient.before_execution_procs.empty?
+        ::RestClient.add_before_execution_proc do |req, params|
+          req.add_field('X-Inbox-API-Wrapper', 'ruby')
+          req['User-Agent'] = "Ruby SDK #{@version} - #{RUBY_VERSION}"
+        end
+      end
+    end
+
+    def url_for_path(path)
+      raise NoAuthToken.new if @access_token == nil and (@app_secret != nil or @app_id != nil)
+      protocol, domain = @api_server.split('//')
+      "#{protocol}//#{@access_token}:@#{domain}#{path}"
+    end
+
+    def url_for_authentication(redirect_uri, login_hint = '', options = {})
+      trialString = 'false'
+      if options[:trial] == true
+        trialString = 'true'
+      end
+      "https://#{@service_domain}/oauth/authorize?client_id=#{@app_id}&trial=#{trialString}&response_type=code&scope=email&login_hint=#{login_hint}&redirect_uri=#{redirect_uri}"
+    end
+
+    def url_for_management
+      protocol, domain = @api_server.split('//')
+      accounts_path = "#{protocol}//#{@app_secret}:@#{domain}/a/#{@app_id}/accounts"
+    end
+
+    def set_access_token(token)
+      @access_token = token
+    end
+
+    def token_for_code(code)
+      data = {
+          'client_id' => app_id,
+          'client_secret' => app_secret,
+          'grant_type' => 'authorization_code',
+          'code' => code
+      }
+
+      ::RestClient.post("https://#{@service_domain}/oauth/token", data) do |response, request, result|
+        json = Inbox.interpret_response(result, response, :expected_class => Object)
+        return json['access_token']
+      end
+    end
+
+    # Convenience Methods
+
+    def namespaces
+      @namespaces ||= RestfulModelCollection.new(Namespace, self, nil)
+      @namespaces
+    end
+
+    # Billing Methods
+
+    def accounts
+      @accounts ||= ManagementModelCollection.new(Account, self, nil)
+      @accounts
+    end
+  end
+end
+
+Nylas = Inbox.clone

data/lib/message.rb

@@ -0,0 +1,41 @@
+require 'restful_model'
+require 'file'
+require 'rfc2882'
+
+module Inbox
+  class Message < RestfulModel
+
+    parameter :subject
+    parameter :snippet
+    parameter :from
+    parameter :to
+    parameter :cc
+    parameter :bcc
+    parameter :date
+    parameter :thread_id
+    parameter :body
+    parameter :unread
+
+    def inflate(json)
+      super
+      @to ||= []
+      @cc ||= []
+      @bcc ||= []
+    end
+
+    def files
+      @files ||= RestfulModelCollection.new(File, @_api, @namespace_id, {:message_id=>@id})
+    end
+
+    def raw
+      model = nil
+      collection = RestfulModelCollection.new(Message, @_api, @namespace_id, {:message_id=>@id})
+      RestClient.get("#{collection.url}/#{id}/rfc2822"){ |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        model = Rfc2822.new(@_api)
+        model.inflate(json)
+      }
+      model
+    end
+  end
+end

data/lib/namespace.rb

@@ -0,0 +1,147 @@
+require 'restful_model'
+require 'account'
+require 'tag'
+require 'message'
+require 'draft'
+require 'contact'
+require 'file'
+require 'calendar'
+require 'event'
+
+# Rather than saying require 'thread', we need to explicitly force
+# the thread model to load. Otherwise, we can't reference it below.
+# Thread still refers to the built-in Thread type, and Inbox::Thread
+# is undefined.
+load "api_thread.rb"
+
+module Inbox
+
+  class Namespace < RestfulModel
+
+    parameter :account_id
+    parameter :name
+    parameter :email_address
+    parameter :provider
+
+    def self.collection_name
+      "n"
+    end
+
+    def threads
+      @threads ||= RestfulModelCollection.new(Thread, @_api, @id)
+    end
+
+    def tags
+      @tags ||= RestfulModelCollection.new(Tag, @_api, @id)
+    end
+
+    def messages
+      @messages ||= RestfulModelCollection.new(Message, @_api, @id)
+    end
+
+    def files
+      @files ||= RestfulModelCollection.new(File, @_api, @id)
+    end
+
+    def drafts
+      @drafts ||= RestfulModelCollection.new(Draft, @_api, @id)
+    end
+
+    def contacts
+      @contacts ||= RestfulModelCollection.new(Contact, @_api, @id)
+    end
+
+    def calendars
+      @calendars ||= RestfulModelCollection.new(Calendar, @_api, @id)
+    end
+
+    def events
+      @events ||= RestfulModelCollection.new(Event, @_api, @id)
+    end
+
+    def get_cursor(timestamp)
+      # Get the cursor corresponding to a specific timestamp.
+      path = @_api.url_for_path("/n/#{@namespace_id}/delta/generate_cursor")
+      data = { :start => timestamp }
+
+      cursor = nil
+
+      RestClient.post(path, data.to_json, :content_type => :json) do |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        cursor = json["cursor"]
+      end
+
+      cursor
+    end
+
+    OBJECTS_TABLE = {
+      "account" => Inbox::Account,
+      "calendar" => Inbox::Calendar,
+      "draft" => Inbox::Draft,
+      "thread" => Inbox::Thread,
+      "contact" => Inbox::Contact,
+      "event" => Inbox::Event,
+      "file" => Inbox::File,
+      "message" => Inbox::Message,
+      "namespace" => Inbox::Namespace,
+      "tag" => Inbox::Tag,
+    }
+
+    def deltas(cursor, exclude_types=[])
+      raise 'Please provide a block for receiving the delta objects' if !block_given?
+      exclude_string = ""
+
+      if exclude_types.any?
+        exclude_string = "&exclude_types="
+
+        exclude_types.each do |value|
+          count = 0
+          if OBJECTS_TABLE.has_value?(value)
+            param_name = OBJECTS_TABLE.key(value)
+            exclude_string += "#{param_name},"
+          end
+        end
+      end
+
+      exclude_string = exclude_string[0..-2]
+
+      # loop and yield deltas until we've come to the end.
+      loop do
+        path = @_api.url_for_path("/n/#{@namespace_id}/delta?cursor=#{cursor}#{exclude_string}")
+        json = nil
+
+        RestClient.get(path) do |response,request,result|
+          json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        end
+
+        start_cursor = json["cursor_start"]
+        end_cursor = json["cursor_end"]
+
+        json["deltas"].each do |delta|
+          object = delta['object']
+          if object == 'message'
+              # Drafts are messages underneath
+              object = delta['attributes']['object']
+          end
+          cls = OBJECTS_TABLE[object]
+          obj = cls.new(@_api, @namespace_id)
+
+          case delta["event"]
+          when 'create', 'modify'
+              obj.inflate(delta['attributes'])
+              obj.cursor = delta["cursor"]
+              yield delta["event"], obj
+          when 'delete'
+              obj.id = delta["id"]
+              obj.cursor = delta["cursor"]
+              yield delta["event"], obj
+          end
+        end
+
+        break if start_cursor == end_cursor
+        cursor = end_cursor
+      end
+    end
+
+  end
+end