contextio 0.5.0 → 1.0.0

data/lib/contextio/contact.rb

@@ -0,0 +1,43 @@
+require 'contextio/api/resource'
+
+class ContextIO
+  class Contact
+    include ContextIO::API::Resource
+
+    self.primary_key = :email
+    self.association_name = :contact
+
+    belongs_to :account
+
+    lazy_attributes :emails, :name, :thumbnail, :last_received, :last_sent,
+                    :count
+    private :last_received, :last_sent
+
+    def email
+      @email ||= emails.first
+    end
+
+    def last_received_at
+      last_received ? Time.at(last_received) : nil
+    end
+
+    def last_sent_at
+      last_sent ? Time.at(last_sent) : nil
+    end
+
+    # Poor man's has_many
+    def threads
+      account.threads.where(email: email)
+    end
+
+    # Poor man's has_many
+    def messages
+      account.messages.where(email: email)
+    end
+
+    # Poor man's has_many
+    def files
+      account.files.where(email: email)
+    end
+  end
+end

data/lib/contextio/contact_collection.rb

@@ -0,0 +1,21 @@
+require_relative 'api/resource_collection'
+require_relative 'contact'
+
+class ContextIO
+  class ContactCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::Contact
+    self.association_name = :contacts
+
+    belongs_to :account
+
+    private
+
+    # The request that comes back is not formatted the same as other
+    # collections, so we need to override it and pick out the right key.
+    def attribute_hashes
+      @attribute_hashes ||= api.request(:get, resource_url, where_constraints)['matches']
+    end
+  end
+end

data/lib/contextio/email_address.rb

@@ -0,0 +1,53 @@
+require 'contextio/api/association_helpers'
+
+class ContextIO
+  class EmailAddress
+    def self.association_name
+      :email_address
+    end
+    ContextIO::API::AssociationHelpers.register_resource(self, :email_address)
+
+    # (see ContextIO#api)
+    attr_reader :api, :account, :email, :validated, :primary
+    private :validated, :primary
+    #
+    # @private
+    #
+    # For internal use only. Users of this gem shouldn't be calling this
+    # directly.
+    #
+    # @param [API] api A handle on the Context.IO API.
+    # @param [Hash{String, Symbol => String, Numeric, Boolean}] options A Hash
+    #   of attributes describing the resource.
+    def initialize(api, options = {})
+      @api = api
+      @account = options.delete(:account) || options.delete('account')
+
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+
+        unless self.respond_to?(key)
+          define_singleton_method(key) do
+            instance_variable_get("@#{key}")
+          end
+        end
+      end
+    end
+
+    def validated?
+      !!validated
+    end
+
+    def primary?
+      !!primary
+    end
+
+    def set_primary
+      api.request(:post, resource_url, primary: 1)['success']
+    end
+
+    def delete
+      api.request(:delete, resource_url)['success']
+    end
+  end
+end

data/lib/contextio/email_address_collection.rb

@@ -0,0 +1,21 @@
+require_relative 'api/resource_collection'
+require_relative 'email_address'
+
+class ContextIO
+  class EmailAddressCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::EmailAddress
+    self.association_name = :email_addresses
+
+    belongs_to :account
+
+    def create(address)
+      result_hash = api.request(:post, resource_url, email_address: address)
+
+      result_hash.delete('success')
+
+      resource_class.new(api, result_hash)
+    end
+  end
+end

data/lib/contextio/email_settings.rb

@@ -0,0 +1,146 @@
+class ContextIO
+  # Represents the IMAP settings for a given email address. The API
+  # documentation refers to this as 'discovery'. This process is hit-and-miss.
+  # If noting is found, many attributes are likely to be nil and blank. Check
+  # {EmailSettings#found? EmailSettings#found?}.
+  class EmailSettings
+    # (see ContextIO#api)
+    attr_reader :api
+
+    # @!attribute [r] type
+    # @return [String] The type og the provider (like 'gmail'). Will fetch from
+    #   the API if necessary.
+    def type
+      return @type if instance_variable_defined?(:@type)
+
+      fetch_attributes
+
+      @type
+    end
+
+    # @!attribute [r] documentation
+    # @return [Array<String>] A list of documentation pages that pertain to the
+    #   provider. Will fetch from the API if necessary.
+    def documentation
+      return @documentation if instance_variable_defined?(:@documentation)
+
+      fetch_attributes
+
+      @documentation
+    end
+
+    # @!attribute [r] email
+    # @return [String] The email address associated with these IMAP settings.
+    attr_reader :email, :source_type
+
+    # Not sure why, but the below comment has to be below the attr_reader call
+    # above.
+
+    # @!attribute [r] source_type
+    # @return [String] The only source type currently supported by the API is
+    #   'IMAP'.
+
+    # (see ContextIO::OAuthProviderCollection#initialize)
+    # @param [String] email The email address to fetch the settings for.
+    # @param [String] source_type The only source type currently supported by
+    #   the API is 'IMAP'.
+    def initialize(api, email, source_type = 'IMAP')
+      @api = api
+      @email = email
+      @source_type = source_type
+    end
+
+    # @!attribute [r] resource_url
+    # @return [String] The path for discovering email settings.
+    def resource_url
+      'discovery'
+    end
+
+    # @!attribute [r] found?
+    # @return [Boolean] Whether the settings were able to be fetched. Will fetch
+    #   from the API if necessary.
+    def found?
+      found
+    end
+
+    # @!attribute [r] server
+    # @return [String] FQDN of the IMAP server. Will fetch from the API if
+    #   necessary.
+    def server
+      imap['server']
+    end
+
+    # @!attribute [r] username
+    # @return [String] The username for authentication purposes. Will fetch
+    #   from the API if necessary.
+    def username
+      imap['username']
+    end
+
+    # @!attribute [r] port
+    # @return [Integer] The network port the IMAP server is listening on. Will
+    #   fetch from the API if necessary.
+    def port
+      imap['port']
+    end
+
+    # @!attribute [r] oauth?
+    # @return [Boolean] Whether the IMAP server supports OAuth or not. Will
+    #   fetch from the API if necessary.
+    def oauth?
+      !!imap['oauth']
+    end
+
+    # @!attribute [r] use_ssl?
+    # @return [Boolean] Whether the IMAP server uses SSL for connections. Will
+    #   fetch from the API if necessary.
+    def use_ssl?
+      !!imap['use_ssl']
+    end
+
+    private
+
+    # @!attribute [r] imap
+    # @return [Hash{String => String, Boolean, Integer}] Attributes of the IMAP
+    #   server in question.
+    def imap
+      return @imap if instance_variable_defined?(:@imap)
+
+      fetch_attributes
+
+      @imap
+    end
+
+    # @!attribute [r] found
+    # @return [Boolean] Whether the settings were able to be fetched. Will fetch
+    #   from the API if necessary.
+    def found
+      return @found if instance_variable_defined?(:@found)
+
+      fetch_attributes
+
+      @found
+    end
+
+    # Fetches attributes from the API for the email settings.
+    #
+    # Defines getter methods for any attributes that come back and don't
+    # already have them. This way, if the API expands, the gem will still let
+    # users get attributes we didn't explicitly declare as lazy.
+    def fetch_attributes
+      attr_hashes = api.request(:get, resource_url, 'email' => email, 'source_type' => source_type)
+
+      attr_hashes.each do |key, value|
+        instance_variable_set("@#{key}", value)
+
+        unless respond_to?(key)
+          instance_eval <<-RUBY
+            def #{key}
+              @#{key}
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/contextio/file.rb

@@ -0,0 +1,92 @@
+require 'contextio/api/resource'
+require 'contextio/source_sync_data'
+
+class ContextIO
+  class File
+    include ContextIO::API::Resource
+
+    self.primary_key = :file_id
+    self.association_name = :file
+
+    belongs_to :account
+
+    lazy_attributes :size, :type, :subject, :date, :addresses, :personInfo,
+                    :email_message_id, :message_id, :date_indexed,
+                    :date_received, :file_name, :file_name_structure,
+                    :body_section, :content_disposition, :file_id,
+                    :is_tnef_part, :gmail_message_id, :gmail_thread_id,
+                    :supports_preview, :is_embedded
+    private :date, :addresses, :message_id, :date_indexed, :date_received,
+            :is_tnef_part, :is_embedded, :personInfo
+
+    def received_at
+      @received_at ||= Time.at(date_received)
+    end
+
+    def indexed_at
+      @indexed_at ||= Time.at(indexed_at)
+    end
+
+    def to
+      addresses['to']
+    end
+
+    def from
+      addresses['from']
+    end
+
+    def person_info
+      personInfo
+    end
+
+    def tnef_part?
+      !!is_tnef_part
+    end
+
+    def embedded?
+      !!is_embedded
+    end
+
+    def content
+      @content ||= api.request(:get, "#{resource_url}/content")
+    end
+
+    def content_link
+      @content_link ||= api.raw_request(:get, "#{resource_url}/content", as_link: 1)
+    end
+
+    def related_files
+      return @related_files if @related_files
+
+      attribute_hashes = api.request(:get, "#{resource_url}/related")
+
+      @related_files = FileCollection.new(api, attribute_hashes: attribute_hashes, account: account)
+
+      return @related_files
+    end
+
+    def revisions
+      return @revisions if @revisions
+
+      attribute_hashes = api.request(:get, "#{resource_url}/revisions")
+
+      @revisions = FileCollection.new(api, attribute_hashes: attribute_hashes, account: account)
+
+      return @revisions
+    end
+
+    def sync_data
+      return @sync_data if @sync_data
+
+      sync_hashes = api.request(:get, "#{resource_url}/sync")
+
+      @sync_data = ContextIO::SourceSyncData.new(sync_hashes)
+
+      return @sync_data
+    end
+
+    def sync!
+      api.request(:post, "#{resource_url}/sync")['success']
+    end
+  end
+end

data/lib/contextio/file_collection.rb

@@ -0,0 +1,13 @@
+require_relative 'api/resource_collection'
+require_relative 'file'
+
+class ContextIO
+  class FileCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::File
+    self.association_name = :files
+
+    belongs_to :account
+  end
+end

data/lib/contextio/folder.rb

@@ -0,0 +1,56 @@
+require 'contextio/api/association_helpers'
+
+class ContextIO
+  class Folder
+    def self.association_name
+      :folder
+    end
+    ContextIO::API::AssociationHelpers.register_resource(self, :folder)
+
+    # (see ContextIO#api)
+    attr_reader :api, :source, :name, :attributes, :delim, :nb_messages,
+                :uidvalidity, :nb_unseen_messages
+    private :attributes
+
+    # @private
+    #
+    # For internal use only. Users of this gem shouldn't be calling this
+    # directly.
+    #
+    # @param [API] api A handle on the Context.IO API.
+    # @param [Hash{String, Symbol => String, Numeric, Boolean}] options A Hash
+    #   of attributes describing the resource.
+    def initialize(api, options = {})
+      @api = api
+      @source = options.delete(:source) || options.delete('source')
+
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+
+        unless self.respond_to?(key)
+          define_singleton_method(key) do
+            instance_variable_get("@#{key}")
+          end
+        end
+      end
+    end
+
+    def has_children?
+      attributes['HasChildren']
+    end
+
+    def marked?
+      attributes['Marked']
+    end
+
+    def imap_attributes
+      attributes
+    end
+
+    def messages
+      association_class = ContextIO::API::AssociationHelpers.class_for_association_name(:messages)
+
+      @messages ||= association_class.new(api, folder: self)
+    end
+  end
+end