contextio 0.5.0 → 1.0.0

data/lib/contextio/folder_collection.rb

@@ -0,0 +1,18 @@
+require_relative 'api/resource_collection'
+require_relative 'folder'
+
+class ContextIO
+  class FolderCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::Folder
+    self.association_name = :folders
+
+    belongs_to :source
+
+    def create(folder_name, folder_delimiter='/')
+      api.request(:put, "#{resource_url}/#{folder_name}", delim: folder_delimiter)['success']
+    end
+  end
+end
+

data/lib/contextio/folder_sync_data.rb

@@ -0,0 +1,32 @@
+class ContextIO
+  class FolderSyncData
+    attr_reader :name
+
+    def initialize(name, attr_hash)
+      @name = name
+      @attr_hash = attr_hash
+    end
+
+    def initial_import_finished?
+      attr_hash['initial_import_finished']
+    end
+
+    def last_expunged_at
+      Time.at(attr_hash['last_expunge'])
+    end
+
+    def last_sync_started_at
+      Time.at(attr_hash['last_sync_start'])
+    end
+
+    def last_sync_stopped_at
+      Time.at(attr_hash['last_sync_stop'])
+    end
+
+    private
+
+    def attr_hash
+      @attr_hash
+    end
+  end
+end

data/lib/contextio/message.rb

@@ -0,0 +1,96 @@
+require 'contextio/api/resource'
+
+class ContextIO
+  class Message
+    include ContextIO::API::Resource
+
+    self.primary_key = :message_id
+    self.association_name = :message
+
+    belongs_to :account
+    has_many :sources
+    has_many :body_parts
+
+    lazy_attributes :date, :folders, :addresses, :subject, :list_help,
+                    :list_unsubscribe, :message_id, :email_message_id,
+                    :gmail_message_id, :gmail_thread_id, :person_info,
+                    :date_received, :date_indexed
+    private :date_received, :date_indexed
+
+    def received_at
+      @received_at ||= Time.at(date_received)
+    end
+
+    def indexed_at
+      @indexed_at ||= Time.at(date_indexed)
+    end
+
+    def flags
+      api.request(:get, "#{resource_url}/flags")
+    end
+
+    # As of this writing, the documented valid flags are: seen, answered,
+    # flagged, deleted, and draft. However, this will send whatever you send it.
+    def set_flags(flag_hash)
+      args = flag_hash.map({}) do |memo, (flag_name, value)|
+        memo[flag_name] = value ? 1 : 0
+        memo
+      end
+
+      api.request(:post, resource_url, args)['success']
+    end
+
+    def folders
+      api.request(:get, "#{resource_url}/folders").collect { |f| f['name'] }
+    end
+
+    def headers
+      api.request(:get, "#{resource_url}/headers")
+    end
+
+    def raw
+      api.raw_request(:get, "#{resource_url}/source")
+    end
+
+    # You can call this with a Folder object, in which case, the source from the
+    # folder will be used, or you can pass in a folder name and source label.
+    def copy_to(folder, source = nil)
+      if folder.is_a?(ContextIO::Folder)
+        folder_name = folder.name
+        source_label = folder.source.label
+      else
+        folder_name = folder.to_s
+        source_label = source.to_s
+      end
+
+      api.request(:post, resource_url, dst_folder: folder_name, dst_source: source_label)['success']
+    end
+
+    # You can call this with a Folder object, in which case, the source from the
+    # folder will be used, or you can pass in a folder name and source label.
+    def move_to(folder, source = nil)
+      if folder.is_a?(ContextIO::Folder)
+        folder_name = folder.name
+        source_label = folder.source.label
+      else
+        folder_name = folder.to_s
+        source_label = source.to_s
+      end
+
+      api.request(:post, resource_url, dst_folder: folder_name, dst_source: source_label, move: 1)['success']
+    end
+
+    def delete
+      api.request(:delete, resource_url)['success']
+    end
+
+    private
+
+    # The API doesn't return enough information to build a resource_url for this
+    # resource, or the resource_url its self, making this problematic. Marking
+    # this private until something is sorted on that front.
+    def thread
+      ContextIO::Thread.new(api, api.request(:get, "#{resource_url}/thread").merge(account: account))
+    end
+  end
+end

data/lib/contextio/message_collection.rb

@@ -0,0 +1,35 @@
+require_relative 'api/resource_collection'
+require_relative 'message'
+
+class ContextIO
+  class MessageCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::Message
+    self.association_name = :messages
+
+    belongs_to :account
+
+    # You can pass a Folder object and this'll use the source from it, or you
+    # can pass a folder label and a source label (from the API), if that's
+    # easier for you.
+    #
+    # This is private because AFAICT, the oauth gem doesn't do POST requests
+    # with Content-Type = 'multipart/form-data' easily. I think it might behoove
+    # us to replace that dependency in the future, anyway, and we can fix this
+    # at that point. In any case, this functionality was missing from previous
+    # releases of the contextio gem, too.
+    def create(raw_message, folder, source = nil)
+      if folder.is_a?(ContextIO::Folder)
+        folder_label = folder.name
+        source_label = source || folder.source.label
+      else
+        folder_label = folder.to_s
+        source_label = source.to_s
+      end
+
+      api.request(:post, resource_url, message: raw_message, dst_folder: folder_label, dst_source: source_label)['success']
+    end
+    private :create
+  end
+end

data/lib/contextio/oauth_provider.rb

@@ -0,0 +1,29 @@
+require 'contextio/api/resource'
+
+class ContextIO
+  # Represents a single OAuth provider for an account. You can use this to
+  # inspect or delete the provider. Most of the attributes are lazily loaded,
+  # meaning that the API won't get hit until you ask for an attribute the object
+  # doesn't already have (presumably from a previous API call).
+  class OAuthProvider
+    include API::Resource
+
+    # @!attribute [r] provider_consumer_key
+    #   @return [String] The consumer key associated with this provider. Will
+    #     fetch from the API if necessary.
+    # @!attribute [r] provider_consumer_secret
+    #   @return [String] The consumer secret associated with this provider. Will
+    #     fetch from the API if necessary.
+    # @!attribute [r] type
+    #   @return [String] The consumer key associated with this provider. Will
+    #     fetch from the API if necessary.
+    lazy_attributes :provider_consumer_key, :provider_consumer_secret, :type
+
+    self.primary_key = :provider_consumer_key
+    self.association_name = :oauth_provider
+
+    def delete
+      api.request(:delete, resource_url)['success']
+    end
+  end
+end

data/lib/contextio/oauth_provider_collection.rb

@@ -0,0 +1,46 @@
+require_relative 'oauth_provider'
+require_relative 'api/resource_collection'
+
+class ContextIO
+  # Represents a collection of OAuth providers for an account. You can use this
+  # to create a proider, fetch a specific one or iterate over them.
+  #
+  # @example You can iterate over them with `each`:
+  #   contextio.oauth_providers.each do |oauth_provider|
+  #     puts oauth_provider.type
+  #   end
+  #
+  # @example You can lazily access a specific one with square brackets:
+  #   provider = contextio.oauth_providers['some_provider_consumer_key']
+  class OAuthProviderCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::OAuthProvider
+    self.association_name = :oauth_providers
+
+    # Creates a new OAuth provider for your account.
+    #
+    # @param [String] type The type of provider. As of this writing, the API
+    #   only accepts 'GMAIL' and 'GOOGLEAPPSMARKETPLACE'.
+    # @param [String] provider_consumer_key The Provider Consumer Key you got
+    #   when you OAuthed the user.
+    # @param [String] provider_consumer_secret The Provider Consumer Secret you
+    #   got when you OAuthed the user.
+    #
+    # @return [OAuthProvider] A new provider instance based on the data you
+    #   input.
+    def create(type, provider_consumer_key, provider_consumer_secret)
+      result_hash = api.request(
+        :post,
+        resource_url,
+        type: type,
+        provider_consumer_key: provider_consumer_key,
+        provider_consumer_secret: provider_consumer_secret
+      )
+
+      result_hash.delete('success')
+
+      resource_class.new(api, result_hash)
+    end
+  end
+end

data/lib/contextio/source.rb

@@ -0,0 +1,55 @@
+require 'contextio/api/resource'
+
+class ContextIO
+  class Source
+    include ContextIO::API::Resource
+
+    self.primary_key = :label
+    self.association_name = :source
+
+    belongs_to :account
+    has_many :folders
+
+    lazy_attributes :server, :label, :username, :port, :authentication_type,
+                    :status, :service_level, :sync_period, :use_ssl, :type
+    private :use_ssl
+
+    # @!attribute [r] use_ssl?
+    #   @return [Boolean] Whether or not this source uses SSL.
+    def use_ssl?
+      use_ssl
+    end
+
+    # Updates the source.
+    #
+    # @params [Hash{String, Symbol => String}] options You can update the
+    #   following: status, sync_period, service_level, password, provider_token,
+    #   provider_token_secret, provider_consumer_key. See the Context.IO docs
+    #   for more details on these fields.
+    def update(options={})
+      updatable_attrs = %w(status sync_period service_level password
+                           provider_token provider_token_secret
+                           provider_consumer_key)
+
+      options.keep_if do |key, value|
+        updatable_attrs.include?(key.to_s)
+      end
+
+      return nil if options.empty?
+
+      it_worked = api.request(:post, resource_url, options)['success']
+
+      if it_worked
+        options.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      it_worked
+    end
+
+    def delete
+      api.request(:delete, resource_url)['success']
+    end
+  end
+end

data/lib/contextio/source_collection.rb

@@ -0,0 +1,41 @@
+require_relative 'api/resource_collection'
+require_relative 'source'
+
+class ContextIO
+  class SourceCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::Source
+    self.association_name = :sources
+
+    belongs_to :account
+
+    # Creates a new source for an account.
+    #
+    # @param [String] email The email address for the new source.
+    # @param [String] server The address of the server for the source.
+    # @param [String] username The name for logging into the server. Often the
+    #   same as the email.
+    # @param [Boolean] use_ssl Whether to use SSL for the new source.
+    # @param [Numeric, String] port The port to connect on.
+    # @param [String] type Currently, only 'IMAP' is supported.
+    # @param [Hash{String, Symbol => String}] options Information you can
+    #   provide at creation. Check out the Context.IO documentation for what's
+    #   required and what's optional.
+    def create(email, server, username, use_ssl, port, type, options={})
+      api_args = options.merge(
+        'email' => email,
+        'username' => username,
+        'use_ssl' => use_ssl ? '1' : '0',
+        'port' => port.to_s,
+        'type' => type
+      )
+
+      result_hash = api.request(:post, resource_url, api_args)
+
+      result_hash.delete('success')
+
+      resource_class.new(api, result_hash)
+    end
+  end
+end

data/lib/contextio/source_sync_data.rb

@@ -0,0 +1,23 @@
+require_relative 'folder_sync_data'
+
+class ContextIO
+  class SourceSyncData
+    attr_reader :folder_names, :folders, :source_label
+
+    def initialize(source_label, folder_hash)
+      @folder_hash = folder_hash
+      @source_label = source_label
+      @folder_names = folder_hash.keys
+
+      @folders = folder_hash.collect do |folder_name, attr_hash|
+        ContextIO::FolderSyncData.new(folder_name, attr_hash)
+      end
+    end
+
+    private
+
+    def folder_hash
+      @folder_hash
+    end
+  end
+end

data/lib/contextio/thread.rb

@@ -0,0 +1,15 @@
+require 'contextio/api/resource'
+
+class ContextIO
+  class Thread
+    include ContextIO::API::Resource
+
+    self.primary_key = :gmail_thread_id
+    self.association_name = :thread
+
+    belongs_to :account
+    has_many :messages
+
+    lazy_attributes :gmail_thread_id, :email_message_ids, :person_info
+  end
+end

data/lib/contextio/thread_collection.rb

@@ -0,0 +1,25 @@
+require_relative 'api/resource_collection'
+require_relative 'thread'
+
+class ContextIO
+  class ThreadCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::Thread
+    self.association_name = :threads
+
+    belongs_to :account
+
+    # Iterates over the resources in question.
+    #
+    # @example
+    #   contextio.connect_tokens.each do |connect_token|
+    #     puts connect_token.email
+    #   end
+    def each(&block)
+      attribute_hashes.each do |actually_a_resource_url|
+        yield resource_class.new(api, {resource_url: actually_a_resource_url}.merge(associations_hash))
+      end
+    end
+  end
+end

data/lib/contextio/version.rb

@@ -0,0 +1,11 @@
+class ContextIO
+  # @private
+  VERSION = "1.0.0"
+
+  # The gem version.
+  #
+  # @return [String] The gem version.
+  def self.version
+    VERSION
+  end
+end

data/lib/contextio/webhook.rb

@@ -0,0 +1,39 @@
+require 'contextio/api/resource'
+
+class ContextIO
+  class Webhook
+    include ContextIO::API::Resource
+
+    self.primary_key = :webhook_id
+    self.association_name = :webhook
+
+    belongs_to :account
+
+    lazy_attributes :callback_url, :failure_notif_url, :active, :sync_period,
+                    :failure, :webhook_id, :filter_to, :filter_from, :filter_cc,
+                    :filter_subject, :filter_thread, :filter_new_important,
+                    :filter_file_name, :filter_file_revisions,
+                    :filter_folder_added, :filter_folder_removed
+    private :active, :failure
+
+    def active?
+      !!active
+    end
+
+    def failure?
+      !!failure
+    end
+
+    def activate
+      api.request(:post, resource_url, active: 1)['success']
+    end
+
+    def deactivate
+      api.request(:post, resource_url, active: 0)['success']
+    end
+
+    def delete
+      api.request(:delete, resource_url)['success']
+    end
+  end
+end