noticed 1.0.0 → 1.2.20

data/lib/generators/noticed/notification_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Noticed
+  module Generators
+    class NotificationGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::ResourceHelpers
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Generates a notification with the given NAME."
+
+      def generate_notification
+        template "notification.rb", "app/notifications/#{file_path}.rb"
+      end
+    end
+  end
+end

data/lib/generators/noticed/templates/README

@@ -0,0 +1,7 @@
+
+🚚 Your notifications database model has been generated!
+
+Next steps:
+1. Run "rails db:migrate"
+2. Add "has_many :notifications, as: :recipient" to your User model(s).
+3. Generate notifications with "rails g noticed:notification"

data/lib/generators/noticed/templates/delivery_method.rb.tt

@@ -0,0 +1,12 @@
+class DeliveryMethods::<%= class_name %> < Noticed::DeliveryMethods::Base
+  def deliver
+    # Logic for sending the notification
+  end
+
+  # You may override this method to validate options for the delivery method
+  # Invalid options should raise a ValidationError
+  #
+  # def self.validate!(options)
+  #   raise ValidationError, "required_option missing" unless options[:required_option]
+  # end
+end

data/lib/generators/noticed/templates/notification.rb.tt

@@ -0,0 +1,27 @@
+# To deliver this notification:
+#
+# <%= class_name %>.with(post: @post).deliver_later(current_user)
+# <%= class_name %>.with(post: @post).deliver(current_user)
+
+class <%= class_name %> < Noticed::Base
+  # Add your delivery methods
+  #
+  # deliver_by :database
+  # deliver_by :email, mailer: "UserMailer"
+  # deliver_by :slack
+  # deliver_by :custom, class: "MyDeliveryMethod"
+
+  # Add required params
+  #
+  # param :post
+
+  # Define helper methods to make rendering easier.
+  #
+  # def message
+  #   t(".message")
+  # end
+  #
+  # def url
+  #   post_path(params[:post])
+  # end
+end

data/lib/noticed/base.rb

@@ -1,16 +1,21 @@
 module Noticed
   class Base
+    include Translation
+    include Rails.application.routes.url_helpers
+
+    extend ActiveModel::Callbacks
+    define_model_callbacks :deliver
+
     class_attribute :delivery_methods, instance_writer: false, default: []
     class_attribute :param_names, instance_writer: false, default: []
 
-    attr_accessor :record
+    # Gives notifications access to the record and recipient when formatting for delivery
+    attr_accessor :record, :recipient
 
     class << self
       def deliver_by(name, options = {})
-        delivery_methods.push(
-          name: name,
-          options: options
-        )
+        delivery_methods.push(name: name, options: options)
+        define_model_callbacks(name)
       end
 
       # Copy delivery methods from parent
@@ -24,23 +29,34 @@ module Noticed
         new(params)
       end
 
-      def param(name)
-        param_names.push(name)
+      def params(*names)
+        param_names.concat Array.wrap(names)
       end
+      alias_method :param, :params
     end
 
     def initialize(params = {})
       @params = params
     end
 
-    def deliver(recipient)
+    def deliver(recipients)
       validate!
-      run_delivery(recipient, enqueue: false)
+
+      run_callbacks :deliver do
+        Array.wrap(recipients).uniq.each do |recipient|
+          run_delivery(recipient, enqueue: false)
+        end
+      end
     end
 
-    def deliver_later(recipient)
+    def deliver_later(recipients)
       validate!
-      run_delivery(recipient, enqueue: true)
+
+      run_callbacks :deliver do
+        Array.wrap(recipients).uniq.each do |recipient|
+          run_delivery(recipient, enqueue: true)
+        end
+      end
     end
 
     def params
@@ -53,6 +69,9 @@ module Noticed
     def run_delivery(recipient, enqueue: true)
       delivery_methods = self.class.delivery_methods.dup
 
+      # Set recipient to instance var so it is available to Notification class
+      @recipient = recipient
+
       # Run database delivery inline first if it exists so other methods have access to the record
       if (index = delivery_methods.find_index { |m| m[:name] == :database })
         delivery_method = delivery_methods.delete_at(index)
@@ -66,9 +85,6 @@ module Noticed
 
     # Actually runs an individual delivery
     def run_delivery_method(delivery_method, recipient:, enqueue:)
-      return if (delivery_method_name = delivery_method.dig(:options, :if)) && !send(delivery_method_name)
-      return if (delivery_method_name = delivery_method.dig(:options, :unless)) && send(delivery_method_name)
-
       args = {
         notification_class: self.class.name,
         options: delivery_method[:options],
@@ -77,28 +93,47 @@ module Noticed
         record: record
       }
 
-      klass = get_class(delivery_method[:name], delivery_method[:options])
-      enqueue ? klass.perform_later(args) : klass.perform_now(args)
+      run_callbacks delivery_method[:name] do
+        method = delivery_method_for(delivery_method[:name], delivery_method[:options])
+
+        # Always perfrom later if a delay is present
+        if (delay = delivery_method.dig(:options, :delay))
+          method.set(wait: delay).perform_later(args)
+        elsif enqueue
+          method.perform_later(args)
+        else
+          method.perform_now(args)
+        end
+      end
     end
 
-    # Retrieves the correct class for a delivery method
-    def get_class(name, options)
-      if name.is_a? Class
-        name
-      elsif options[:class]
+    def delivery_method_for(name, options)
+      if options[:class]
         options[:class].constantize
       else
-        "Noticed::DeliveryMethods::#{name.to_s.classify}".constantize
+        "Noticed::DeliveryMethods::#{name.to_s.camelize}".constantize
       end
     end
 
-    # Validates that all params are present
     def validate!
+      validate_params_present!
+      validate_options_of_delivery_methods!
+    end
+
+    # Validates that all params are present
+    def validate_params_present!
       self.class.param_names.each do |param_name|
         if params[param_name].nil?
           raise ValidationError, "#{param_name} is missing."
         end
       end
     end
+
+    def validate_options_of_delivery_methods!
+      delivery_methods.each do |delivery_method|
+        method = delivery_method_for(delivery_method[:name], delivery_method[:options])
+        method.validate!(delivery_method[:options])
+      end
+    end
   end
 end

data/lib/noticed/coder.rb

@@ -1,10 +1,12 @@
 module Noticed
   class Coder
     def self.load(data)
+      return if data.nil?
       ActiveJob::Arguments.send(:deserialize_argument, data)
     end
 
     def self.dump(data)
+      return if data.nil?
       ActiveJob::Arguments.send(:serialize_argument, data)
     end
   end

data/lib/noticed/delivery_methods/action_cable.rb

@@ -16,10 +16,18 @@ module Noticed
       end
 
       def channel
-        if (method = options[:channel])
-          notification.send(method)
-        else
-          Noticed::NotificationChannel
+        @channel ||= begin
+          value = options[:channel]
+          case value
+          when String
+            value.constantize
+          when Symbol
+            notification.send(value)
+          when Class
+            value
+          else
+            Noticed::NotificationChannel
+          end
         end
       end
     end

data/lib/noticed/delivery_methods/base.rb

@@ -1,23 +1,86 @@
 module Noticed
   module DeliveryMethods
     class Base < Noticed.parent_class.constantize
-      attr_reader :notification, :options, :recipient
-      delegate :params, to: :notification
+      extend ActiveModel::Callbacks
+      define_model_callbacks :deliver
 
-      def perform(notification_class:, options:, params:, recipient:, record:)
-        @notification = notification_class.constantize.new(params)
-        @options = options
-        @recipient = recipient
+      class_attribute :option_names, instance_writer: false, default: []
 
-        # Keep track of the database record for rendering
-        @notification.record = record
+      attr_reader :notification, :options, :params, :recipient, :record
 
-        deliver
+      class << self
+        # Copy option names from parent
+        def inherited(base) #:nodoc:
+          base.option_names = option_names.dup
+          super
+        end
+
+        def options(*names)
+          option_names.concat Array.wrap(names)
+        end
+        alias_method :option, :options
+
+        def validate!(delivery_method_options)
+          option_names.each do |option_name|
+            unless delivery_method_options.key? option_name
+              raise ValidationError, "option `#{option_name}` must be set for #{name}"
+            end
+          end
+        end
+      end
+
+      def perform(args)
+        @notification = args[:notification_class].constantize.new(args[:params])
+        @options = args[:options]
+        @params = args[:params]
+        @recipient = args[:recipient]
+        @record = args[:record]
+
+        # Make notification aware of database record and recipient during delivery
+        @notification.record = args[:record]
+        @notification.recipient = args[:recipient]
+
+        return if (condition = @options[:if]) && !@notification.send(condition)
+        return if (condition = @options[:unless]) && @notification.send(condition)
+
+        run_callbacks :deliver do
+          deliver
+        end
       end
 
       def deliver
         raise NotImplementedError, "Delivery methods must implement a deliver method"
       end
+
+      private
+
+      # Helper method for making POST requests from delivery methods
+      #
+      # Usage:
+      #   post("http://example.com", basic_auth: {user:, pass:}, json: {}, form: {})
+      #
+      def post(url, args = {})
+        basic_auth = args.delete(:basic_auth)
+
+        request = if basic_auth
+          HTTP.basic_auth(user: basic_auth[:user], pass: basic_auth[:pass])
+        else
+          HTTP
+        end
+
+        response = request.post(url, args)
+
+        if options[:debug]
+          Rails.logger.debug("POST #{url}")
+          Rails.logger.debug("Response: #{response.code}: #{response}")
+        end
+
+        if !options[:ignore_failure] && !response.status.success?
+          raise ResponseUnsuccessful.new(response)
+        end
+
+        response
+      end
     end
   end
 end

data/lib/noticed/delivery_methods/database.rb

@@ -3,18 +3,29 @@ module Noticed
     class Database < Base
       # Must return the database record
       def deliver
-        recipient.notifications.create(attributes)
+        recipient.send(association_name).create!(attributes)
+      end
+
+      def self.validate!(options)
+        super
+
+        # Must be executed right away so the other deliveries can access the db record
+        raise ArgumentError, "database delivery cannot be delayed" if options.key?(:delay)
       end
 
       private
 
+      def association_name
+        options[:association] || :notifications
+      end
+
       def attributes
         if (method = options[:format])
           notification.send(method)
         else
           {
             type: notification.class.name,
-            params: params
+            params: notification.params
           }
         end
       end

data/lib/noticed/delivery_methods/email.rb

@@ -1,8 +1,10 @@
 module Noticed
   module DeliveryMethods
     class Email < Base
+      option :mailer
+
       def deliver
-        mailer.with(notification.params).send(method.to_sym).deliver_later
+        mailer.with(format).send(method.to_sym).deliver_now
       end
 
       private
@@ -14,6 +16,17 @@ module Noticed
       def method
         options[:method] || notification.class.name.underscore
       end
+
+      def format
+        if (method = options[:format])
+          notification.send(method)
+        else
+          notification.params.merge(
+            recipient: recipient,
+            record: record
+          )
+        end
+      end
     end
   end
 end

data/lib/noticed/delivery_methods/microsoft_teams.rb

@@ -0,0 +1,32 @@
+module Noticed
+  module DeliveryMethods
+    class MicrosoftTeams < Base
+      def deliver
+        post(url, json: format)
+      end
+
+      private
+
+      def format
+        if (method = options[:format])
+          notification.send(method)
+        else
+          {
+            title: notification.params[:title],
+            text: notification.params[:text],
+            sections: notification.params[:sections],
+            potentialAction: notification.params[:notification_action]
+          }
+        end
+      end
+
+      def url
+        if (method = options[:url])
+          notification.send(method)
+        else
+          Rails.application.credentials.microsoft_teams[:notification_url]
+        end
+      end
+    end
+  end
+end

data/lib/noticed/delivery_methods/slack.rb

@@ -2,7 +2,7 @@ module Noticed
   module DeliveryMethods
     class Slack < Base
       def deliver
-        HTTP.post(url, json: format)
+        post(url, json: format)
       end
 
       private
@@ -11,7 +11,7 @@ module Noticed
         if (method = options[:format])
           notification.send(method)
         else
-          params
+          notification.params
         end
       end
 

data/lib/noticed/delivery_methods/test.rb

@@ -2,9 +2,15 @@ module Noticed
   module DeliveryMethods
     class Test < Base
       class_attribute :delivered, default: []
+      class_attribute :callbacks, default: []
+
+      after_deliver do
+        self.class.callbacks << :after
+      end
 
       def self.clear!
         delivered.clear
+        callbacks.clear
       end
 
       def deliver

data/lib/noticed/delivery_methods/twilio.rb

@@ -2,7 +2,7 @@ module Noticed
   module DeliveryMethods
     class Twilio < Base
       def deliver
-        HTTP.basic_auth(user: account_sid, pass: auth_token).post(url, json: format)
+        post(url, basic_auth: {user: account_sid, pass: auth_token}, form: format)
       end
 
       private

data/lib/noticed/delivery_methods/vonage.rb

@@ -2,7 +2,13 @@ module Noticed
   module DeliveryMethods
     class Vonage < Base
       def deliver
-        HTTP.post("https://rest.nexmo.com/sms/json", json: format)
+        response = post("https://rest.nexmo.com/sms/json", json: format)
+        status = response.parse.dig("messages", 0, "status")
+        if !options[:ignore_failure] && status != "0"
+          raise ResponseUnsuccessful.new(response)
+        end
+
+        response
       end
 
       private

data/lib/noticed/model.rb

@@ -0,0 +1,61 @@
+module Noticed
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      self.inheritance_column = nil
+
+      serialize :params, noticed_coder
+
+      belongs_to :recipient, polymorphic: true
+
+      scope :newest_first, -> { order(created_at: :desc) }
+      scope :unread, -> { where(read_at: nil) }
+      scope :read, -> { where.not(read_at: nil) }
+    end
+
+    class_methods do
+      def mark_as_read!
+        update_all(read_at: Time.current, updated_at: Time.current)
+      end
+
+      def mark_as_unread!
+        update_all(read_at: nil, updated_at: Time.current)
+      end
+
+      def noticed_coder
+        case attribute_types["params"].type
+        when :json, :jsonb
+          Noticed::Coder
+        else
+          Noticed::TextCoder
+        end
+      end
+    end
+
+    # Rehydrate the database notification into the Notification object for rendering
+    def to_notification
+      @_notification ||= begin
+        instance = type.constantize.with(params)
+        instance.record = self
+        instance
+      end
+    end
+
+    def mark_as_read!
+      update(read_at: Time.current)
+    end
+
+    def mark_as_unread!
+      update(read_at: nil)
+    end
+
+    def unread?
+      !read?
+    end
+
+    def read?
+      read_at?
+    end
+  end
+end

data/lib/noticed/text_coder.rb

@@ -0,0 +1,16 @@
+module Noticed
+  class TextCoder
+    def self.load(data)
+      return if data.nil?
+
+      # Text columns need JSON parsing
+      data = JSON.parse(data)
+      ActiveJob::Arguments.send(:deserialize_argument, data)
+    end
+
+    def self.dump(data)
+      return if data.nil?
+      ActiveJob::Arguments.send(:serialize_argument, data).to_json
+    end
+  end
+end

data/lib/noticed/translation.rb

@@ -0,0 +1,23 @@
+module Noticed
+  module Translation
+    extend ActiveSupport::Concern
+
+    # Returns the +i18n_scope+ for the class. Overwrite if you want custom lookup.
+    def i18n_scope
+      :notifications
+    end
+
+    def translate(key, **options)
+      I18n.translate(scope_translation_key(key), **options)
+    end
+    alias_method :t, :translate
+
+    def scope_translation_key(key)
+      if key.to_s.start_with?(".")
+        "#{i18n_scope}.#{self.class.name.underscore}#{key}"
+      else
+        key
+      end
+    end
+  end
+end

data/lib/noticed/version.rb

@@ -1,3 +1,3 @@
 module Noticed
-  VERSION = "1.0.0"
+  VERSION = "1.2.20"
 end

data/lib/noticed.rb

@@ -1,9 +1,14 @@
+require "active_job/arguments"
 require "http"
 require "noticed/engine"
 
 module Noticed
   autoload :Base, "noticed/base"
   autoload :Coder, "noticed/coder"
+  autoload :Model, "noticed/model"
+  autoload :TextCoder, "noticed/text_coder"
+  autoload :Translation, "noticed/translation"
+  autoload :NotificationChannel, "noticed/notification_channel"
 
   module DeliveryMethods
     autoload :Base, "noticed/delivery_methods/base"
@@ -11,6 +16,7 @@ module Noticed
     autoload :Database, "noticed/delivery_methods/database"
     autoload :Email, "noticed/delivery_methods/email"
     autoload :Slack, "noticed/delivery_methods/slack"
+    autoload :MicrosoftTeams, "noticed/delivery_methods/microsoft_teams"
     autoload :Test, "noticed/delivery_methods/test"
     autoload :Twilio, "noticed/delivery_methods/twilio"
     autoload :Vonage, "noticed/delivery_methods/vonage"
@@ -30,4 +36,12 @@ module Noticed
 
   class ValidationError < StandardError
   end
+
+  class ResponseUnsuccessful < StandardError
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+    end
+  end
 end