nylas-shipmnts 3.0.0

data/lib/mixins.rb

@@ -0,0 +1,26 @@
+module Nylas
+  module ReadUnreadMethods
+    def update_param!(param, value)
+      update('PUT', '', {
+        param => value,
+      })
+    end
+
+    def mark_as_read!
+      update_param!(:unread, false)
+    end
+
+    def mark_as_unread!
+      update_param!(:unread, true)
+    end
+
+    def star!
+      update_param!(:starred, true)
+    end
+
+    def unstar!
+      update_param!(:starred, false)
+    end
+  end
+end
+

data/lib/nylas.rb

@@ -0,0 +1,394 @@
+require 'json'
+require 'rest-client'
+require 'yajl'
+require 'em-http'
+
+
+require 'ostruct'
+require 'active_support/core_ext/hash'
+
+require 'account'
+require 'api_account'
+require 'api_thread'
+require 'calendar'
+require 'account'
+require 'message'
+require 'expanded_message'
+require 'draft'
+require 'contact'
+require 'file'
+require 'calendar'
+require 'event'
+require 'folder'
+require 'restful_model'
+require 'restful_model_collection'
+require 'version'
+
+module Nylas
+  Error = Class.new(::StandardError)
+  NoAuthToken = Class.new(Error)
+  UnexpectedAccountAction = Class.new(Error)
+  UnexpectedResponse = Class.new(Error)
+  class APIError < Error
+    attr_accessor :type
+    attr_accessor :message
+    attr_accessor :server_error
+
+    def initialize(type, message, server_error = nil)
+      super(message)
+      self.type = type
+      self.message = message
+      self.server_error = server_error
+    end
+  end
+  AccessDenied = Class.new(APIError)
+  ResourceNotFound = Class.new(APIError)
+  InvalidRequest = Class.new(APIError)
+  MessageRejected = Class.new(APIError)
+  SendingQuotaExceeded = Class.new(APIError)
+  ServiceUnavailable = Class.new(APIError)
+  BadGateway = Class.new(APIError)
+  InternalError = Class.new(APIError)
+  MailProviderError = Class.new(APIError)
+
+  HTTP_CODE_TO_EXCEPTIONS = {
+    400 => InvalidRequest,
+    402 => MessageRejected,
+    403 => AccessDenied,
+    404 => ResourceNotFound,
+    422 => MailProviderError,
+    429 => SendingQuotaExceeded,
+    500 => InternalError,
+    502 => BadGateway,
+    503 => ServiceUnavailable,
+  }.freeze
+
+  def self.http_code_to_exception(http_code)
+    HTTP_CODE_TO_EXCEPTIONS.fetch(http_code, APIError)
+  end
+
+  def self.interpret_response(result, result_content, options = {})
+
+    # We expected a certain kind of object, but the API didn't return anything
+    raise UnexpectedResponse.new if options[:expected_class] && result_content.empty?
+
+    # If it's already parsed, or if we've received an actual raw payload on success, don't parse
+    if options[:result_parsed] || (options[:raw_response] && result.code.to_i == 200)
+      response = result_content
+    else
+      response = JSON.parse(result_content)
+    end
+
+    if result.code.to_i != 200
+      exc = Nylas.http_code_to_exception(result.code.to_i)
+      if response.is_a?(Hash)
+        raise exc.new(response['type'], response['message'], response.fetch('server_error', nil))
+      end
+    end
+
+    raise UnexpectedResponse.new(result.msg) if result.is_a?(Net::HTTPClientError)
+    raise UnexpectedResponse.new if options[:expected_class] && !response.is_a?(options[:expected_class])
+    response
+
+  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 Nylas 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 = Nylas::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'] = "Nylas 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 = {})
+      params = {
+        :client_id => @app_id,
+        :trial => options.fetch(:trial, false),
+        :response_type => 'code',
+        :scope => 'email',
+        :login_hint => login_hint,
+        :redirect_uri => redirect_uri,
+      }
+
+      if options.has_key?(:state) then
+        params[:state] = options[:state]
+      end
+
+      "https://#{@service_domain}/oauth/authorize?" + params.to_query
+    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 = Nylas.interpret_response(result, response, :expected_class => Object)
+        return json['access_token']
+      end
+    end
+
+    # API Methods
+    def threads
+      @threads ||= RestfulModelCollection.new(Thread, self)
+    end
+
+    def messages(expanded: false)
+      @messages ||= Hash.new do |h, is_expanded|
+        h[is_expanded] = \
+          if is_expanded
+            RestfulModelCollection.new(ExpandedMessage, self, view: 'expanded')
+          else
+            RestfulModelCollection.new(Message, self)
+          end
+      end
+      @messages[expanded]
+    end
+
+    def files
+      @files ||= RestfulModelCollection.new(File, self)
+    end
+
+    def drafts
+      @drafts ||= RestfulModelCollection.new(Draft, self)
+    end
+
+    def contacts
+      @contacts ||= RestfulModelCollection.new(Contact, self)
+    end
+
+    def calendars
+      @calendars ||= RestfulModelCollection.new(Calendar, self)
+    end
+
+    def events
+      @events ||= RestfulModelCollection.new(Event, self)
+    end
+
+    def folders
+      @folders ||= RestfulModelCollection.new(Folder, self)
+    end
+
+    def labels
+      @labels ||= RestfulModelCollection.new(Label, self)
+    end
+
+    def account
+      path = self.url_for_path("/account")
+
+      RestClient.get(path, {}) do |response,request,result|
+        json = Nylas.interpret_response(result, response, {:expected_class => Object})
+        model = APIAccount.new(self)
+        model.inflate(json)
+        model
+      end
+    end
+
+    def using_hosted_api?
+       return !@app_id.nil?
+    end
+
+    def accounts
+          if self.using_hosted_api?
+               @accounts ||= ManagementModelCollection.new(Account, self)
+          else
+               @accounts ||= RestfulModelCollection.new(APIAccount, self)
+          end
+    end
+
+    def latest_cursor
+      # Get the cursor corresponding to a specific timestamp.
+      path = self.url_for_path("/delta/latest_cursor")
+
+      cursor = nil
+
+      RestClient.post(path, :content_type => :json) do |response,request,result|
+        json = Nylas.interpret_response(result, response, {:expected_class => Object})
+        cursor = json["cursor"]
+      end
+
+      cursor
+    end
+
+    OBJECTS_TABLE = {
+      "account" => Nylas::Account,
+      "calendar" => Nylas::Calendar,
+      "draft" => Nylas::Draft,
+      "thread" => Nylas::Thread,
+      "contact" => Nylas::Contact,
+      "event" => Nylas::Event,
+      "file" => Nylas::File,
+      "message" => Nylas::Message,
+      "folder" => Nylas::Folder,
+      "label" => Nylas::Label,
+    }
+
+    # It's possible to ask the API to expand objects.
+    # In this case, we do the right thing and return
+    # an expanded object.
+    EXPANDED_OBJECTS_TABLE = {
+      "message" => Nylas::ExpandedMessage,
+    }
+
+    def _build_exclude_types(exclude_types)
+      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
+
+      exclude_string = exclude_string[0..-2]
+    end
+
+    def deltas(cursor, exclude_types=[], expanded_view=false)
+      return enum_for(:deltas, cursor, exclude_types, expanded_view) unless block_given?
+
+      exclude_string = ""
+
+      if exclude_types.any?
+        exclude_string = _build_exclude_types(exclude_types)
+      end
+
+      # loop and yield deltas until we've come to the end.
+      loop do
+        path = self.url_for_path("/delta?exclude_folders=false&cursor=#{cursor}#{exclude_string}")
+        if expanded_view
+          path += '&view=expanded'
+        end
+
+        json = nil
+
+        RestClient.get(path) do |response,request,result|
+          json = Nylas.interpret_response(result, response, {:expected_class => Object})
+        end
+
+        start_cursor = json["cursor_start"]
+        end_cursor = json["cursor_end"]
+
+        json["deltas"].each do |delta|
+          if not OBJECTS_TABLE.has_key?(delta['object'])
+            next
+          end
+
+          cls = OBJECTS_TABLE[delta['object']]
+          if EXPANDED_OBJECTS_TABLE.has_key?(delta['object']) and expanded_view
+            cls = EXPANDED_OBJECTS_TABLE[delta['object']]
+          end
+
+          obj = cls.new(self)
+
+          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
+
+    def delta_stream(cursor, exclude_types=[], timeout=0, expanded_view=false)
+      raise 'Please provide a block for receiving the delta objects' if !block_given?
+
+      exclude_string = ""
+
+      if exclude_types.any?
+        exclude_string = _build_exclude_types(exclude_types)
+      end
+
+      # loop and yield deltas indefinitely.
+      path = self.url_for_path("/delta/streaming?exclude_folders=false&cursor=#{cursor}#{exclude_string}")
+      if expanded_view
+        path += '&view=expanded'
+      end
+
+      parser = Yajl::Parser.new(:symbolize_keys => false)
+      parser.on_parse_complete = proc do |data|
+        delta = Nylas.interpret_response(OpenStruct.new(:code => '200'), data, {:expected_class => Object, :result_parsed => true})
+
+        if not OBJECTS_TABLE.has_key?(delta['object'])
+          next
+        end
+
+        cls = OBJECTS_TABLE[delta['object']]
+        if EXPANDED_OBJECTS_TABLE.has_key?(delta['object']) and expanded_view
+          cls = EXPANDED_OBJECTS_TABLE[delta['object']]
+        end
+
+        obj = cls.new(self)
+
+        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
+
+      http = EventMachine::HttpRequest.new(path, :connect_timeout => 0, :inactivity_timeout => timeout).get(:keepalive => true)
+
+      # set a callback on the HTTP stream that parses incoming chunks as they come in
+      http.stream do |chunk|
+        parser << chunk
+      end
+
+      http.errback do
+        raise UnexpectedResponse.new http.error
+      end
+
+    end
+  end
+end

data/lib/parameters.rb

@@ -0,0 +1,26 @@
+module Nylas
+  module Parameters
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def parameters
+      self.class.instance_variable_get("@parameters")
+    end
+
+    module ClassMethods
+      def parameter(*params)
+        @parameters ||= []
+        params.each do |param|
+          attr_accessor param
+          @parameters << param.to_s
+        end
+      end
+
+      def inherited(subclass)
+        parameters = instance_variable_get("@parameters") || []
+        subclass.instance_variable_set("@parameters", parameters.clone)
+      end
+    end
+  end
+end

data/lib/restful_model.rb

@@ -0,0 +1,82 @@
+require 'time_attr_accessor'
+require 'parameters'
+
+module Nylas
+  class RestfulModel
+    extend Nylas::TimeAttrAccessor
+    include Nylas::Parameters
+
+    parameter :id
+    parameter :account_id
+    parameter :cursor  # Only used by the delta sync API
+    time_attr_accessor :created_at
+    attr_reader :raw_json
+
+    def self.collection_name
+      "#{self.to_s.downcase}s".split('::').last
+    end
+
+    def initialize(api, account_id = nil)
+      raise StandardError.new unless api.class <= Nylas::API
+      @account_id = account_id
+      @_api = api
+    end
+
+    def ==(comparison_object)
+      comparison_object.equal?(self) || (comparison_object.instance_of?(self.class) && comparison_object.id == id)
+    end
+
+    def inflate(json)
+      @raw_json = json
+      parameters.each do |property_name|
+        send("#{property_name}=", json[property_name]) if json.has_key?(property_name)
+      end
+    end
+
+    def save!(params={})
+      if id
+        update('PUT', '', as_json(), params)
+      else
+        update('POST', '', as_json(), params)
+      end
+    end
+
+    def url(action = "")
+      action = "/#{action}" unless action.empty?
+      @_api.url_for_path("/#{self.class.collection_name}/#{id}#{action}")
+    end
+
+    def as_json(options = {})
+      hash = {}
+      parameters.each do |getter|
+        unless options[:except] && options[:except].include?(getter)
+          value = send(getter)
+          unless value.is_a?(RestfulModelCollection)
+            value = value.as_json(options) if value.respond_to?(:as_json)
+            hash[getter] = value
+          end
+        end
+      end
+      hash
+    end
+
+    def update(http_method, action, data = {}, params = {})
+      http_method = http_method.downcase
+
+      ::RestClient.send(http_method, self.url(action), data.to_json, :content_type => :json, :params => params) do |response, request, result|
+        unless http_method == 'delete'
+          json = Nylas.interpret_response(result, response, :expected_class => Object)
+          inflate(json)
+        end
+      end
+      self
+    end
+
+    def destroy(params = {})
+      ::RestClient.send('delete', self.url, :params => params) do |response, request, result|
+        Nylas.interpret_response(result, response, {:raw_response => true})
+      end
+    end
+
+  end
+end