contextio-lite 0.0.2

data/lib/contextio/lite/api.rb

@@ -0,0 +1,30 @@
+require 'contextio/api/abstract_api'
+require_relative 'url_builder'
+
+module ContextIO
+	class Lite
+		class API < ContextIO::API::AbstractAPI
+
+			VERSION = 'lite'
+
+			def self.user_agent_string
+				"contextio-#{self.version}-ruby-#{ContextIO.version}"
+			end
+
+			# @param [Object] resource The resource you want the URL for.
+			#
+			# @return [String] The URL for the resource in the API.
+			def self.url_for(resource)
+				ContextIO::Lite::URLBuilder.url_for(resource)
+			end
+
+			# @param [Object] resource The resource you want the URL for.
+			#
+			# @return [String] The URL for the resource in the API.
+			def url_for(resource)
+				ContextIO::Lite::API.url_for(resource)
+			end
+
+		end
+	end
+end

data/lib/contextio/lite/email_account.rb

@@ -0,0 +1,48 @@
+require 'contextio/api/resource'
+require 'contextio/api/association_helpers'
+
+module ContextIO
+	class Lite
+		class EmailAccount
+			include ContextIO::API::Resource
+
+			self.primary_key = :label
+			self.association_name = :email_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 email_account.
+			#
+			# @params [Hash{String, Symbol => String}] options See the Context.IO docs
+			#   for more details on these fields.
+			def update(options={})
+				it_worked = api.request(:post, resource_url, options)['success']
+
+				if it_worked
+					options.each do |key, value|
+						key = key.to_s.gsub('-', '_')
+
+						instance_variable_set("@#{key}", value)
+					end
+				end
+
+				it_worked
+			end
+
+			def delete
+				api.request(:delete, resource_url)['success']
+			end
+
+		end
+	end
+end

data/lib/contextio/lite/email_account_collection.rb

@@ -0,0 +1,44 @@
+require 'contextio/api/resource_collection'
+require_relative 'email_account'
+
+module ContextIO
+	class Lite
+		class EmailAccountCollection
+			include ContextIO::API::ResourceCollection
+
+			self.resource_class = ContextIO::Lite::EmailAccount
+			self.association_name = :email_accounts
+
+			belongs_to :user
+
+			# Creates a new email_account for an user.
+			#
+			# @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,
+						:server => server,
+						: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
+end

data/lib/contextio/lite/folder.rb

@@ -0,0 +1,18 @@
+require 'contextio/api/resource'
+require 'contextio/api/association_helpers'
+
+module ContextIO
+  class Lite
+    class Folder
+      include ContextIO::API::Resource
+
+      self.primary_key = :name
+      self.association_name = :folder
+
+      has_many :messages
+
+      lazy_attributes :name, :delimiter, :nb_messages, :nb_unseen_messages
+
+    end
+  end
+end

data/lib/contextio/lite/folder_collection.rb

@@ -0,0 +1,17 @@
+require 'contextio/api/resource_collection'
+require_relative 'folder'
+
+module ContextIO
+  class Lite
+    class FolderCollection
+      include ContextIO::API::ResourceCollection
+
+      self.resource_class = ContextIO::Lite::Folder
+      self.association_name = :folders
+
+      belongs_to :email_account
+
+    end
+  end
+end
+

data/lib/contextio/lite/message.rb

@@ -0,0 +1,77 @@
+require 'contextio/api/resource'
+require 'contextio/api/association_helpers'
+
+module ContextIO
+  class Lite
+    class Message
+      include ContextIO::API::Resource
+
+      self.primary_key = :message_id
+      self.association_name = :message
+
+      # has_many :body_parts
+
+      lazy_attributes :sent_at, :addresses, :person_info, :email_message_id, :message_id,
+                      :attachments, :subject, :folders, :bodies, :references, :in_reply_to,
+                      :list_headers, :received_headers
+
+      FLAG_KEYS = %w(seen answered flagged draft deleted)
+
+      private :sent_at, :bodies, :addresses
+
+      def sent
+        @sent ||= Time.at(sent_at)
+      end
+
+      %w(from to bcc cc reply_to).each do |f|
+        define_method(f) do
+          addresses[f]
+        end
+      end
+
+      def body_plain
+        self.body(type:'text/plain').map{|b| b['content']}.join
+      end
+
+      def body_html
+        self.body(type:'text/html').map{|b| b['content']}.join
+      end
+
+      def body(options={})
+        @body ||= if @with_constraints.has_key?(:include_body) && @with_constraints[:include_body]==1 then
+                    options.has_key?('type') ?
+                        self.api_attributes['bodies'].select { |b| b['type']==options['type'] } :
+                        self.api_attributes['bodies']
+                  else
+                    api.request(:get, "#{resource_url}/body", options)['bodies']
+                  end
+      end
+
+      def flags
+        if @with_constraints.has_key?(:include_flags) && @with_constraints[:include_flags]==1
+          @flags = self.api_attributes['flags']
+        else
+          @flags ||= api.request(:get, "#{resource_url}/flags")['flags']
+          @flags['seen'] = @flags.delete 'read' if @flags.has_key? 'read'
+          @flags = Hash[FLAG_KEYS.map{|f| [f, @flags.include?(f) && @flags[f]]}]
+        end
+        @flags
+      end
+
+      def headers
+        @headers ||= @with_constraints.has_key?(:include_headers) && @with_constraints[:include_headers]==1 ?
+          self.api_attributes['headers'] :
+          api.request(:get, "#{resource_url}/headers")['headers']
+      end
+
+      def raw
+        api.raw_request(:get, "#{resource_url}/raw")
+      end
+
+      def read
+        api.request(:post, "#{resource_url}/read")['success']
+      end
+
+    end
+  end
+end

data/lib/contextio/lite/message_collection.rb

@@ -0,0 +1,15 @@
+require 'contextio/api/resource_collection'
+require_relative 'message'
+
+module ContextIO
+  class Lite
+    class MessageCollection
+      include ContextIO::API::ResourceCollection
+
+      self.resource_class = ContextIO::Lite::Message
+      self.association_name = :messages
+
+      belongs_to :folder
+    end
+  end
+end

data/lib/contextio/lite/url_builder.rb

@@ -0,0 +1,95 @@
+require_relative 'email_account_collection'
+require_relative 'folder_collection'
+require_relative 'message_collection'
+require_relative 'user_collection'
+require_relative 'webhook_collection'
+
+module ContextIO
+  class Lite
+    class URLBuilder
+      class Error < StandardError; end
+
+      # Tells you the right URL for a resource to fetch attributes from.
+      #
+      # @param [Contextio::Resource, Contextio::ResourceCollection] resource The
+      #   resource or resource collection.
+      #
+      # @return [String] The path for that resource in the API.
+      def self.url_for(resource)
+        if (builder = @registered_urls[resource.class])
+          builder.call(resource)
+        else
+          raise Error, "URL could not be built for unregistered Class: #{resource.class}."
+        end
+      end
+
+      # Register a block that calculates the URL for a given resource.
+      #
+      # @param [Class] resource_class The class of the resource you are
+      #   registering.
+      # @param [Block] block The code that will compute the url for the
+      #   resource. This is actually a path. Start after the version number of
+      #   the API in the URL. When a URL is being calculated for a specific
+      #   resource, the resource instance will be yielded to the block.
+      #
+      # @example For Accounts
+      #   register_url ContextIO::Account do |account|
+      #     "accounts/#{account.id}"
+      #   end
+      def self.register_url(resource_class, &block)
+        @registered_urls ||= {}
+        @registered_urls[resource_class] = block
+      end
+
+      register_url ContextIO::Lite::UserCollection do
+        'users'
+      end
+
+      register_url ContextIO::Lite::User do |user|
+        "users/#{user.id}"
+      end
+
+      register_url ContextIO::Lite::EmailAccountCollection do |email_accounts|
+        "users/#{email_accounts.user.id}/email_accounts"
+      end
+
+      register_url ContextIO::Lite::EmailAccount do |email_account|
+        "users/#{email_account.user.id}/email_accounts/#{email_account.label}"
+      end
+
+      register_url ContextIO::Lite::FolderCollection do |folders|
+        "users/#{folders.email_account.user.id}/email_accounts/#{uri_encode folders.email_account.label}/folders"
+      end
+
+      register_url ContextIO::Lite::Folder do |folder|
+        "users/#{folder.email_account.user.id}/email_accounts/#{uri_encode folder.email_account.label}/folders/#{uri_encode folder.name}"
+      end
+
+      register_url ContextIO::Lite::MessageCollection do |messages|
+        "users/#{messages.folder.email_account.user.id}/email_accounts/#{uri_encode messages.folder.email_account.label}/folders/#{uri_encode messages.folder.name}/messages"
+      end
+
+      register_url ContextIO::Lite::Message do |message|
+        "users/#{message.folder.email_account.user.id}/email_accounts/#{uri_encode message.folder.email_account.label}/folders/#{uri_encode message.folder.name}/messages/#{uri_encode message.message_id}"
+      end
+
+
+      register_url ContextIO::Lite::WebhookCollection do |webhooks|
+        "users/#{webhooks.user.id}/webhooks"
+      end
+
+      register_url ContextIO::Lite::Webhook do |webhook|
+        "users/#{webhook.user.id}/webhooks/#{webhook.webhook_id}"
+      end
+
+      def self.uri_encode(param)
+        if param.is_a? String
+          URI.encode param
+        else
+          param
+        end
+      end
+
+    end
+  end
+end

data/lib/contextio/lite/user.rb

@@ -0,0 +1,61 @@
+require 'contextio/api/resource'
+require 'contextio/api/association_helpers'
+
+module ContextIO
+  class Lite
+    class User
+      include ContextIO::API::Resource
+
+      self.primary_key = :id
+      self.association_name = :user
+
+      has_many :email_accounts
+      has_many :webhooks
+
+      # @!attribute [r] id
+      #   @return [String] The id assigned to this account by Context.IO.
+      # @!attribute [r] username
+      #   @return [String] The username assigned to this account by Context.IO.
+      # @!attribute [r] first_name
+      #   @return [String] The account holder's first name.
+      # @!attribute [r] last_name
+      #   @return [String] The account holder's last name.
+      lazy_attributes :id, :email_addresses, :username, :created, :first_name, :last_name
+      private :created
+
+      # @!attribute [r] created_at
+      #   @return [Time] The time this account was created (with Context.IO).
+      def created_at
+        @created_at ||= Time.at(created)
+      end
+
+      # Updates the account.
+      #
+      # @param [Hash{String, Symbol => String}] options You can update first_name
+      #   or last_name (or both).
+      def update(options={})
+        first_name = options[:first_name] || options['first_name']
+        last_name = options[:last_name] || options['last_name']
+
+        attrs = {}
+        attrs[:first_name] = first_name if first_name
+        attrs[:last_name] = last_name if last_name
+
+        return nil if attrs.empty?
+
+        it_worked = api.request(:post, resource_url, attrs)['success']
+
+        if it_worked
+          @first_name = first_name || @first_name
+          @last_name = last_name || @last_name
+        end
+
+        it_worked
+      end
+
+      def delete
+        api.request(:delete, resource_url)['success']
+      end
+    end
+  end
+end

data/lib/contextio/lite/user_collection.rb

@@ -0,0 +1,40 @@
+require 'contextio/api/resource_collection'
+require_relative 'user'
+
+module ContextIO
+  class Lite
+    class UserCollection
+      include ContextIO::API::ResourceCollection
+
+      self.resource_class = ContextIO::Lite::User
+      self.association_name = :accounts
+
+      # Creates a new email account for your Context.IO account.
+      #
+      # @param [Hash{String, Symbol => String}] options Information you can
+      #   provide at creation: email, first_name and/or last_name. If the
+      #   collection isn't already limited by email, then you must provide it.
+      #
+      # @return [Account] A new email account instance based on the data you
+      #   input.
+      def create(options={})
+        email = options.delete(:email) || options.delete('email') ||
+          where_constraints[:email] || where_constraints['email']
+
+        if email.nil?
+          raise ArgumentError, 'You must provide an email for new Users.'
+        end
+
+        result_hash = api.request(
+          :post,
+          resource_url,
+          options.merge(email: email)
+        )
+
+        result_hash.delete('success')
+
+        resource_class.new(api, result_hash)
+      end
+    end
+  end
+end