mailhandler 1.0.1

data/lib/mailhandler/receiving/filter.rb

@@ -0,0 +1,161 @@
+module Filter
+
+  class Base
+
+    def Base.sort(files)
+
+      swapped = true
+      j = 0
+
+      while swapped do
+
+        swapped = false
+        j+=1
+
+        (files.size - j).times do |i|
+
+          if File.new(files[i]).ctime < File.new(files[i + 1]).ctime
+            tmp = files[i]
+            files[i] = files[i + 1]
+            files[i + 1] = tmp
+            swapped = true
+
+          end
+
+        end
+
+      end
+
+      files
+
+    end
+
+    def get(pattern)
+
+      files = []
+      Dir.glob(pattern).each { |file| files << File.absolute_path(file) }
+      files
+
+    end
+
+  end
+
+  class ByFilename < Base
+
+    def get(pattern)
+
+      super(pattern)
+
+    end
+
+  end
+
+  class ByContent < Base
+
+    def initialize(content)
+
+      @content = content
+
+    end
+
+    def get(pattern)
+
+      files = super(pattern)
+
+      matched_files = []
+
+      files.each do |file|
+
+        begin
+
+          content = File.read(file)
+          matched_files << file if content.include? @content
+
+        rescue
+
+          # skip file reading if file is not there anymore
+
+        end
+
+      end
+
+      matched_files
+
+    end
+
+  end
+
+  class ByDate < Base
+
+    def initialize(date)
+
+      @date = date
+
+    end
+
+    def get(pattern)
+
+      files = super(pattern)
+      files.select { |filename|
+
+        file = nil
+        begin
+
+          file = File.new(filename)
+
+        rescue
+
+          # skip file reading if file is not there anymore
+
+        end
+
+        file.ctime > @date if (file != nil)
+
+      }
+
+    end
+
+  end
+
+  module Email
+
+    class ByRecipient < Base
+
+      def initialize(recipient)
+
+        @recipient = recipient
+
+      end
+
+      def get(pattern)
+
+        files = super(pattern)
+
+        matched_files = []
+
+        files.each do |file|
+
+          begin
+
+            content = File.read(file)
+
+            email = Mail.read_from_string(content)
+            matched_files << file if email[@recipient.keys.first].to_s.include? @recipient.values.first
+
+          rescue
+
+            # skip file reading if file is not there anymore
+
+          end
+
+        end
+
+        matched_files
+
+      end
+
+    end
+
+  end
+
+end

data/lib/mailhandler/receiving/notification/console.rb

@@ -0,0 +1,44 @@
+module MailHandler
+
+  module Receiving
+
+    module Notification
+
+      class Console
+
+        def notify(search)
+
+          output_delay Time.now - search.started_at
+
+        end
+
+        private
+
+        module Seconds
+
+          TO_SHOW = 10
+
+        end
+
+        # print to screen delay length
+        def output_delay(delay)
+
+          delay_seconds = delay.to_i
+          output(delay_seconds) if [0,1].include? (delay_seconds % Seconds::TO_SHOW)
+
+        end
+
+        # print to screen delay length
+        def output(delay)
+
+          puts "  email delay: #{'%03d' % delay} seconds"
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/mailhandler/receiving/notification/email.rb

@@ -0,0 +1,74 @@
+require_relative 'email/content'
+require_relative 'email/states'
+
+module MailHandler
+
+  module Receiving
+
+    module Notification
+
+      class Email
+
+        attr_reader   :sender,
+                      :contacts,
+                      :min_time_to_notify,
+                      :max_time_to_notify
+
+        def initialize(sender, contacts, min_time_to_notify = 60)
+
+          @min_time_to_notify = min_time_to_notify
+
+          @sender = sender
+          @contacts = contacts
+          init_state
+
+        end
+
+        def notify(search)
+
+          @max_time_to_notify = search.max_duration
+          init_state if Time.now - search.started_at < min_time_to_notify
+          @current_state.notify(search)
+
+        end
+
+        def set_state(state)
+
+          @current_state = state
+
+        end
+
+        def send_email(type, search)
+
+          verify_email_type(type)
+          content = EmailContent.send("email_#{type}",search.options, Time.now - search.started_at, sender.dispatcher.username, contacts)
+          sender.send_email content
+
+        end
+
+        private
+
+        def init_state
+
+          @current_state = Notification::NoDelay.new(self)
+
+        end
+
+        EMAIL_TYPES = [:delayed, :received]
+
+        def verify_email_type(type)
+
+          raise StandardError, "Incorrect type: #{type}, allowed types: #{EMAIL_TYPES}" unless EMAIL_TYPES.include? type
+
+        end
+
+      end
+
+    end
+
+  end
+
+end
+
+
+

data/lib/mailhandler/receiving/notification/email/content.rb

@@ -0,0 +1,43 @@
+require 'mail'
+
+module MailHandler
+
+  module Receiving
+
+    module Notification
+
+      class EmailContent
+
+        def self.email_received(options, delay, from, to)
+
+          Mail.new do
+
+            from from
+            subject "Received - delay was #{(delay.to_f/60).round(2)} minutes"
+            body "Received - delay was #{(delay.to_f/60).round(2)} minutes - search by #{options}"
+            to to
+
+          end
+
+        end
+
+        def self.email_delayed(options, delay, from, to)
+
+          Mail.new do
+
+            from from
+            subject "Over #{(delay.to_f/60).round(2)} minutes delay"
+            body "Over #{(delay.to_f/60).round(2)} minutes delay - search by #{options}"
+            to  to
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/mailhandler/receiving/notification/email/states.rb

@@ -0,0 +1,113 @@
+require_relative '../email'
+
+module MailHandler
+
+  module Receiving
+
+    module Notification
+
+      class DelayState
+
+        attr_accessor :context,
+                      :notified
+
+        def initialize(context)
+
+          @context = context
+
+        end
+
+        def notification_fired
+
+          @notified = true
+
+        end
+
+        def notify(search)
+
+          raise StandardError, 'notify(search) interface has to be implemented'
+
+        end
+
+        protected
+
+        def send_notification_email(type, search)
+
+          unless notified
+
+            context.send_email(type, search)
+            notification_fired
+
+          end
+
+        end
+
+      end
+
+      class NoDelay < DelayState
+
+        def notify(search)
+
+          if Time.now - search.started_at >= context.min_time_to_notify
+
+            context.set_state(Delay.new(context))
+            context.notify(search)
+
+          end
+
+        end
+
+      end
+
+      class Delay < DelayState
+
+        def notify(search)
+
+          if search.result
+
+            context.set_state(Received.new(context))
+            context.notify(search)
+
+          elsif Time.now - search.started_at >= context.max_time_to_notify
+
+            context.set_state(MaxDelay.new(context))
+            context.notify(search)
+
+          else
+
+            send_notification_email(:delayed, search)
+
+          end
+
+        end
+
+      end
+
+      class MaxDelay < DelayState
+
+        def notify(search)
+
+          send_notification_email(:delayed, search)
+
+        end
+
+      end
+
+      class Received < DelayState
+
+        def notify(search)
+
+          send_notification_email(:received, search)
+
+        end
+
+      end
+
+    end
+
+  end
+
+end
+
+
+

data/lib/mailhandler/receiving/observer.rb

@@ -0,0 +1,37 @@
+module MailHandler
+
+  module Receiving
+
+    module Observer
+
+      def init_observer
+
+        @observers = Array.new
+
+      end
+
+      def add_observer(observer)
+
+        @observers ||= Array.new
+        @observers << observer
+
+      end
+
+      def delete_observer(observer)
+
+        @observers.delete(observer) if @observers
+
+      end
+
+      def notify_observers(search)
+
+        @observers.each { |observer| observer.notify(search) } if @observers
+
+      end
+
+    end
+
+  end
+
+end
+