context_io 1.0.0.pre.beta

data/lib/context_io.rb

@@ -0,0 +1,104 @@
+require 'context_io/account'
+require 'context_io/connection'
+require 'context_io/oauth_provider'
+
+require 'context_io/account/contact'
+require 'context_io/account/email_address'
+require 'context_io/account/files'
+require 'context_io/account/sources'
+require 'context_io/account/sync'
+require 'context_io/account/threads'
+
+require 'context_io/shared/connect_token'
+require 'context_io/shared/discovery'
+require 'context_io/shared/folder'
+require 'context_io/shared/message'
+require 'context_io/shared/webhook'
+
+require 'context_io/utilities/api_call_made'
+require 'context_io/utilities/call_helpers'
+require 'context_io/utilities/collection_helper'
+require 'context_io/utilities/deleted_resource'
+require 'context_io/utilities/request'
+require 'context_io/utilities/valid_parameters/get_params'
+require 'context_io/utilities/valid_parameters/post_params'
+
+require "erb"
+
+module ContextIO
+  class ContextIO
+    include CollectionHelper
+    include CallHelpers
+    attr_reader :connection, :call_url
+    def initialize(key:, secret:)
+      @connection = Connection.new(key, secret)
+      @call_url = "/2.0"
+    end
+
+    def get_accounts(**kwargs)
+      collection_return(url: "#{call_url}/accounts",
+                        klass: Account,
+                        valid_params: ValidGetParams::ACCOUNTS,
+                        given_params: kwargs)
+    end
+
+    def post_account(type: "IMAP", **kwargs)
+      given_params = kwargs.merge(type: type)
+      account = call_api_return_new_object(klass: Account,
+                                           url: "#{call_url}/accounts",
+                                           method: :post,
+                                           valid_params: ValidPostParams::ACCOUNTS,
+                                           given_params: given_params)
+      return_post_api_call_made(account)
+    end
+
+    def get_connect_tokens
+      collection_return(url: "#{call_url}/connect_tokens",
+                        klass: ConnectToken)
+    end
+
+    def post_connect_token(callback_url: , **kwargs)
+      given_params = kwargs.merge(callback_url: callback_url)
+      token = call_api_return_new_object(klass: ConnectToken,
+                                         url: "#{call_url}/connect_tokens",
+                                         method: :post,
+                                         valid_params: ValidPostParams::CONNECT_TOKEN,
+                                         given_params: given_params)
+      return_post_api_call_made(token)
+    end
+
+    def discovery(email:)
+      Discovery.new(parent: self, email: email).get
+    end
+
+    def get_oauth_providers
+      collection_return(url: "#{call_url}/oauth_providers",
+                        klass: OauthProvider)
+    end
+
+    def post_oauth_provider(type:, provider_consumer_key:, provider_consumer_secret:)
+      given_params = [type, provider_consumer_key, provider_consumer_secret]
+      provider = call_api_return_new_object(klass: OauthProvider,
+                                            url: "#{call_url}/oauth_provider",
+                                            method: :post,
+                                            valid_params: ValidPostParams::OAUTH_PROVIDER,
+                                            given_params: given_params)
+      return_post_api_call_made(provider)
+    end
+
+    def get_webhooks
+      collection_return(url: "#{call_url}/webhooks",
+                        klass: Webhook)
+    end
+
+    def post_webhook(callback_url:, **kwargs)
+      given_params = kwargs.merge(callback_url: callback_url)
+      token = call_api_return_new_object(klass: Webhook,
+                                         url: "#{call_url}/webhooks",
+                                         method: :post,
+                                         valid_params: ValidPostParams::WEBHOOK,
+                                         given_params: given_params)
+      return_post_api_call_made(token)
+    end
+  end
+end

data/lib/context_io/account.rb

@@ -0,0 +1,143 @@
+require "context_io/utilities/collection_helper"
+require "context_io/utilities/call_helpers"
+module ContextIO
+  class Account
+    include ContextIO::CallHelpers
+    ACCOUNT_READERS = %I(username created suspended email_addresses first_name last_name
+                       password_expired sources resource_url)
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :id, :success, :connection, :status, *ACCOUNT_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @id = identifier
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def call_url
+      build_url("accounts", id)
+    end
+
+    def post(**kwargs)
+      call_api_return_updated_object(klass: Account,
+                                     method: :post,
+                                     identifier: id,
+                                     url: call_url,
+                                     valid_params: ValidPostParams::ACCOUNT,
+                                     given_params: kwargs)
+    end
+
+    def get_connect_tokens
+      collection_return(url: "#{call_url}/connect_tokens",
+                        klass: ConnectToken)
+    end
+
+    def post_connect_token(callback_url:, **kwargs)
+      given_params = kwargs.merge(callback_url: callback_url)
+      token = call_api_return_new_object(klass: ConnectToken,
+                                         url: "#{call_url}/connect_tokens",
+                                         method: :post,
+                                         valid_params: ValidPostParams::CONNECT_TOKEN,
+                                         given_params: given_params)
+      return_post_api_call_made(token)
+    end
+
+    def get_contacts(**kwargs)
+      contact_collection_return(url: "#{call_url}/contacts",
+                                valid_params: ValidGetParams::CONTACTS,
+                                given_params: kwargs)
+    end
+
+    def get_email_addresses
+      collection_return(url: "#{call_url}/email_addresses",
+                        klass: EmailAddress)
+    end
+
+    def post_email_address(email_address:)
+      given_params = { email_address: email_address }
+      email = call_api_return_new_object(klass: EmailAddress,
+                                         url: "#{call_url}/email_addresses",
+                                         method: :post,
+                                         valid_params: [:email_address],
+                                         given_params: given_params)
+      return_post_api_call_made(email)
+    end
+
+    def get_files(**kwargs)
+      collection_return(url: "#{call_url}/files",
+                        klass: Files,
+                        valid_params: ValidGetParams::FILES,
+                        given_params: kwargs)
+    end
+
+    def get_messages(**kwargs)
+      collection_return(url: "#{call_url}/messages",
+                        klass: Message,
+                        valid_params: ValidGetParams::MESSAGES,
+                        given_params: kwargs)
+    end
+
+    def get_sources(**kwargs)
+      collection_return(url: "#{call_url}/sources",
+                        klass: Sources,
+                        valid_params: ValidGetParams::SOURCES,
+                        given_params: kwargs)
+    end
+
+    def post_source(email:, server:, username:, use_ssl:, port:, type: "IMAP", **kwargs)
+      given_params = kwargs.merge(email: email,
+                                  server: server,
+                                  username: username,
+                                  use_ssl: use_ssl,
+                                  port: port,
+                                  type: type)
+      token = call_api_return_new_object(klass: Sources,
+                                         url: "#{call_url}/sources",
+                                         method: :post,
+                                         valid_params: ValidPostParams::SOURCES,
+                                         given_params: given_params)
+      return_post_api_call_made(token)
+    end
+
+    def get_sync
+      Sync.new(parent: self).get
+    end
+
+    def get_threads(**kwargs)
+      call_api_return_new_object(klass: Threads,
+                                 url: "#{call_url}/threads",
+                                 valid_params: ValidGetParams::THREADS,
+                                 given_params: kwargs)
+    end
+
+    def get_webhooks
+      collection_return(url: "#{call_url}/webhooks",
+                        klass: Webhook)
+    end
+
+    def post_webhook(callback_url:, failure_notif_url:, **kwargs)
+      given_params = kwargs.merge(callback_url: callback_url,
+                                  failure_notif_url: failure_notif_url)
+      token = call_api_return_new_object(klass: Webhook,
+                                         url: "#{call_url}/webhooks",
+                                         method: :post,
+                                         valid_params: ValidPostParams::WEBHOOKS,
+                                         given_params: given_params)
+      return_post_api_call_made(token)
+    end
+  end
+end

data/lib/context_io/account/contact.rb

@@ -0,0 +1,59 @@
+module ContextIO
+  class Contact
+    include ContextIO::CallHelpers
+    CONTACT_READERS =  %I(emails name thumbnail last_received last_sent count sent_count
+                       received_count sent_from_account_count query email resource_url)
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :response, :status, :parent, :connection, :success, :email,
+                 *CONTACT_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @email = identifier
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def encoded_email
+      ERB::Util.url_encode(email)
+    end
+
+    def call_url
+      build_url("contacts", encoded_email)
+    end
+
+    def get_files(**kwargs)
+      collection_return(url: "#{call_url}/files",
+                        klass: Files,
+                        valid_params: ValidGetParams::CONTACT_FILES,
+                        given_params: kwargs)
+    end
+
+    def get_messages(**kwargs)
+      collection_return(url: "#{call_url}/messages",
+                        klass: Message,
+                        valid_params: ValidGetParams::CONTACT_MESSAGES,
+                        given_params: kwargs)
+    end
+
+    def get_threads(**kwargs)
+      call_api_return_new_object(klass: Threads,
+                                 url: "#{call_url}/threads",
+                                 valid_params: ValidGetParams::THREADS,
+                                 given_params: kwargs)
+    end
+  end
+end

data/lib/context_io/account/email_address.rb

@@ -0,0 +1,33 @@
+module ContextIO
+  class EmailAddress
+    include ContextIO::CallHelpers
+    EMAIL_ATTRS = %I(validated primary resource_url)
+
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :response, :status, :connection, :success, :email, *EMAIL_ATTRS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @email = identifier
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def call_url
+      build_url("email_addresses", email)
+    end
+  end
+end

data/lib/context_io/account/files.rb

@@ -0,0 +1,58 @@
+module ContextIO
+  class Files
+    include ContextIO::CallHelpers
+    FILE_READERS = %I(size type subject date date_indexed addresses person_info
+                   file_name file_name_structure body_section supports_preview
+                   is_embedded content_disposition content_id message_id
+                   email_message_id gmail_message_id gmail_thread_id email_addresses
+                   created first_name id last_name resource_url sources is_tnef_part)
+
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :connection, :response, :status, :success, :file_id, *FILE_READERS
+    def initialize(parent:,
+                   identifier: nil,
+                   response: nil,
+                   status: nil,
+                   success: nil,
+                   api_call_made: nil)
+      @parent = parent
+      @connection = parent.connection
+      @file_id = identifier
+      @status = status
+      @success = success
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def call_url
+      build_url("files", file_id)
+    end
+
+    def contact_url?
+      parent.call_url.include?("/contacts/")
+    end
+
+    def contact_url_error
+      raise StandardError, "This method can only be called from '2.0/accounts/:account/file/:file_id'" if contact_url?
+    end
+
+    def get_content(**kwargs)
+      contact_url_error
+      call_api_return_new_object(klass: Files,
+                                 url: "#{call_url}/content",
+                                 valid_params: ValidGetParams::FILE_CONTENT,
+                                 given_params: kwargs)
+    end
+
+    def get_related
+      contact_url_error
+      get_request(url: "#{call_url}/related")
+    end
+  end
+end

data/lib/context_io/account/sources.rb

@@ -0,0 +1,83 @@
+module ContextIO
+  class Sources
+  include ContextIO::CallHelpers
+  include ContextIO::CollectionHelper
+  SOURCE_READERS = %I(username status type label use_ssl resource_url server
+                      port mailserviceAccountId callbackUrl delimiter
+                      authentication_type sync_flags type browser_redirect_url)
+
+    private
+    attr_reader :parent
+
+    public
+    attr_accessor :api_call_made
+    attr_reader :status, :success, :connection, :message_id, :response, *SOURCE_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
+      @label = identifier
+      @api_call_made = api_call_made
+      if response
+        parse_response(response)
+      end
+    end
+
+    def call_url
+      build_url("sources", label)
+    end
+
+    def post(**kwargs)
+      src = call_api_return_updated_object(klass: Sources,
+                                           url: call_url,
+                                           identifier: label,
+                                           method: :post,
+                                           valid_params: ValidPostParams::SOURCE,
+                                           given_params: kwargs)
+      return_post_api_call_made(src)
+    end
+
+    def get_folders(**kwargs)
+      collection_return(url: "#{call_url}/folders",
+                        klass: Folder,
+                        valid_params: ValidGetParams::FOLDERS_SOURCES,
+                        given_params: kwargs)
+    end
+
+    def get_folder(folder:, **kwargs)
+      url = "#{call_url}/folders/#{folder}"
+      call_api_return_new_object(klass: Folder,
+                                 url: url,
+                                 valid_params: ValidGetParams::SOURCE_FOLDER,
+                                 given_params: kwargs)
+    end
+
+    def sync
+      Sync.new(parent: self).get
+    end
+
+    def get_connect_tokens
+      collection_return(url: "#{call_url}/connect_tokens",
+                        klass: ConnectToken)
+    end
+
+    def get_connect_token(token:)
+      call_api_return_new_object(klass: ConnectToken,
+                                 url: "#{call_url}/connect_tokens/#{token}")
+    end
+
+    def post_connect_token(callback_url:)
+      call_api_return_new_object(klass: ConnectToken,
+                                 url: "#{call_url}/connect_tokens",
+                                 method: :post,
+                                 valid_params: ValidPostParams::SOURCE_CONNECT_TOKEN,
+                                 given_params: { callback_url: callback_url })
+    end
+  end
+end