mailhandler 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad4de21ce6ad278dd2916e5cb898691c10961b87
+  data.tar.gz: caedb45d153cbfa44d41b13328a9afb20c81b2fa
+SHA512:
+  metadata.gz: a0da923ce9b696ca05ce4cc1b322678bd272b44227ca25a330239375fac65c3bdddbe3fbc08b6b425a27b89c24907b4a48fd259a5a99cec88f5e4ac6f165f8c4
+  data.tar.gz: 7667ee7a964c55262104b954abd8289f7855b4107056041587702d76dbecab016425b139d49a3989ddcc53d7a905d781c029f39ca339cb122278d75542c46eae

data/.gitignore

@@ -0,0 +1,5 @@
+**/*.log
+**/*.rvm
+**/*.DS_Store
+**/*.idea
+

data/lib/mailhandler.rb

@@ -0,0 +1,91 @@
+require_relative 'mailhandler/sender'
+require_relative 'mailhandler/receiver'
+
+require_relative 'mailhandler/receiving/notification/email'
+require_relative 'mailhandler/receiving/notification/console'
+
+module MailHandler
+
+  class Handler
+
+    attr_accessor :sender,
+                  :receiver
+
+    def self.sender(type = :postmark_api)
+
+      verify_type(type, SENDER_TYPES)
+      sender = MailHandler::Sender.new(SENDER_TYPES[type].new)
+      yield(sender.dispatcher) if block_given?
+
+      sender
+
+    end
+
+
+    def self.receiver(type = :folder, notifications = [])
+
+      verify_type(type, CHECKER_TYPES)
+      receiver = MailHandler::Receiver.new(CHECKER_TYPES[type].new)
+      add_receiving_notifications(receiver, notifications)
+
+      yield(receiver.checker) if block_given?
+
+      receiver
+
+    end
+
+    def self.handler(sender, receiver)
+
+      handler = new
+      handler.sender = sender
+      handler.receiver = receiver
+      handler
+
+    end
+
+    private
+
+    def self.add_receiving_notifications(receiver, notifications)
+
+      if (notifications - NOTIFICATION_TYPES.keys).empty?
+
+        notifications.each { |n| receiver.add_observer(NOTIFICATION_TYPES[n].new) }
+
+      end
+
+    end
+
+    def self.verify_type(type, types)
+
+      raise StandardError, "Unknown type - #{type}, possible options: #{types.keys}" unless types.keys.include? type
+
+    end
+
+    CHECKER_TYPES = {
+
+        :folder => Receiving::FolderChecker,
+        :imap => Receiving::IMAPChecker
+
+    }
+
+    SENDER_TYPES = {
+
+        :postmark_api => Sending::PostmarkAPISender,
+        :postmark_batch_api => Sending::PostmarkBatchAPISender,
+        :smtp => Sending::SMTPSender
+
+    }
+
+    NOTIFICATION_TYPES = {
+
+        :console => Receiving::Notification::Console,
+        :email => Receiving::Notification::Email
+
+    }
+
+  end
+
+end
+
+
+

data/lib/mailhandler/receiver.rb

@@ -0,0 +1,86 @@
+require_relative 'receiving/checker_folder'
+require_relative 'receiving/checker_imap'
+require_relative 'receiving/observer'
+
+module MailHandler
+
+  class Receiver
+
+    include Receiving::Observer
+
+    attr_accessor :checker,
+                  :search,
+                  :search_max_duration
+
+    module DEFAULTS
+
+      MAX_SEARCH_DURATION = 240 # maximum time for search to last in [seconds]
+
+    end
+
+    # @param [Hash] - search options
+    # @param [Time] - search started at Time
+    # @param [Time] - search finished at Time
+    # @param [int] - how long search lasted
+    # @param [int] - how long search can last
+    # @param [boolean] - result of search
+    # @param [Mail] - first email found
+    # @param [Array] - all emails found
+    Search = Struct.new( :options, :started_at, :finished_at, :duration, :max_duration, :result, :email, :emails)
+
+    def initialize(checker)
+
+      @checker = checker
+      @search_max_duration = DEFAULTS::MAX_SEARCH_DURATION
+
+    end
+
+    def find_email(options)
+
+      init_search_details(options)
+
+      while 1
+
+        received = checker.find(options) || search_time_expired?
+        update_search_details
+        notify_observers(search)
+
+        break if received
+        sleep 1
+
+      end
+
+      checker.search_result
+
+    end
+
+    private
+
+    def init_search_details(options)
+
+      @search = Search.new
+      @search.options = options
+      @search.started_at = Time.now
+      @search.max_duration = @search_max_duration
+
+    end
+
+    def update_search_details
+
+      search.finished_at = Time.now
+      search.duration = search.finished_at - search.started_at
+      search.result = checker.search_result
+      search.emails = checker.found_emails
+      search.email = search.emails.first
+
+    end
+
+    def search_time_expired?
+
+      (Time.now - search.started_at) > @search_max_duration
+
+    end
+
+  end
+
+end

data/lib/mailhandler/receiving/checker.rb

@@ -0,0 +1,60 @@
+module MailHandler
+
+  module Receiving
+
+    #
+    # Email receiving checker interface. All email checking types need to implement it.
+    # @see MailHandler::Receiving::FolderChecker for example for one of implemented checkers.
+    #
+    # Checker interface is used for doing a single check whether email is in your inbox.
+    #
+    class Checker
+
+      attr_accessor :search_options,
+                    :found_emails
+
+      AVAILABLE_SEARCH_OPTIONS = [
+
+          :by_subject,
+          :by_content,
+          :by_date,
+          :by_recipient,
+          :count,
+          :archive
+
+      ]
+
+      def initialize
+
+        # Default number of email results to return, and whether to archive emails.
+        @search_options = {:count => 10, :archive => false}
+
+      end
+
+      def find(options)
+
+        raise StandardError, 'Method not implemented'
+
+      end
+
+      def verify_and_set_search_options(options)
+
+        unless (options.keys - AVAILABLE_SEARCH_OPTIONS).empty?
+          raise StandardError, "#{(options.keys - AVAILABLE_SEARCH_OPTIONS)} - Incorrect search option values, options are #{AVAILABLE_SEARCH_OPTIONS}"
+        end
+
+        @search_options = search_options.merge options
+
+      end
+
+      def search_result
+
+        found_emails != nil and !found_emails.empty?
+
+      end
+
+    end
+
+  end
+
+end

data/lib/mailhandler/receiving/checker_folder.rb

@@ -0,0 +1,126 @@
+require_relative 'checker.rb'
+require_relative 'filter'
+require 'fileutils'
+require 'mail'
+
+module MailHandler
+
+  module Receiving
+
+    class FolderChecker < Checker
+
+      # folders in which emails will be searched for and managed
+      attr_accessor :inbox_folder,
+                    :archive_folder
+
+      def initialize(inbox_folder = nil, archive_folder = nil)
+
+        super()
+
+        @inbox_folder = inbox_folder
+        @archive_folder = archive_folder
+
+      end
+
+      # check whether email is received by checking for an email in folder
+      def find(options)
+
+        verify_and_set_search_options(options)
+        email_files = find_files(search_options)
+
+        if email_files.empty?
+
+          @found_emails = []
+
+        else
+
+          @found_emails = read_found_emails(email_files, search_options[:count])
+          move_files(email_files) if search_options[:archive]
+
+        end
+
+        !@found_emails.empty?
+
+      end
+
+      private
+
+      # filter options which need to be done by searching files
+      FILE_SEARCH_OPTIONS = {
+
+          :by_subject => Filter::ByContent,
+          :by_content => Filter::ByContent,
+          :by_date => Filter::ByDate,
+          :by_recipient => Filter::Email::ByRecipient
+      }
+
+      def search_pattern
+
+        @inbox_folder + '/*.*'
+
+      end
+
+      def read_found_emails(files, count)
+
+        files.first(count).map do |file|
+
+          email_content = File.read(file)
+          Mail.read_from_string(email_content)
+
+        end
+
+      end
+
+      # find files by FILE_SEARCH_OPTIONS options
+      # this will ignore filter criteria options which can't be done on files directly
+      def find_files(options)
+
+        files = Filter::Base.new.get(search_pattern)
+
+        options.each do |key, value|
+
+          files = (files & FILE_SEARCH_OPTIONS[key].new(value).get(search_pattern)) if FILE_SEARCH_OPTIONS[key] != nil
+
+        end
+
+        Filter::Base.sort(files)
+
+      end
+
+      def move_files(files)
+
+        setup_inbox_folders
+
+        files.each do |file|
+
+          file = File.basename(file)
+
+          if inbox_folder != archive_folder
+
+            FileUtils.mv("#{inbox_folder}/#{file}", "#{archive_folder}/#{file}")
+
+          else
+
+            FileUtils.rm_r "#{inbox_folder}/#{file}", :force => true
+
+          end
+
+        end
+
+      end
+
+      # create folders if they don't exist
+      def setup_inbox_folders
+
+        raise StandardError, 'Folder variables are not set' if inbox_folder.nil? or archive_folder.nil?
+
+        Dir::mkdir inbox_folder unless File.directory? inbox_folder
+        Dir::mkdir archive_folder unless File.directory? archive_folder
+
+      end
+
+    end
+
+  end
+
+end

data/lib/mailhandler/receiving/checker_imap.rb

@@ -0,0 +1,90 @@
+require 'mail'
+require_relative 'checker.rb'
+# encoding: utf-8
+
+module MailHandler
+
+  module Receiving
+
+    class IMAPChecker < Checker
+
+      AVAILABLE_SEARCH_OPTIONS = [
+
+          :by_subject,
+          :count,
+          :archive
+
+      ]
+
+      def initialize
+
+        super
+
+      end
+
+      # set email account from which we will read email
+      def imap_details(address, port, username, password, use_ssl)
+
+        Mail.defaults do
+          retriever_method :imap,
+                           :address    => address,
+                           :port       => port,
+                           :user_name  => username,
+                           :password   => password,
+                           :enable_ssl => use_ssl
+        end
+
+      end
+
+      def find(options)
+
+        verify_and_set_search_options(options)
+        validate_options(options)
+        emails = find_emails(search_options)
+
+        @found_emails = []
+
+        unless emails.empty?
+
+          emails.each do |email|
+
+            found = email.subject.include? search_options[:by_subject]
+            @found_emails << email if found
+
+          end
+
+        end
+
+        !@found_emails.empty?
+
+      end
+
+      private
+
+      def find_emails(options)
+
+        if options[:archive]
+
+          Mail.find_and_delete(:what => :last, :count => search_options[:count], :order => :desc, :keys => ['SUBJECT', search_options[:by_subject]])
+
+        else
+
+          Mail.find(:what => :last, :count => search_options[:count], :order => :desc, :keys => ['SUBJECT', search_options[:by_subject]])
+
+        end
+
+      end
+
+      def validate_options(options)
+
+        unless (options.keys - AVAILABLE_SEARCH_OPTIONS).empty?
+          raise StandardError, "#{(options.keys - AVAILABLE_SEARCH_OPTIONS)} - Not supported search option values for imap, options are #{AVAILABLE_SEARCH_OPTIONS}"
+        end
+
+      end
+
+    end
+
+  end
+
+end