blythedunham-sms_on_rails 0.1.0

data/generators/sms_on_rails/templates/configuration/clickatell.rb

@@ -0,0 +1,6 @@
+SmsOnRails::ServiceProviders::Clickatell.config =
+{
+   :api_id => 'api-key',
+   :user_name => 'username',
+   :password => 'password'
+}

data/generators/sms_on_rails/templates/configuration/email_gateway.rb

@@ -0,0 +1,7 @@
+SmsOnRails::ServiceProviders::EmailGateway.config =
+{
+   :sender => 'youremail address',
+   :subject => 'Default Subject Text'
+   #:bcc => nil,
+   #:mailer_klass => nil
+}

data/generators/sms_on_rails/templates/migrate/schema_migration.rb

@@ -0,0 +1,15 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+<%= SmsOnRails::SchemaHelper.create(*files) %>
+
+<% if migration_name.downcase.include?('carrier') -%>
+  require "#{RAILS_ROOT}/vendor/plugins/smsonrails/db/seed_data.rb"
+<% else %>
+  <%= migration_name %>
+<% end -%>
+  end
+
+  def self.down
+<%= SmsOnRails::SchemaHelper.drop(*files) %>
+  end
+end

data/generators/sms_on_rails/templates/migrate/sms_on_rails_update_phone_numbers.rb

@@ -0,0 +1,40 @@
+class SmsOnRailsUpdatePhoneNumbers < ActiveRecord::Migration
+  def self.up
+
+<%
+      existing_columns = ActiveRecord::Base.connection.columns(:phone_numbers).collect { |each| each.name }
+      columns = [
+        [:number,      't.string  :number,       :length => 20, :null => false'],
+        [:carrier_id,  't.integer :carrier_id,   :default => nil'],
+        [:owner_id,    't.integer :owner_id,     :default => nil'],
+        [:white_list,  't.boolean :white_list,   :null => false, :default => false'],
+        [:do_not_send, 't.string  :do_not_send,  :length => 30, :default => nil'],
+        [:country_code,'t.string  :country_code, :length => 2, :default => 1'],
+      ].delete_if {|c| existing_columns.include?(c.first.to_s)}
+-%>
+    change_table(:phone_numbers) do |t|
+<% columns.each do |c| -%>
+      <%= c.last %>
+<% end -%>
+    end
+
+<%
+    existing_indexes = ActiveRecord::Base.connection.indexes(:phone_numbers)
+    index_names = existing_indexes.collect { |each| each.name }
+    new_indexes = [
+      [:uk_phone_numbers_number, 'add_index :phone_numbers, :unique => true']
+    ].delete_if { |each| index_names.include?(each.first.to_s) }
+-%>
+<% new_indexes.each do |each| -%>
+    <%= each.last %>
+<% end -%>
+  end
+
+  def self.down
+    change_table(:phone_numbers) do |t|
+<% unless columns.empty? -%>
+      t.remove <%= columns.collect { |each| ":#{each.first}" }.join(',') %>
+<% end -%>
+    end
+  end
+end

data/generators/sms_on_rails/templates/phone_number_collision.rb

@@ -0,0 +1,2 @@
+require "#{RAILS_ROOT}/app/models/phone_number"
+SmsOnRails::PhoneNumber = ::PhoneNumber

data/init.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/lib/sms_on_rails'
+
+

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/sms_on_rails.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+
+Dir.glob(File.dirname(__FILE__) + '/sms_on_rails/activerecord_extensions/*.rb'){|f| require f}
+
+files = Dir.glob(File.dirname(__FILE__) + '/sms_on_rails/util/*.rb')
+files.concat Dir.glob(File.dirname(__FILE__) + '/sms_on_rails/service_providers/*.rb')
+files.concat(Dir.glob(File.dirname(__FILE__) + '/sms_on_rails/model_support/*.rb'))
+files.each {|f| require f }

data/lib/sms_on_rails/activerecord_extensions/acts_as_deliverable.rb

@@ -0,0 +1,92 @@
+module SmsOnRails
+  module ActsAsDeliverable
+
+    def self.extended(base)#:nodoc:
+      base.send :class_inheritable_hash, :acts_as_deliverable_options
+      base.acts_as_deliverable_options = {
+        :retry_count => 3,
+        :max_messages => 30,
+        :fatal_exception => nil,
+        :locrec_options => {},
+        :error => "Unable to deliver.",
+        :already_processed_error => 'Already delivered'
+      }
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_deliverable(options={})
+        class_eval do
+          acts_as_deliverable_options.update(options) if options
+          include SmsOnRails::ActsAsDeliverable::InstanceMethods
+          extend  SmsOnRails::ActsAsDeliverable::SingletonMethods
+          lockable_record acts_as_deliverable_options[:locrec_options]
+        end
+      end
+    end
+
+    module SingletonMethods
+      # Deliver a list of deliverables
+      # === Parameters
+      # * +deliverables+ - a deliverable or an array of deliverables
+      # * +options+ - delivery options. Refer to individual delivery options
+      #
+      # All messages(including failed status) are delivered unless a fatal exception occurs
+      # Specify <tt> :fatal_exception => nil </tt> to override this behavior
+      def deliver(deliverables, options={})
+        [deliverables].flatten.each do |deliverable|
+          deliverable.deliver(options)
+        end
+      end
+    end
+
+    module InstanceMethods
+
+      # Return true if delivery was successful
+      # If unsuccessful, only raise fatal exceptions, and return false otherwise
+      # === Options
+      # +fatal_exception+ - specify the fatal exception Class to throw. To dismiss all exceptions, set to nil.
+      # Defaults to acts_as_deliverable_options specified
+      # +error+ - add an error to the objects base if delivery failed
+      def deliver(options={})
+        deliver!(options)
+      rescue Exception => exc
+        log_delivery_error(exc)
+        fatal_exception = acts_as_deliverable_options.merge(options)[:fatal_exception]
+        raise exc if fatal_exception && exc.is_a?(fatal_exception)
+        self.errors.add_to_base(delivery_error_message(exc, options))
+        false
+      end
+
+      # Deliver and mark the status fields approriately
+      def deliver!(options={})
+        lock_record_and_execute { deliver_message(options) }
+      end
+
+      def delivered?; already_processed?; end
+
+      # Deliver message should be overridden by the class to perform any
+      # functionality
+      def deliver_message(options={})
+        raise(acts_as_deliverable_options[:fatal_exception]||Exception).new "Overwrite deliver_message in base class to perform the actual delivery"
+      end
+
+      protected
+      def delivery_error_message(exc, options)
+        err_msg = if exc.is_a?(SmsOnRails::LockableRecord::AlreadyProcessed)
+          options[:already_processed_error]|| acts_as_deliverable_options[:already_processed_error]
+        end || (options[:error]||acts_as_deliverable_options[:error])
+        err_msg
+      end
+
+      # Override this function to outbound errors
+      # differently to a log or with a different message
+      def log_delivery_error(exc)
+        logger.error "Delivery Error: #{exc}"
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend SmsOnRails::ActsAsDeliverable unless defined?(ActiveRecord::Base.acts_as_deliverable_options)
+

data/lib/sms_on_rails/activerecord_extensions/acts_as_substitutable.rb

@@ -0,0 +1,80 @@
+module SmsOnRails
+  module ActsAsSubstitutable
+
+    def self.extended(base)
+      base.send :class_inheritable_accessor, :acts_as_sub_options
+      base.acts_as_sub_options = {}
+
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_substitutable(method, options={})
+        
+        defaults =  {:time => Proc.new {|rec| Time.now.to_s(:db) }}
+
+        class_eval do
+          acts_as_sub_options[method.to_sym] = defaults.merge(options||{})
+          def clear_substituted_params
+            acts_as_sub_options.keys.each{|method| instance_variable_set("@#{method}", nil)}
+          end
+        end
+
+        acts_as_substitutable_instance_methods(method)
+      end
+
+      protected
+
+      def acts_as_substitutable_instance_methods(method)
+        class_eval(<<-EOS, __FILE__, __LINE__)
+          before_save :clear_substituted_params
+
+          def substituted_#{method}
+            return '' if self.#{method}.blank?
+            unless @sub_#{method}
+              @sub_#{method} = self.#{method}.dup
+
+              if (subs = @sub_#{method}.scan(substitution_#{method}_regex)).any?
+                 subs.flatten.compact.each do |sub|
+                   method = #{method}_sub_options[sub.downcase.to_sym]
+                   val = if method.is_a?(Proc)
+                     method.call(self)
+                   elsif method
+                     self.send method
+                   end
+                   @sub_#{method}.gsub!(sub_key_to_val(sub), val)
+                 end
+              end
+            end
+            @sub_#{method}
+         end
+
+         protected
+         def substitution_#{method}_regex
+           @@substitution_#{method}_regex ||= 
+              Regexp.new #{method}_sub_options.keys.collect{|key| 
+                sub_key_to_val(key, ['\\$(', ')\\$'])
+              }.join('|')
+         end
+
+
+         def sub_key_to_val(key, surround = ['$', '$'])
+
+           val = surround.first
+           val << key.to_s.upcase
+           val << surround.last
+           val
+         end
+
+         def #{method}_sub_options
+           self.class.acts_as_sub_options[:#{method}]
+         end
+       EOS
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend SmsOnRails::ActsAsSubstitutable unless defined?(ActiveRecord::Base.acts_as_sub_options)
+
+

data/lib/sms_on_rails/activerecord_extensions/has_a_sms_service_provider.rb

@@ -0,0 +1,101 @@
+module SmsOnRails
+  module ServiceProviders
+    module HasASmsServiceProvider
+
+      def self.extended(base)
+        base.send :class_inheritable_hash, :sms_service_provider_options
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # Add an accessor to the service provider
+        # 
+        # 
+        # For example, if the provider was referenced by name by calling method 'sms_vendor'
+        #   has_an_sms_service_provider :method => 'sms_vendor', :type => :name, :accessor_method => 'sms_service_provider'
+        # would define an instance method sms_service_provider and  sms_service_provider_id that returns the appropriate
+        # instance and id respectively.
+        #
+        # Likewise if :type => :id or there is a column on the :id field, sms_service_provider_id would
+        # be defined
+        #
+        #
+        # ===Options
+        # <tt>:type</tt> the key field (either :id or :name). the one that actually stores the data
+        # The provider is referenced by provider_id by default
+        # <tt>:method</tt> the name of the method that should be invoked to get the wanted id or name
+        # <tt>:accessor_name</tt> the name of the new method accessor
+        def has_a_sms_service_provider(options={})
+          self.sms_service_provider_options = options||{}
+
+          sms_service_provider_options[:accessor_name]||= 'sms_service_provider'
+
+          accessors =
+            { sms_service_provider_options[:accessor_name] + '_id' => :provider_id,
+              sms_service_provider_options[:accessor_name] + '_name'=> :name}
+
+
+          key_field = nil
+          if sms_service_provider_options[:type]
+            key_field = sms_service_provider_options[:accessor_name]
+            key_field << '_'
+            key_field << sms_service_provider_options[:type]
+          end
+
+          set_instance_code = accessors.inject('') do |code, field|
+
+
+            # column fields use write_attribute to update the data
+            # non column field look up the service providers real name
+            if respond_to?(:column_names) && self.column_names.include?(field.first)
+              key_field ||= field.first
+              code << "write_attribute(#{field.first.inspect}, (@provider.#{field.last} if @provider))"
+            else
+              class_eval <<-EOS, __FILE__, __LINE__
+                def #{field.first}
+                  if (p=#{sms_service_provider_options[:accessor_name]})
+                    p.send #{field.last.inspect}
+                  end
+                end
+              EOS
+            end
+
+            #define the setter function to call the service_provider instance setter
+            class_eval <<-EOS, __FILE__, __LINE__
+              def #{field.first}=(value)
+                self.#{sms_service_provider_options[:accessor_name]}=value
+                self.#{field.first}
+              end
+            EOS
+            code
+          end
+
+          #define the setter and getter codes for service provider
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{sms_service_provider_options[:accessor_name]}
+              unless @provider
+                value = self.send(#{key_field.inspect})
+                self.#{sms_service_provider_options[:accessor_name]}=value
+              end
+              @provider
+            end
+
+            def #{sms_service_provider_options[:accessor_name]}=(value)
+              @provider = SmsOnRails::ServiceProviders::Base.get_service_provider(value)
+              #{set_instance_code}
+              @provider
+            end
+
+            def default_service_provider; SmsOnRails::ServiceProviders::Base.default_service_provider; end
+            def self.sms_service_provider_map; SmsOnRails::ServiceProviders::Base.provider_map; end
+            def self.sms_service_provider_list; SmsOnRails::ServiceProviders::Base.provider_list; end
+          EOS
+        end
+      end
+    end
+  end
+end
+
+unless ActiveRecord::Base.respond_to?(:has_a_sms_service_provider)
+  ActiveRecord::Base.extend SmsOnRails::ServiceProviders::HasASmsServiceProvider
+end

data/lib/sms_on_rails/activerecord_extensions/lockable_record.rb

@@ -0,0 +1,186 @@
+module SmsOnRails
+  module LockableRecord
+
+    class UnableToLockRecord < Exception; end
+    class AlreadyProcessed   < UnableToLockRecord; end
+
+    
+    def self.extended(base)
+      base.class_inheritable_hash :locrec_options
+
+      base.locrec_options = {
+        :log_lock_warnings => true,
+        :columns => {
+          :status        => 'status',
+          :processed_on  => 'processed_on',
+          :notes         => 'notes',
+          :retry_count   => 'retry_count',
+          :sub_status    => 'sub_status'
+        },
+
+        :status => {
+          :not_processed => 'NOT_PROCESSED',
+          :processed     => 'PROCESSED',
+          :processing    => 'PROCESSING',
+          :failed        => 'FAILED',
+          :cancelled     => 'CANCELLED'
+        }
+      }
+
+      base.send :include, InstanceMethods
+      base.send :extend,  ClassMethods
+    end
+
+
+    module InstanceMethods
+      def locrec_columns
+        self.class.locrec_columns
+      end
+      def locrec_status
+        self.class.locrec_status
+      end
+
+      def already_processed?
+        get_locrec_col(:status) != locrec_status[:not_processed]
+      end
+      # Lock the record by setting the status from NOT_PROCESSED TO PROCESSED
+      # StalerecordErrors are caught and logged
+      def lock_record
+        if already_processed?
+          raise SmsOnRails::LockableRecord::AlreadyProcessed.new(
+            "Record #{self.to_param} appears to be processed. #{locrec_columns[:status]}" +
+            " is #{get_locrec_col(:status)} instead of #{locrec_status[:not_processed]}"
+          )
+        end
+
+        begin
+          set_locrec_col :processed_on, Time.now
+          set_locrec_col :status,       locrec_status[:processing]
+          set_locrec_col :retry_count,  get_locrec_col(:retry_count).to_i + 1
+          save!
+          return true
+        #this just means another proc got to it first, skip
+        rescue ActiveRecord::StaleObjectError => exc
+          if locrec_options[:log_lock_warnings]
+            log_locrec_error :level => :warn,
+                              :msg => "#{self.class} lock failed",
+                              :exception => exc
+          end
+          raise SmsOnRails::LockableRecord::UnableToLockRecord.new(
+              "Unable to set #{locrec_columns[:status]}. Record is stale")
+
+        end
+        false
+      end
+
+      def lock_record_and_execute(&block)
+
+        begin
+          # Lock the process, execute the block, set the status to PROCESSED
+          # If the process could not be locked (stale record exception), continue without error
+          # If the process raised any other exception, set the status to FAILED
+          if lock_record
+            yield
+
+            if get_locrec_col(:status) == locrec_status[:processing]
+              set_locrec_col :status, locrec_status[:processed]
+              set_locrec_col :processed_on, Time.now if locrec_columns[:processed_on]
+              save!
+            end
+          end
+          return true
+        # Do not mess with the record status if it is already being processed
+        #rescue ActiveRecord::StaleObjectError => soe
+        #  reset_status(locrec_status[:failed], soe)
+        
+        #rescue self.class.locrec_options[:fatal_exception] => ie
+        #  reset_status(locrec_status[:failed], ie)
+        #  raise ie
+        #
+
+        # Set status to failed and reraise exception if the exception is fatal
+        # or we wish to throw all errors
+        rescue Exception => exc
+          reset_locrec_status(locrec_status[:failed], exc) unless exc.is_a?(SmsOnRails::LockableRecord::UnableToLockRecord)
+          raise exc
+        end
+      end
+
+      def reset_locrec_status(current_status, exc)
+        begin
+          #log_entry = LogEntry.error("Send #{self.to_s.demodulize} unexpected error: #{self.id}",nil,exc)
+          #fresh copy in case it was updated
+          reload
+          if get_locrec_col(:status) == locrec_status[:processing]
+
+            set_locrec_col :status, current_status
+
+            if locrec_columns[:notes]
+              set_locrec_col :notes, "#{current_status}: #{exc.to_s}"
+            end
+
+            if locrec_columns[:sub_status] && exc.respond_to?(:sub_status)
+              set_locrec_col :sub_status, exc.sub_status.to_s
+            end
+            
+            save!
+          end
+        rescue Exception => e2
+          log_locrec_error(:level => :fatal, :msg => "fatal fatal error in #{self.class}", :exception => e2)
+        end
+      end
+
+      def log_locrec_error(options={})
+        message = options[:msg]||"ERROR LOCKING INSTANCE #{self}"
+        message << "\n#{options[:exception].to_s}" if options[:exception]
+        logger.send options[:level]||:error, message
+      end
+
+      def set_locrec_col(col, value)
+        send "#{locrec_columns[col]}=", value
+      end
+
+      def get_locrec_col(col)
+        send locrec_columns[col]
+      end
+    end
+
+    module ClassMethods
+
+      def lockable_record(options={})
+        self.locrec_options = ActiveRecord::Base.locrec_options.merge(options)
+        [:columns, :status].each do |method|
+          if options[method]
+            self.locrec_options[method] = ActiveRecord::Base.locrec_options[method].merge(options[method])
+          end
+        end
+      end
+
+      def locrec_columns; locrec_options[:columns]; end
+      def locrec_status; locrec_options[:status]; end
+
+      def recover_stale_records
+        update_all(["#{locrec_columns[:status]} = ?", locrec_status[:not_processed]],
+                   stale_record_conditions)
+      end
+
+
+      def delete_stale_records
+        delete_all stale_record_conditions
+      end
+
+      def stale_record_conditions
+        query = []
+        query << "#{locrec_columns[:status]} = :status"
+        query << "#{locrec_columns[:processed_on]} < now() - interval :min minute"
+        map = {:status => locrec_status[:processing],
+               :min => locrec_options[:recover_stalled_minutes]}
+        [query.join(' AND '), map]
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend SmsOnRails::LockableRecord unless defined?(ActiveRecord::Base.locrec_options)
+
+