noticed 1.6.3 → 2.0.0

data/lib/generators/noticed/model/mysql_generator.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators/named_base"
-require_relative "base_generator"
-
-module Noticed
-  module Generators
-    module Model
-      class MysqlGenerator < BaseGenerator
-        private
-
-        def json_column_type
-          "json"
-        end
-      end
-    end
-  end
-end

data/lib/generators/noticed/model/postgresql_generator.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators/named_base"
-require_relative "base_generator"
-
-module Noticed
-  module Generators
-    module Model
-      class PostgresqlGenerator < BaseGenerator
-        private
-
-        def json_column_type
-          "jsonb"
-        end
-      end
-    end
-  end
-end

data/lib/generators/noticed/model/sqlite3_generator.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators/named_base"
-require_relative "base_generator"
-
-module Noticed
-  module Generators
-    module Model
-      class Sqlite3Generator < BaseGenerator
-        private
-
-        def json_column_type
-          "json"
-        end
-      end
-    end
-  end
-end

data/lib/generators/noticed/model_generator.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators/named_base"
-
-module Noticed
-  module Generators
-    class ModelGenerator < Rails::Generators::NamedBase
-      include Rails::Generators::ResourceHelpers
-
-      source_root File.expand_path("../templates", __FILE__)
-
-      desc "Generates a Notification model for storing notifications."
-
-      argument :name, type: :string, default: "Notification", banner: "Notification"
-      argument :attributes, type: :array, default: [], banner: "field:type field:type"
-
-      def generate_notification
-        generate :model, name, "recipient:references{polymorphic}", "type", params_column, "read_at:datetime:index", *attributes
-      end
-
-      def add_noticed_model
-        inject_into_class model_path, class_name, "  include Noticed::Model\n"
-      end
-
-      def add_not_nullable
-        migration_path = Dir.glob(Rails.root.join("db/migrate/*")).max_by { |f| File.mtime(f) }
-
-        # Force is required because null: false already exists in the file and Thor isn't smart enough to tell the difference
-        insert_into_file migration_path, after: "t.string :type", force: true do
-          ", null: false"
-        end
-      end
-
-      def done
-        readme "README" if behavior == :invoke
-      end
-
-      private
-
-      def model_path
-        @model_path ||= File.join("app", "models", "#{file_path}.rb")
-      end
-
-      def params_column
-        case current_adapter
-        when "postgresql", "postgis"
-          "params:jsonb"
-        else
-          # MySQL and SQLite both support json
-          "params:json"
-        end
-      end
-
-      def current_adapter
-        if ActiveRecord::Base.respond_to?(:connection_db_config)
-          ActiveRecord::Base.connection_db_config.adapter
-        else
-          ActiveRecord::Base.connection_config[:adapter]
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# 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,160 +0,0 @@
-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: []
-
-    # Gives notifications access to the record and recipient during delivery
-    attr_accessor :record, :recipient
-
-    delegate :read?, :unread?, to: :record
-
-    class << self
-      def deliver_by(name, options = {})
-        delivery_methods.push(name: name, options: options)
-        define_model_callbacks(name)
-      end
-
-      # Copy delivery methods from parent
-      def inherited(base) # :nodoc:
-        base.delivery_methods = delivery_methods.dup
-        base.param_names = param_names.dup
-        super
-      end
-
-      def with(params)
-        new(params)
-      end
-
-      # Shortcut for delivering without params
-      def deliver(recipients)
-        new.deliver(recipients)
-      end
-
-      # Shortcut for delivering later without params
-      def deliver_later(recipients)
-        new.deliver_later(recipients)
-      end
-
-      def params(*names)
-        param_names.concat Array.wrap(names)
-      end
-      alias_method :param, :params
-    end
-
-    def initialize(params = {})
-      @params = params
-    end
-
-    def deliver(recipients)
-      validate!
-
-      run_callbacks :deliver do
-        Array.wrap(recipients).uniq.each do |recipient|
-          run_delivery(recipient, enqueue: false)
-        end
-      end
-    end
-
-    def deliver_later(recipients)
-      validate!
-
-      run_callbacks :deliver do
-        Array.wrap(recipients).uniq.each do |recipient|
-          run_delivery(recipient, enqueue: true)
-        end
-      end
-    end
-
-    def params
-      @params || {}
-    end
-
-    def clear_recipient
-      self.recipient = nil
-    end
-
-    private
-
-    # Runs all delivery methods for a notification
-    def run_delivery(recipient, enqueue: true)
-      delivery_methods = self.class.delivery_methods.dup
-
-      self.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)
-        self.record = run_delivery_method(delivery_method, recipient: recipient, enqueue: false, record: nil)
-      end
-
-      delivery_methods.each do |delivery_method|
-        run_delivery_method(delivery_method, recipient: recipient, enqueue: enqueue, record: record)
-      end
-    end
-
-    # Actually runs an individual delivery
-    def run_delivery_method(delivery_method, recipient:, enqueue:, record:)
-      args = {
-        notification_class: self.class.name,
-        options: delivery_method[:options],
-        params: params,
-        recipient: recipient,
-        record: record
-      }
-
-      run_callbacks delivery_method[:name] do
-        method = delivery_method_for(delivery_method[:name], delivery_method[:options])
-
-        # If the queue is `nil`, ActiveJob will use a default queue name.
-        queue = delivery_method.dig(:options, :queue)
-
-        # Always perfrom later if a delay is present
-        if (delay = delivery_method.dig(:options, :delay))
-          # Dynamic delays with metho calls or
-          delay = send(delay) if delay.is_a? Symbol
-
-          method.set(wait: delay, queue: queue).perform_later(args)
-        elsif enqueue
-          method.set(queue: queue).perform_later(args)
-        else
-          method.perform_now(args)
-        end
-      end
-    end
-
-    def delivery_method_for(name, options)
-      if options[:class]
-        options[:class].constantize
-      else
-        "Noticed::DeliveryMethods::#{name.to_s.camelize}".constantize
-      end
-    end
-
-    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/delivery_methods/base.rb

@@ -1,95 +0,0 @@
-module Noticed
-  module DeliveryMethods
-    class Base < Noticed.parent_class.constantize
-      extend ActiveModel::Callbacks
-      define_model_callbacks :deliver
-
-      class_attribute :option_names, instance_writer: false, default: []
-
-      attr_reader :notification, :options, :params, :recipient, :record, :logger
-
-      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 assign_args(args)
-        @notification = args.fetch(:notification_class).constantize.new(args[:params])
-        @options = args[:options] || {}
-        @params = args[:params]
-        @recipient = args[:recipient]
-        @record = args[:record]
-
-        # Set the default logger
-        @logger = @options.fetch(:logger, Rails.logger)
-
-        # Make notification aware of database record and recipient during delivery
-        @notification.record = args[:record]
-        @notification.recipient = args[:recipient]
-        self
-      end
-
-      def perform(args)
-        assign_args(args)
-
-        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:}, headers: {}, json: {}, form: {})
-      #
-      def post(url, args = {})
-        basic_auth = args.delete(:basic_auth)
-        headers = args.delete(:headers)
-
-        request = HTTP
-        request = request.basic_auth(user: basic_auth[:user], pass: basic_auth[:pass]) if basic_auth
-        request = request.headers(headers) if headers
-
-        response = request.post(url, args)
-
-        if options[:debug]
-          logger.debug("POST #{url}")
-          logger.debug("Response: #{response.code}: #{response}")
-        end
-
-        if !options[:ignore_failure] && !response.status.success?
-          puts response.status
-          puts response.body
-          raise ResponseUnsuccessful.new(response)
-        end
-
-        response
-      end
-    end
-  end
-end

data/lib/noticed/delivery_methods/database.rb

@@ -1,34 +0,0 @@
-module Noticed
-  module DeliveryMethods
-    class Database < Base
-      # Must return the database record
-      def deliver
-        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: notification.params
-          }
-        end
-      end
-    end
-  end
-end

data/lib/noticed/delivery_methods/twilio.rb

@@ -1,51 +0,0 @@
-module Noticed
-  module DeliveryMethods
-    class Twilio < Base
-      def deliver
-        post(url, basic_auth: {user: account_sid, pass: auth_token}, form: format)
-      end
-
-      private
-
-      def format
-        if (method = options[:format])
-          notification.send(method)
-        else
-          {
-            From: phone_number,
-            To: recipient.phone_number,
-            Body: notification.params[:message]
-          }
-        end
-      end
-
-      def url
-        if (method = options[:url])
-          notification.send(method)
-        else
-          "https://api.twilio.com/2010-04-01/Accounts/#{account_sid}/Messages.json"
-        end
-      end
-
-      def account_sid
-        credentials.fetch(:account_sid)
-      end
-
-      def auth_token
-        credentials.fetch(:auth_token)
-      end
-
-      def phone_number
-        credentials.fetch(:phone_number)
-      end
-
-      def credentials
-        if (method = options[:credentials])
-          notification.send(method)
-        else
-          Rails.application.credentials.twilio
-        end
-      end
-    end
-  end
-end

data/lib/noticed/delivery_methods/vonage.rb

@@ -1,40 +0,0 @@
-module Noticed
-  module DeliveryMethods
-    class Vonage < Base
-      def deliver
-        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
-
-      def format
-        if (method = options[:format])
-          notification.send(method)
-        else
-          {
-            api_key: credentials[:api_key],
-            api_secret: credentials[:api_secret],
-            from: notification.params[:from],
-            text: notification.params[:body],
-            to: notification.params[:to],
-            type: "unicode"
-          }
-        end
-      end
-
-      def credentials
-        if (method = options[:credentials])
-          notification.send(method)
-        else
-          Rails.application.credentials.vonage
-        end
-      end
-    end
-  end
-end

data/lib/noticed/has_notifications.rb

@@ -1,49 +0,0 @@
-module Noticed
-  module HasNotifications
-    # Defines a method for the association and a before_destroy callback to remove notifications
-    # where this record is a param
-    #
-    #    class User < ApplicationRecord
-    #      has_noticed_notifications
-    #      has_noticed_notifications param_name: :owner, destroy: false, model: "Notification"
-    #    end
-    #
-    #    @user.notifications_as_user
-    #    @user.notifications_as_owner
-
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def has_noticed_notifications(param_name: model_name.singular, **options)
-        define_method "notifications_as_#{param_name}" do
-          model = options.fetch(:model_name, "Notification").constantize
-          case current_adapter
-          when "postgresql", "postgis"
-            model.where("params @> ?", Noticed::Coder.dump(param_name.to_sym => self).to_json)
-          when "mysql2"
-            model.where("JSON_CONTAINS(params, ?)", Noticed::Coder.dump(param_name.to_sym => self).to_json)
-          when "sqlite3"
-            model.where("json_extract(params, ?) = ?", "$.#{param_name}", Noticed::Coder.dump(self).to_json)
-          else
-            # This will perform an exact match which isn't ideal
-            model.where(params: {param_name.to_sym => self})
-          end
-        end
-
-        if options.fetch(:destroy, true)
-          before_destroy do
-            send("notifications_as_#{param_name}").destroy_all
-          end
-        end
-      end
-    end
-
-    def current_adapter
-      if ActiveRecord::Base.respond_to?(:connection_db_config)
-        ActiveRecord::Base.connection_db_config.adapter
-      else
-        ActiveRecord::Base.connection_config[:adapter]
-      end
-    end
-  end
-end

data/lib/noticed/model.rb

@@ -1,85 +0,0 @@
-module Noticed
-  module Model
-    DATABASE_ERROR_CLASS_NAMES = lambda {
-      classes = [ActiveRecord::NoDatabaseError]
-      classes << ActiveRecord::ConnectionNotEstablished
-      classes << Mysql2::Error if defined?(::Mysql2)
-      classes << PG::ConnectionBad if defined?(::PG)
-      classes
-    }.call.freeze
-
-    extend ActiveSupport::Concern
-
-    included do
-      self.inheritance_column = nil
-
-      if Rails.gem_version >= Gem::Version.new("7.1.0.alpha")
-        serialize :params, coder: noticed_coder
-      else
-        serialize :params, noticed_coder
-      end
-
-      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
-        return Noticed::TextCoder unless table_exists?
-
-        case attribute_types["params"].type
-        when :json, :jsonb
-          Noticed::Coder
-        else
-          Noticed::TextCoder
-        end
-      rescue *DATABASE_ERROR_CLASS_NAMES => _error
-        warn("Noticed was unable to bootstrap correctly as the database is unavailable.")
-
-        Noticed::TextCoder
-      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.recipient = recipient
-        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
-
-    # If a GlobalID record in params is no longer found, the params will default with a noticed_error key
-    def deserialize_error?
-      !!params[:noticed_error]
-    end
-  end
-end

data/lib/noticed/notification_channel.rb

@@ -1,15 +0,0 @@
-module Noticed
-  class NotificationChannel < ApplicationCable::Channel
-    def subscribed
-      stream_for current_user
-    end
-
-    def unsubscribed
-      stop_all_streams
-    end
-
-    def mark_as_read(data)
-      current_user.notifications.where(id: data["ids"]).mark_as_read!
-    end
-  end
-end

data/lib/noticed/text_coder.rb

@@ -1,16 +0,0 @@
-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