context_io 1.0.0.pre.beta

data/lib/context_io/account/sync.rb

@@ -0,0 +1,34 @@
+module ContextIO
+  class Sync
+    include ContextIO::CallHelpers
+    private
+    attr_reader :parent
+
+    public
+    attr_reader :status, :success, :connection, :response, :api_call_made
+    def initialize(parent:,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @response = response
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+    end
+
+    def call_url
+      "#{parent.call_url}/sync"
+    end
+
+    def get
+      request = Request.new(connection, :get, call_url)
+      @response = request.response
+      @status = request.status
+      @success = check_success(status)
+      self
+    end
+  end
+end

data/lib/context_io/account/threads.rb

@@ -0,0 +1,35 @@
+module ContextIO
+  class Threads
+    include ContextIO::CallHelpers
+    THREADS_READERS = %I(gmail_thread_id email_message_ids person_info messages)
+
+    private
+    attr_reader :parent
+
+    public
+    attr_reader :api_call_made
+    attr_reader :status, :success, :connection, :thread_id, *THREADS_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @thread_id = identifier
+      @response = response
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+    end
+
+    def call_url
+      build_url("threads", thread_id)
+    end
+
+    def get(**kwargs)
+      get_request(given_params: kwargs, valid_params: ValidGetParams::THREAD)
+    end
+  end
+end

data/lib/context_io/connection.rb

@@ -0,0 +1,25 @@
+require "faraday"
+require "faraday_middleware"
+
+module ContextIO
+  class Connection
+    ROOT_URL = "https://api.context.io"
+    USER_AGENT = "context_io-ruby-2.0"
+
+    attr_reader :key, :secret
+    def initialize(key, secret)
+      @key = key
+      @secret = secret
+    end
+
+    def connect
+      connection ||= Faraday::Connection.new(ROOT_URL) do |f|
+        f.headers["User-Agent"] = USER_AGENT
+        f.request :oauth, consumer_key: key, consumer_secret: secret
+        f.request :url_encoded
+        f.request :retry, max: 0
+        f.adapter Faraday.default_adapter
+      end
+    end
+  end
+end

data/lib/context_io/oauth_provider.rb

@@ -0,0 +1,33 @@
+module ContextIO
+  class OauthProvider
+    include ContextIO::CallHelpers
+    OAUTH_READERS = %I(type provider_consumer_key provider_consumer_secret resource_url)
+    private
+    attr_reader :connection
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :status, :parent, :success, :key, *OAUTH_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @response = response
+      @status = status
+      @success = success
+      @key = identifier
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def call_url
+      build_url("oauth_providers", key)
+    end
+  end
+end

data/lib/context_io/shared/connect_token.rb

@@ -0,0 +1,35 @@
+module ContextIO
+  class ConnectToken
+    include ContextIO::CallHelpers
+    CONNECT_READERS = %I(email source_callback_url source_raw_file_list created
+                         used expires status_callback_url first_name last_name account
+                         resource_url server_label callback_url browser_redirect_url)
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :token, :connection, :success, :status, :resposne, *CONNECT_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @token = identifier
+      @response = response
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def call_url
+      build_url("connect_tokens", token)
+    end
+  end
+end

data/lib/context_io/shared/discovery.rb

@@ -0,0 +1,31 @@
+module ContextIO
+  class Discovery
+    include ContextIO::CallHelpers
+    DISCOVERY_READERS = %I(email found resource_url type imap documentation)
+
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :status, :success, :connection, :response, *DISCOVERY_READERS
+    def initialize(parent:,
+                   email:,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @email = email
+      @response = response
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+    end
+
+    def call_url
+      "#{parent.call_url}/discovery?email=#{email}&source_type=IMAP"
+    end
+  end
+end

data/lib/context_io/shared/folder.rb

@@ -0,0 +1,57 @@
+module ContextIO
+  class Folder
+    include ContextIO::CallHelpers
+    FOLDER_READERS = %I(symbolic_name attributes delim nb_messages xlist_name
+                        nb_unseen_messages resource_url name)
+
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :status, :success, :connection, :response, *FOLDER_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @status = status
+      @success = success
+      @parent = parent
+      @connection = parent.connection
+      @name = identifier
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def encoded_name
+      ERB::Util.url_encode(name)
+    end
+
+    def call_url
+      build_url("folders", encoded_name)
+    end
+
+    def source_parent?
+      parent.class == Sources
+    end
+
+    def get(**kwargs)
+      if source_parent?
+        get_request(given_params: kwargs, valid_params: ValidGetParams::SOURCE_FOLDER)
+      else
+        get_request(given_params: kwargs)
+      end
+    end
+
+    def get_messages(**kwargs)
+      collection_return(url: "#{call_url}/messages",
+                        klass: Message,
+                        valid_params: ValidGetParams::SOURCE_FOLDER_MESSAGES,
+                        given_params: kwargs)
+    end
+  end
+end

data/lib/context_io/shared/message.rb

@@ -0,0 +1,112 @@
+module ContextIO
+  class Message
+    include ContextIO::CallHelpers
+    MESSAGE_READERS = %I(date date_indexed date_received addresses person_info email_message_id
+                       message_id gmail_message_id gmail_thread_id files subject
+                       folders sources content type charset body_section answered
+                       deleted draft flagged seen in_reply_to references resource_url)
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :status, :success, :connection, :message_id, :response, *MESSAGE_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @message_id = identifier
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def encoded_message_id
+      ERB::Util.url_encode(message_id)
+    end
+
+    def call_url
+      build_url("messages", encoded_message_id)
+    end
+
+    def parent_not_account_error
+      raise StandardError, "This method can only be called from '2.0/accounts/:account/message/:message_id'" if parent.class != Account
+    end
+
+    def get(**kwargs)
+      get_request(given_params: kwargs, valid_params: ValidGetParams::MESSAGE)
+    end
+
+    def post(dst_folder:, **kwargs)
+      parent_not_account_error
+      given_params = kwargs.merge(dst_folder: dst_folder)
+      message = call_api_return_updated_object(klass: Message,
+                                               url: "#{call_url}",
+                                               identifier: encoded_message_id,
+                                               method: :post,
+                                               valid_params: ValidPostParams::MESSAGE_MOVE_20,
+                                               given_params: given_params)
+      return_post_api_call_made(message)
+    end
+
+    def get_body(**kwargs)
+      parent_not_account_error
+      call_api_return_new_object(klass: Message,
+                                 url: "#{call_url}/body",
+                                 valid_params: ValidGetParams::MESSAGE_BODY,
+                                 given_params: kwargs)
+    end
+
+    def get_flags
+      parent_not_account_error
+      call_api_return_new_object(klass: Message,
+                                 url: "#{call_url}/flags")
+    end
+
+    def post_flags(**kwargs)
+      parent_not_account_error
+      flags = call_api_return_updated_object(klass: Message,
+                                             url: "#{call_url}/flags",
+                                             identifier: encoded_message_id,
+                                             method: :post,
+                                             valid_params: ValidPostParams::FLAGS,
+                                             given_params: kwargs)
+      return_post_api_call_made(flags)
+    end
+
+    def get_folders
+      parent_not_account_error
+      call_api_return_new_object(klass: Message,
+                                 url: "#{call_url}/folders")
+    end
+
+    def get_headers(**kwargs)
+      parent_not_account_error
+      call_api_return_new_object(klass: Message,
+                                 url: "#{call_url}/headers",
+                                 valid_params: ValidGetParams::MESSAGE_HEADER,
+                                 given_params: kwargs)
+    end
+
+    def get_source
+      parent_not_account_error
+      call_api_return_new_object(klass: Message,
+                                 url: "#{call_url}/source")
+    end
+
+    def get_threads(**kwargs)
+      parent_not_account_error
+      call_api_return_new_object(klass: Message,
+                                 url: "#{call_url}/thread",
+                                 valid_params: ValidGetParams::MESSAGE_THREADS,
+                                 given_params: kwargs)
+    end
+  end
+end

data/lib/context_io/shared/webhook.rb

@@ -0,0 +1,43 @@
+module ContextIO
+  class Webhook
+    include ContextIO::CallHelpers
+    WEBHOOK_READERS = %I(callback_url failure_notif_url active webhook_id resource_url)
+
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :webhook_id, :success, :connection, :status, *WEBHOOK_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @webhook_id = identifier
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def call_url
+      build_url("webhooks", webhook_id)
+    end
+
+    def post(**kwargs)
+      webhook = call_api_return_updated_object(klass: Webhook,
+                                               url: call_url,
+                                               identifier: webhook_id,
+                                               method: :post,
+                                               valid_params: ValidPostParams::WEBHOOK,
+                                               given_params: kwargs)
+      return_post_api_call_made(webhook)
+    end
+  end
+end

data/lib/context_io/utilities/api_call_made.rb

@@ -0,0 +1,5 @@
+module ContextIO
+  module APICallMade
+    CALL_MADE_STRUCT= Struct.new(:url, :method, :allowed_params, :rejected_params)
+  end
+end

data/lib/context_io/utilities/call_helpers.rb

@@ -0,0 +1,145 @@
+module ContextIO
+  module CallHelpers
+    require_relative './collection_helper.rb'
+    include ContextIO::CollectionHelper
+    def parse_response(response)
+      if [Array, String].include?(response.class)
+        @response = response
+      else
+        response.each do |k,v|
+          key = k.to_s.gsub('-', '_')
+          instance_variable_set("@#{key}", v)
+        end
+      end
+    end
+
+    def build_url(resource, identifier)
+      "#{parent.call_url}/#{resource}/#{identifier}"
+    end
+
+    def get_request(given_params: nil, valid_params: nil, url: nil)
+      request, api_call_made = call_api(method: :get,
+                                        url: url || call_url,
+                                        given_params: given_params,
+                                        valid_params:valid_params)
+      parse_response(request.response)
+      @status = request.status
+      @success = check_success(status)
+      @api_call_made = api_call_made
+      self
+    end
+
+    def call_api_return_new_object(klass:,
+                                   url:,
+                                   method: :get,
+                                   parent: nil,
+                                   valid_params: nil,
+                                   given_params: nil)
+      request, api_call_made = call_api(method: method,
+                                        url: url,
+                                        given_params: given_params,
+                                        valid_params: valid_params)
+      klass.new(parent: parent || self,
+                response: request.response,
+                status: request.status,
+                success: request.success,
+                api_call_made: api_call_made)
+    end
+
+    def call_api_return_updated_object(klass:,
+                                       url:,
+                                       identifier:,
+                                       method: :post,
+                                       valid_params: nil,
+                                       given_params: nil)
+      request, api_call_made = call_api(method: method,
+                                        url: url,
+                                        given_params: given_params,
+                                        valid_params: valid_params)
+      object = klass.new(parent: parent,
+                         response: request.response,
+                         identifier: identifier,
+                         status: request.status,
+                         success: request.success,
+                         api_call_made: api_call_made)
+      return_post_api_call_made(object)
+    end
+
+    def validate_params(inputed_params, valid_params)
+      return [nil, nil] if inputed_params.nil?
+      rejected_params = []
+      params = []
+      inputed_params.map do |key, value|
+        if valid_params.include?(key)
+          params << [key, value]
+        else
+          rejected_params << key
+        end
+      end
+      params = params.compact
+      if !params.empty?
+        params = params.to_h
+      end
+      [params, rejected_params]
+    end
+
+    def get(**kwargs)
+      get_request(given_params: kwargs)
+    end
+
+    def delete
+      request = Request.new(connection, :delete, call_url)
+      raise StandardError, build_error_message(request.status, request.response) if request.success == false
+      api_call_made = build_api_call_made(request.url,
+                                          :delete,
+                                          nil,
+                                          nil)
+      DeletedResource.new(response: request.response,
+                          status: request.status,
+                          success: request.success,
+                          api_call_made: api_call_made)
+    end
+
+    def success?
+      self.success
+    end
+
+    def return_post_api_call_made(object)
+      call_made = object.api_call_made
+      object.get
+      object.api_call_made = call_made
+      object
+    end
+
+    private
+    def call_api(method:, url:, given_params:, valid_params:)
+      allowed_params, rejected_params = validate_params(given_params, valid_params)
+      request = Request.new(connection, method, url || call_url, allowed_params)
+      raise StandardError, build_error_message(request.status, request.response) if request.success == false
+      api_call_made = build_api_call_made(request.url,
+                                          method,
+                                          allowed_params,
+                                          rejected_params)
+      [request, api_call_made]
+    end
+
+    def check_success(status)
+      status >= 200 && status <= 299
+    end
+
+    def build_api_call_made(url, method, allowed_params, rejected_params)
+      APICallMade::CALL_MADE_STRUCT.new(url,
+                                        method,
+                                        allowed_params,
+                                        rejected_params)
+    end
+
+    def build_error_message(status, body)
+      if body.empty?
+        "HTTP code #{status}. No API error given."
+      else
+        "HTTP code #{status}. Response #{body}"
+      end
+    end
+  end
+end