rails_notice 0.1.0

data/app/channels/notices_channel.rb

@@ -0,0 +1,7 @@
+class NoticesChannel < ApplicationCable::Channel
+
+  def subscribed
+    stream_from "#{current_receiver.class.name}:#{current_receiver&.id}"
+  end
+
+end

data/app/channels/the_notify_connection.rb

@@ -0,0 +1,30 @@
+# prepend this module
+module RailsNoticeConnection
+
+  def self.prepended(model)
+    model.identified_by :current_receiver
+  end
+
+  def connect
+    self.current_receiver = find_verified_receiver
+    super
+  end
+
+  protected
+  def find_verified_receiver
+    if session && session['receiver_id'] && session['receiver_type']
+      Rails.logger.silence do
+        session['receiver_type'].constantize.find session['receiver_id']
+      end
+    else
+      logger.error 'An unauthorized connection attempt was rejected'
+      nil
+    end
+  end
+
+  def session
+    session_key = Rails.configuration.session_options[:key]
+    cookies.encrypted[session_key]
+  end
+
+end

data/app/controllers/concerns/rails_notice_controller.rb

@@ -0,0 +1,18 @@
+module RailsNoticeController
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_receiver
+    helper_method :current_receiver
+  end
+
+  def set_receiver
+    session['receiver_type'] = current_receiver.class.name
+    session['receiver_id'] = current_receiver&.id
+  end
+
+  def current_receiver
+    current_user
+  end
+
+end

data/app/controllers/rails_notice_admin/base_controller.rb

@@ -0,0 +1,6 @@
+class RailsNoticeAdmin::BaseController < RailsNotice.config.admin_class.constantize
+  #skip_before_action :verify_authenticity_token#, if: -> { request.content_type == 'application/json' }
+
+
+
+end

data/app/controllers/rails_notice_admin/notification_settings_controller.rb

@@ -0,0 +1,55 @@
+class RailsNoticeAdmin::NotificationSettingsController < RailsNoticeAdmin::BaseController
+  before_action :set_notification_setting, only: [:show, :edit, :update, :destroy]
+
+  def index
+    q_params = params.fetch(:q, {}).permit(:id, :receiver_type, :receiver_id)
+    @notification_settings = NotificationSetting.default_where(q_params).page(params[:page])
+  end
+
+  def new
+    @notification_setting = NotificationSetting.new
+  end
+
+  def create
+    @notification_setting = NotificationSetting.new(notification_setting_params)
+
+    if @notification_setting.save
+      redirect_to admin_notification_settings_url, notice: 'Notification setting was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def show
+  end
+
+  def edit
+  end
+
+  def update
+    respond_to do |format|
+      if @notification_setting.update(notification_setting_params)
+        format.html { redirect_to admin_notification_settings_url, notice: 'Notification setting was successfully updated.' }
+        format.js
+      else
+        format.html { render :edit }
+        format.js
+      end
+    end
+  end
+
+  def destroy
+    @notification_setting.destroy
+    redirect_to admin_notification_settings_url, notice: 'Notification setting was successfully destroyed.'
+  end
+
+  private
+  def set_notification_setting
+    @notification_setting = NotificationSetting.find(params[:id])
+  end
+
+  def notification_setting_params
+    params.fetch(:notification_setting, {}).permit(:showtime, :accept_email, notifiable_types: [])
+  end
+
+end

data/app/controllers/rails_notice_admin/notifications_controller.rb

@@ -0,0 +1,71 @@
+class RailsNoticeAdmin::NotificationsController < RailsNoticeAdmin::BaseController
+  before_action :set_receiver, only: [:index, :new, :create]
+  before_action :set_notification, only: [:show, :push, :email, :edit, :update, :destroy]
+
+  def index
+    if @receiver
+      @notifications = @receiver.notifications.page(params[:page])
+    else
+      @notifications = Notification.default_where(params.fetch(:q, {}).permit(:id, :'body-like', :receiver_type, :receiver_id)).page(params[:page])
+    end
+  end
+
+  def show
+  end
+
+  def push
+    @notification.process_job
+    head :ok
+  end
+
+  def email
+    @notification.send_email
+    head :ok
+  end
+
+  def new
+    @notification = @receiver.notifications.build
+  end
+
+  def edit
+  end
+
+  def create
+    @notification = @receiver.notifications.build(notification_params)
+
+    if @notification.save
+      redirect_to admin_notifications_url(receiver_id: @receiver.id, receiver_type: @receiver.class.name), notice: 'User notification was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def update
+    if @notification.update(notification_params)
+      redirect_to admin_notifications_url(receiver_id: @receiver.id, receiver_type: @receiver.class.name), notice: 'User notification was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    @notification.destroy
+    redirect_to admin_notifications_url(receiver_id: @receiver.id, receiver_type: @receiver.class.name), notice: 'User notification was successfully destroyed.'
+  end
+
+  private
+  def set_receiver
+    if params[:receiver_type]
+      @receiver = params[:receiver_type].constantize.find(params[:receiver_id])
+    end
+  end
+
+  def set_notification
+    @notification = Notification.find(params[:id])
+  end
+
+  def notification_params
+    params[:notification].permit(:title, :body, :link)
+  end
+
+end

data/app/controllers/rails_notice_my/base_controller.rb

@@ -0,0 +1,5 @@
+class RailsNoticeMy::BaseController < RailsNotice.config.my_class.constantize
+
+
+
+end

data/app/controllers/rails_notice_my/notification_settings_controller.rb

@@ -0,0 +1,28 @@
+class RailsNoticeMy::NotificationSettingsController < RailsNoticeMy::BaseController
+  before_action :set_notification_setting, only: [:show, :edit, :update]
+
+  def show
+  end
+
+  def edit
+  end
+
+  def update
+    if @notification_setting.update(notification_setting_params)
+      redirect_to notification_settings_url(receiver: params[:receiver]), notice: 'Notification setting was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  private
+  def set_notification_setting
+    @receiver = current_receiver
+    @notification_setting = @receiver.notification_setting || @receiver.build_notification_setting
+  end
+
+  def notification_setting_params
+    params.fetch(:notification_setting, {}).permit(:showtime, :accept_email)
+  end
+
+end

data/app/controllers/rails_notice_my/notifications_controller.rb

@@ -0,0 +1,78 @@
+class RailsNoticeMy::NotificationsController < RailsNoticeMy::BaseController
+  before_action :set_notification, only: [:show, :url, :read, :edit, :update, :destroy]
+  before_action :set_receiver, only: [:index, :read_all]
+  protect_from_forgery except: :read
+
+  def index
+    @notifications = @receiver.received_notifications.order(read_at: :asc)
+    if params[:scope] == 'have_read'
+      @notifications = @notifications.have_read
+    else
+      @notifications = @notifications.unread
+    end
+    @notifications = @notifications.page(params[:page])
+
+    respond_to do |format|
+      format.html
+      format.js
+    end
+  end
+
+  def read_all
+    @notifications = @receiver.received_notifications
+    @notifications.update_all(read_at: Time.now)
+    @count = Notification.update_unread_count(@receiver)
+  end
+
+  def new
+    @notification = Notification.new
+  end
+
+  def create
+    @notification = Notification.new(params[:notification].permit!)
+
+    if @notification.save
+      redirect_to(notifications_path, notice: 'Notification 创建成功。')
+    else
+      render action: 'new'
+    end
+  end
+
+  def show
+  end
+
+  def url
+    @notification.make_as_read
+    redirect_to @notification.link
+  end
+
+  def read
+    @notification.make_as_read
+  end
+
+  def edit
+  end
+
+  def update
+    if @notification.update(params[:notification].permit!)
+      redirect_to(notifications_path, notice: 'Notification 更新成功。')
+    else
+      render action: 'edit'
+    end
+  end
+
+  def destroy
+    @notification.destroy
+    redirect_to(notifications_path, notice: "删除成功。")
+  end
+
+  private
+  def set_receiver
+    @receiver = current_receiver
+  end
+
+  def set_notification
+    @notification = Notification.find(params[:id])
+  end
+
+end

data/app/controllers/receivers_controller.rb

@@ -0,0 +1,12 @@
+class ReceiversController < ApplicationController
+
+  def search
+    if Notification.options_i18n(:receiver_type).values.include?(params[:receiver_type].to_sym) && params[:receiver_type].safe_constantize
+      @receivers = params[:receiver_type].safe_constantize.default_where('name-like': params[:q])
+      render json: { results: @receivers.as_json(only: [:id], methods: [:name]) }
+    else
+      render json: { results: [] }
+    end
+  end
+
+end

data/app/jobs/notification_job.rb

@@ -0,0 +1,17 @@
+class NotificationJob < ApplicationJob
+  queue_as :default
+
+  def perform(notification_id)
+    notify = Notification.find(notification_id)
+    if notify.receiver
+      result = ActionCable.server.broadcast "#{notify.receiver_type}:#{notify.receiver_id}",
+                                            id: notify.id,
+                                            body: notify.body,
+                                            count: notify.unread_count,
+                                            link: notify.link,
+                                            showtime: notify.notification_setting&.showtime
+      notify.update sent_at: Time.now, sent_result: result
+    end
+  end
+
+end

data/app/mailers/rails_notice_mailer.rb

@@ -0,0 +1,21 @@
+class RailsNoticeMailer < ApplicationMailer
+  add_template_helper(RailsCom::FormatHelper)
+
+  def notify(notification_id)
+    @notification = Notification.find(notification_id)
+    unless @notification.receiver.respond_to?(:email) && @notification.receiver.email
+      return
+    end
+    if @notification.receiver.respond_to?(:locale)
+      I18n.locale = @notification.receiver.locale
+    end
+
+    mail_params = {to: @notification.receiver.email,
+         cc: @notification.cc_emails,
+         subject: @notification.title || 'Notification'}
+    mail_params[:from] = @notification.sender.email if @notification.sender && @notification.sender.respond_to?(:email) && @notification.sender.email
+
+    mail mail_params
+  end
+
+end

data/app/models/annunciation.rb

@@ -0,0 +1,4 @@
+class Annunciation < ApplicationRecord
+  belongs_to :publisher, polymorphic: true
+
+end

data/app/models/concerns/i18n_helper.rb

@@ -0,0 +1,14 @@
+module I18nHelper
+  extend self
+
+  def interpolate_key(string)
+    string.gsub(I18n::INTERPOLATION_PATTERN).map do |match|
+      if match == '%%'
+        next
+      else
+        ($1 || $2 || match.tr('%{}', '')).to_sym
+      end
+    end
+  end
+
+end

data/app/models/concerns/the_notifiable.rb

@@ -0,0 +1,33 @@
+module TheNotifiable
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :notifies, default: {}
+
+    delegate :url_helpers, to: 'Rails.application.routes'
+
+    has_many :notifications, as: 'notifiable', dependent: :delete_all
+
+    RailsNotice.notifiable_types << self.name unless RailsNotice.notifiable_types.include?(self.name)
+  end
+
+  def to_notification(receiver: , **other_params)
+    n = self.notifications.build
+    n.receiver_id = receiver.id
+    n.receiver_type = receiver.class
+
+    if other_params[:sender]
+      n.sender_id = other_params[:sender].id
+      n.sender_type = other_params[:sender].class
+    end
+
+    n.assign_attributes other_params.slice(
+      :title, :body, :link,
+      :verbose, :code,
+      :cc_emails
+    )
+
+    n.save!
+  end
+
+end

data/app/models/concerns/the_publishable.rb

@@ -0,0 +1,9 @@
+module ThePublishable
+  extend ActiveSupport::Concern
+
+  included do
+    Annunciation.belongs_to :publisher, class_name: name, foreign_key: 'publisher_id', optional: true, inverse_of: :notifications
+    has_many :published_notifications, class_name: 'Notification', foreign_key: 'publisher_id', dependent: :nullify
+  end
+
+end

data/app/models/concerns/the_receivable.rb

@@ -0,0 +1,17 @@
+module TheReceivable
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :received_notifications, as: 'receiver', class_name: 'Notification', dependent: :destroy
+    has_one :notification_setting, as: 'receiver', dependent: :destroy
+  end
+
+  def unread_count
+    Rails.cache.read("#{self.class.name}_#{self.id}_unread") || 0
+  end
+
+  def endearing_name
+    name
+  end
+
+end