redmine_events_manager 0.4.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a76fba8e0e80ac0cb125f39d3651721a0239b0e69ef46c818c0125b4eb9af2fd
+  data.tar.gz: 7f9f3742c930fb348878382b06a787077e88563f7d1cc3e430668db752537790
+SHA512:
+  metadata.gz: 936392a8e1096dec12b8f309b32df278e59e511c085937de11f71ef8d88b718e877d5c2ae1c2c3ec2eb52f3553fbed851775b6b71ad70fe20a35e06942e2fe93
+  data.tar.gz: 4015c2642a34f911faa94428d1876a3d69ad1b847d3a974807b7f1df663d24bdc59be02e71fc761f994133733f1d637594bd5a05de850b8c338242d11c07189d

data/.avm.yml

@@ -0,0 +1,3 @@
+ruby:
+  rubocop:
+    gemfile: SelfGemfile

data/.gitignore

@@ -0,0 +1 @@
+/SelfGemfile.lock

data/.rubocop.yml

@@ -0,0 +1,40 @@
+require:
+  - rubocop-rails
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 2.4
+  TargetRailsVersion: 4.2
+
+Layout/LineLength:
+  Max: 100
+  Exclude:
+    - 'db/migrate/**/*'
+
+Metrics/AbcSize:
+  Exclude:
+    - 'db/migrate/**/*'
+    - 'test/**/*'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'db/migrate/**/*'
+    - 'lib/tasks/**/*'
+    - 'spec/**/*.rb'
+
+Metrics/MethodLength:
+  Exclude:
+    - 'db/migrate/**/*'
+    - 'test/**/*'
+
+Style/Documentation:
+  Enabled: false
+
+Style/HashEachMethods:
+  Enabled: true
+
+Style/HashTransformKeys:
+  Enabled: true
+
+Style/HashTransformValues:
+  Enabled: true

data/SelfGemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/app/controllers/event_exceptions_controller.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class EventExceptionsController < ApplicationController
+  before_action :require_admin
+  layout 'admin'
+  before_action :clear_event_exception_unchecked, only: :index # rubocop:disable Rails/LexicallyScopedActionFilter
+
+  active_scaffold :event_exception do |conf|
+    conf.actions.exclude :create, :update, :delete
+    conf.list.columns = %i[created_at event_entity event_action listener_class]
+    conf.list.sorting = { created_at: :desc }
+    conf.action_links.add :download, type: :member, label: 'Download', page: true
+  end
+
+  def download
+    ex = find_if_allowed(params[:id], :read)
+    send_data ex.attributes.to_yaml, filename: download_filename(ex)
+  end
+
+  private
+
+  def download_filename(error)
+    [Setting.host_name, 'exception', error.id.to_s, error.created_at.to_s].map do |s|
+      s.parameterize.strip
+    end.select(&:present?).join('_')
+  end
+
+  def clear_event_exception_unchecked
+    EventsManager::Settings.event_exception_unchecked = false if
+    EventsManager::Settings.event_exception_unchecked
+  end
+end

data/app/controllers/listener_options_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ListenerOptionsController < ApplicationController
+  before_action :require_admin
+  layout 'admin'
+
+  active_scaffold :listener_option do |conf|
+    conf.columns[:listener_class].form_ui = :select
+    conf.columns[:listener_class].options ||= {}
+    conf.columns[:listener_class].options[:options] = ::ListenerOption.listener_class_options
+  end
+end

data/app/models/event_exception.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class EventException < ActiveRecord::Base
+  self.inheritance_column = nil
+
+  validates :event_entity, :event_action, :event_data, :listener_class, :listener_instance,
+            :exception_class, :exception_message, :exception_stack, presence: true
+end

data/app/models/listener_option.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class ListenerOption < ActiveRecord::Base
+  DEFAULT_DELAY = 0
+  DEFAULT_ENABLED = true
+
+  class << self
+    def listener_class_list
+      @listener_class_list ||= ::EventsManager.all_listeners
+    end
+
+    def listener_class_options
+      listener_class_list.sort.map { |v| [v, v] }
+    end
+
+    def listener_delay(listener_class)
+      o = ::ListenerOption.find_by(listener_class: listener_class.to_s)
+      o && o.delay.present? && o.delay >= 0 ? o.delay : DEFAULT_DELAY
+    end
+
+    def listener_enabled?(listener_class)
+      o = ::ListenerOption.find_by(listener_class: listener_class.to_s)
+      o.present? ? o.enabled? : DEFAULT_ENABLED
+    end
+
+    def listener_enable(listener_class, enabled)
+      o = ::ListenerOption.find_or_create_by(listener_class: listener_class.to_s)
+      o.enabled = enabled
+      o.save!
+    end
+  end
+
+  validates :listener_class, presence: true, uniqueness: true,
+                             inclusion: { in: listener_class_list }
+  validates :delay, allow_blank: true,
+                    numericality: { integer_only: true }
+end

data/assets/stylesheets/application.css

@@ -0,0 +1,8 @@
+#top-menu .event-exception-unchecked {
+  background-image: url('../../../images/warning.png');
+  background-position: 0% 40%;
+  background-repeat: no-repeat;
+  padding-left: 20px;
+  padding-top: 2px;
+  padding-bottom: 3px;
+}

data/bin/bundle

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../SelfGemfile', __dir__)
+load Gem.bin_path('bundler', 'bundle')

data/config/initializers/000_dependencies.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+Redmine::Plugin.post_register :redmine_events_manager do
+  # Source: https://github.com/esquilo-azul/redmine_nonproject_modules
+  requires_redmine_plugin(:redmine_nonproject_modules, version_or_higher: '0.2.1')
+end

data/config/locales/pt-BR.yml

@@ -0,0 +1,7 @@
+pt-BR:
+  activerecord:
+    description:
+      listener_option:
+        delay: Atraso em segundos para o listener ser processado.
+  label_event_exception_plural: Exceções em eventos
+  label_listener_option_plural: Opções de listeners

data/config/routes.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RedmineApp::Application.routes.draw do
+  resources(:event_exceptions) do
+    as_routes
+    member do
+      get :download
+    end
+  end
+  resources(:listener_options) { as_routes }
+end

data/db/migrate/20160509152749_create_delayed_jobs.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class CreateDelayedJobs < (
+    Rails.version < '5.2' ? ActiveRecord::Migration : ActiveRecord::Migration[4.2]
+  )
+  def self.up
+    create_table :delayed_jobs, force: true do |table|
+      table.integer :priority, default: 0, null: false # Allows some jobs to jump to the front of
+      # the queue
+      table.integer :attempts, default: 0, null: false # Provides for retries, but still fail eventually.
+      table.text :handler,                 null: false # YAML-encoded string of the object that will do work
+      table.text :last_error                           # reason for last failure (See Note below)
+      table.datetime :run_at                           # When to run. Could be Time.zone.now for immediately, or sometime in the future.
+      table.datetime :locked_at                        # Set when a client is working on this object
+      table.datetime :failed_at                        # Set when all retries have failed (actually, by default, the record is deleted instead)
+      table.string :locked_by                          # Who is working on this object (if locked)
+      table.string :queue                              # The name of the queue this job is in
+      table.timestamps null: true
+    end
+
+    add_index :delayed_jobs, %i[priority run_at], name: 'delayed_jobs_priority'
+  end
+
+  def self.down
+    drop_table :delayed_jobs
+  end
+end

data/db/migrate/20160717222418_create_event_exceptions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateEventExceptions < (
+    Rails.version < '5.2' ? ActiveRecord::Migration : ActiveRecord::Migration[4.2]
+  )
+  def change
+    create_table :event_exceptions do |t|
+      t.string :event_entity
+      t.string :event_action
+      t.text :event_data
+      t.string :listener_class
+      t.string :listener_instance
+      t.string :exception_class
+      t.string :exception_message
+      t.text :exception_stack
+
+      t.timestamps null: false
+    end
+  end
+end

data/db/migrate/20180331122033_create_listener_options.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreateListenerOptions < (
+    Rails.version < '5.2' ? ActiveRecord::Migration : ActiveRecord::Migration[4.2]
+  )
+  def change
+    create_table :listener_options do |t|
+      t.string :listener_class
+      t.integer :delay
+
+      t.timestamps null: false
+    end
+  end
+end

data/db/migrate/20180419202618_add_enabled_to_listener_options.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddEnabledToListenerOptions < (
+    Rails.version < '5.2' ? ActiveRecord::Migration : ActiveRecord::Migration[4.2]
+  )
+  def change
+    add_column :listener_options, :enabled, :boolean, null: false, default: true
+  end
+end

data/db/migrate/20180711170315_rename_plugin_events_manager_to_redmine_events_manager.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class RenamePluginEventsManagerToRedmineEventsManager < (
+    Rails.version < '5.2' ? ActiveRecord::Migration : ActiveRecord::Migration[4.2]
+  )
+  class Settings < ActiveRecord::Base
+  end
+
+  def up
+    rename_plugin('events_manager', 'redmine_events_manager')
+  end
+
+  def down
+    rename_plugin('redmine_events_manager', 'events_manager')
+  end
+
+  private
+
+  def rename_plugin(from, to)
+    old_record = Setting.find_by(name: from)
+    return if old_record.blank?
+
+    new_record = Setting.find_by(name: to)
+    if new_record.present?
+      new_value = plugin_setting_value(old_record).value.merge(plugin_setting_value(new_record))
+      new_record.update!(value: new_value)
+      old_record.destroy!
+    else
+      old_record.update!(name: to)
+    end
+  end
+
+  def plugin_setting_value(record)
+    if record.value.blank?
+      {}.with_indifferent_access
+    elsif record.value.is_a?(Hash)
+      record.value
+    else
+      raise "#{record} value is not Hash or blank"
+    end
+  end
+end

data/init.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'redmine'
+
+require 'events_manager/patches/issue_patch'
+require 'events_manager/patches/issue_relation_patch'
+require 'events_manager/patches/journal_patch'
+require 'events_manager/patches/test_case_patch'
+require 'events_manager/patches/time_entry_patch'
+require 'events_manager/patches/repository/git_patch'
+require 'events_manager'
+require_dependency 'events_manager/hooks/add_assets'
+require_dependency 'redmine_events_manager/version'
+
+Redmine::Plugin.register :redmine_events_manager do
+  name 'Events Manager'
+  author ::RedmineEventsManager::AUTHOR
+  description ::RedmineEventsManager::SUMMARY
+  version ::RedmineEventsManager::VERSION
+
+  settings default: { event_exception_unchecked: false }
+
+  Redmine::MenuManager.map :admin_menu do |menu|
+    menu.push :event_exceptions, { controller: 'event_exceptions', action: 'index', id: nil },
+              caption: :label_event_exception_plural
+    menu.push :listener_options, { controller: 'listener_options', action: 'index', id: nil },
+              caption: :label_listener_option_plural
+  end
+
+  Redmine::MenuManager.map :top_menu do |menu|
+    menu.push :event_exception_unchecked,
+              { controller: 'event_exceptions', action: 'index', id: nil },
+              caption: '', last: true, if: proc {
+                User.current.admin? && EventsManager::Settings.event_exception_unchecked
+              }
+  end
+end

data/lib/events_manager.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module EventsManager
+  class << self
+    attr_accessor :delay_disabled, :log_exceptions_disabled
+
+    EVENT_EXCEPTION_ATTRIBUTES = {
+      event_entity: proc { |e, _l, _ex| e.entity.name },
+      event_action: proc { |e, _l, _ex| e.action.to_s },
+      event_data: proc { |e, _l, _ex| e.data.to_yaml },
+      listener_class: proc { |_e, l, _ex| l.class.name },
+      listener_instance: proc { |_e, l, _ex| l.to_s },
+      exception_class: proc { |_e, _l, ex| ex.class.name },
+      exception_message: proc { |_e, _l, ex| ex.message },
+      exception_stack: proc { |_e, _l, ex| ex.backtrace.join("\n") }
+    }.freeze
+
+    def add_listener(entity, action, listener)
+      return if listeners(entity, action).include?(listener)
+
+      listeners(entity, action) << listener.to_s
+    end
+
+    def trigger(entity, action, data)
+      event = EventsManager::Event.new(entity, action, data)
+      Rails.logger.debug("Event triggered: #{event}")
+      listeners(entity, action).each do |l|
+        Rails.logger.debug("Listener found: #{l}")
+        run_delayed_listener(event, l.constantize.new(event))
+      end
+    end
+
+    def all_listeners
+      r = []
+      @listeners.each_value do |e|
+        e.each_value do |a|
+          r += a
+        end
+      end
+      r.uniq
+    end
+
+    private
+
+    def run_delayed_listener(event, listener)
+      return unless ::ListenerOption.listener_enabled?(listener.class)
+
+      if delay_disabled
+        run_listener(event, listener)
+      else
+        delay(run_at: ::ListenerOption.listener_delay(listener.class).seconds.from_now)
+          .run_listener(event, listener)
+      end
+    end
+
+    def run_listener(event, listener)
+      previous_locale = I18n.locale
+      begin
+        Rails.logger.info("Running listener: #{listener}")
+        I18n.locale = Setting.default_language
+        listener.run
+      rescue StandardError => e
+        on_listener_exception(event, listener, e)
+      ensure
+        I18n.locale = previous_locale
+      end
+    end
+
+    def on_listener_exception(event, listener, exception)
+      raise exception if log_exceptions_disabled
+
+      Rails.logger.warn(exception)
+      begin
+        EventsManager::Settings.event_exception_unchecked = true
+        EventException.create!(event_exception_data(event, listener, exception))
+      rescue StandardError => e
+        Rails.logger.warn(e)
+      end
+    end
+
+    def event_exception_data(event, listener, exception)
+      data = {}
+      EVENT_EXCEPTION_ATTRIBUTES.each do |a, p|
+        data[a] = begin
+          p.call(event, listener, exception)
+                  rescue StandardError => e
+                    e.to_s
+        end
+      end
+      data
+    end
+
+    def listeners(entity, action)
+      @listeners ||= {}
+      @listeners[entity] ||= {}
+      @listeners[entity][action] ||= []
+    end
+  end
+end

data/lib/events_manager/event.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EventsManager
+  class Event
+    attr_reader :entity, :action, :data
+
+    def initialize(entity, action, data)
+      @entity = entity
+      @action = action
+      @data = data
+    end
+
+    def to_s
+      "#{entity}::#{action}|#{data.class}(#{data.id})"
+    end
+
+    def issue_create?
+      entity == ::Issue && action == :create
+    end
+
+    def issue_update?
+      entity == ::Issue && action == :update
+    end
+
+    def issue_relation_create?
+      entity == ::IssueRelation && action == :create
+    end
+  end
+end

data/lib/events_manager/hooks/add_assets.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module EventsManager
+  module Hooks
+    class AddAssets < Redmine::Hook::ViewListener
+      def view_layouts_base_html_head(_context = {})
+        stylesheet_link_tag(:application, plugin: 'redmine_events_manager') + "\n"
+      end
+    end
+  end
+end

data/lib/events_manager/patches/issue_patch.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EventsManager
+  module Patches
+    module IssuePatch
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+
+        base.class_eval do
+          unloadable
+
+          after_create :issue_create_event
+          after_destroy :issue_destroy_event
+        end
+      end
+
+      module InstanceMethods
+        def issue_create_event
+          EventsManager.trigger(Issue, :create, self)
+        end
+
+        def issue_destroy_event
+          EventsManager.trigger(Issue, :delete, self)
+        end
+      end
+    end
+  end
+end
+
+unless Issue.included_modules.include? EventsManager::Patches::IssuePatch
+  Issue.include EventsManager::Patches::IssuePatch
+end

data/lib/events_manager/patches/issue_relation_patch.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EventsManager
+  module Patches
+    module IssueRelationPatch
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+
+        base.class_eval do
+          unloadable
+
+          after_create :issue_relation_create_event
+          after_destroy :issue_relation_destroy_event
+        end
+      end
+
+      module InstanceMethods
+        def issue_relation_create_event
+          EventsManager.trigger(IssueRelation, :create, self)
+        end
+
+        def issue_relation_destroy_event
+          EventsManager.trigger(IssueRelation, :delete, self)
+        end
+      end
+    end
+  end
+end
+
+unless IssueRelation.included_modules.include? EventsManager::Patches::IssueRelationPatch
+  IssueRelation.include EventsManager::Patches::IssueRelationPatch
+end

data/lib/events_manager/patches/journal_patch.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EventsManager
+  module Patches
+    module JournalPatch
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+
+        base.class_eval do
+          unloadable
+
+          after_create :journal_create_event
+        end
+      end
+
+      module InstanceMethods
+        def journal_create_event
+          return unless journalized_type == 'Issue'
+
+          EventsManager.trigger(Issue, :update, self)
+        end
+      end
+    end
+  end
+end
+
+unless Journal.included_modules.include? EventsManager::Patches::JournalPatch
+  Journal.include EventsManager::Patches::JournalPatch
+end

data/lib/events_manager/patches/repository/git_patch.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EventsManager
+  module Patches
+    module Repository
+      module GitPatch
+        def fetch_changesets
+          super
+          EventsManager.trigger(::Repository, :receive, self)
+        end
+      end
+    end
+  end
+end
+
+unless ::Repository::Git.included_modules.include?(EventsManager::Patches::Repository::GitPatch)
+  ::Repository::Git.prepend(EventsManager::Patches::Repository::GitPatch)
+end

data/lib/events_manager/patches/test_case_patch.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EventsManager
+  module Patches
+    module TestCasePatch
+      def self.included(base)
+        base.setup { ::RedmineEventsManager::TestConfig.new.before_each }
+      end
+    end
+  end
+end
+
+if Rails.env.test?
+  unless ::ActiveSupport::TestCase.included_modules.include? EventsManager::Patches::TestCasePatch
+    ::ActiveSupport::TestCase.include EventsManager::Patches::TestCasePatch
+  end
+end

data/lib/events_manager/patches/time_entry_patch.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module EventsManager
+  module Patches
+    module TimeEntryPatch
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+
+        base.class_eval do
+          unloadable
+
+          after_create :time_entry_create_event
+          after_destroy :time_entry_destroy_event
+          after_update :time_entry_update_event
+        end
+      end
+
+      module InstanceMethods
+        def time_entry_create_event
+          EventsManager.trigger(TimeEntry, :create, self)
+        end
+
+        def time_entry_destroy_event
+          EventsManager.trigger(TimeEntry, :delete,
+                                EventsManager::RemovedRecord.new(self))
+        end
+
+        def time_entry_update_event
+          EventsManager.trigger(TimeEntry, :update,
+                                EventsManager::UpdatedRecord.new(self))
+        end
+      end
+    end
+  end
+end
+
+unless TimeEntry.included_modules.include? EventsManager::Patches::TimeEntryPatch
+  TimeEntry.include EventsManager::Patches::TimeEntryPatch
+end

data/lib/events_manager/removed_record.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module EventsManager
+  class RemovedRecord
+    def initialize(record)
+      @attributes = record.attributes
+      @class = record.class
+    end
+
+    def copy_record
+      r = @class.new
+      @attributes.each do |k, v|
+        r.send("#{k}=", v)
+      end
+      r
+    end
+
+    def id
+      @attributes[:id]
+    end
+  end
+end

data/lib/events_manager/settings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EventsManager
+  class Settings
+    class << self
+      def event_exception_unchecked=(value)
+        s = Setting.plugin_redmine_events_manager.dup || {}
+        s[:event_exception_unchecked] = value ? true : false
+        Setting.plugin_redmine_events_manager = s
+      end
+
+      def event_exception_unchecked
+        Setting.plugin_redmine_events_manager[:event_exception_unchecked] ? true : false
+      end
+    end
+  end
+end

data/lib/events_manager/updated_record.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module EventsManager
+  class UpdatedRecord
+    attr_reader :record, :changes
+
+    def initialize(record)
+      @record = record
+      @changes = record.changes
+    end
+
+    delegate :id, to: :record
+  end
+end

data/lib/redmine_events_manager/test_config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RedmineEventsManager
+  class TestConfig
+    def before_each
+      EventsManager.delay_disabled = true
+      EventsManager.log_exceptions_disabled = true
+      EventsManager::Settings.event_exception_unchecked = false
+    end
+  end
+end

data/lib/redmine_events_manager/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RedmineEventsManager
+  AUTHOR = 'Eduardo Henrique Bogoni'
+  HOMEPAGE = 'https://github.com/esquilo-azul/redmine_events_manager'
+  SUMMARY = 'Management for events'
+  VERSION = '0.4.8'
+end

data/lib/tasks/events.rake

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+namespace :events_manager do
+  namespace :events do
+    namespace :issue_relation do
+      desc 'Envia notificações da criação de um IssueRelation'
+      task :create, [:issue_relation_id] => :environment do |_t, args|
+        EventsManager.trigger(
+          IssueRelation,
+          :create,
+          IssueRelation.find(args.issue_relation_id)
+        )
+      end
+    end
+    namespace :issue do
+      desc 'Envia notificações da criação de um Issue'
+      task :create, [:issue_id] => :environment do |_t, args|
+        EventsManager.trigger(
+          Issue,
+          :create,
+          Issue.find(args.issue_id)
+        )
+      end
+
+      desc 'Envia notificações da alteração de um Issue'
+      task :update, [:journal_id] => :environment do |_t, args|
+        EventsManager.trigger(
+          Issue,
+          :update,
+          Journal.find(args.journal_id)
+        )
+      end
+    end
+    namespace :repository do
+      desc 'Ativa evento de recebimento de conteúdo por repositório'
+      task :receive, [:repository_id] => :environment do |_t, args|
+        EventsManager.delay_disabled = true
+        EventsManager.trigger(
+          Repository,
+          :receive,
+          Repository.find(args.repository_id)
+        )
+      end
+    end
+  end
+end

data/lib/tasks/redmine_events_manager.rake

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'redmine_plugins_helper/plugin_rake_task'
+::RedminePluginsHelper::PluginRakeTask.register(:redmine_events_manager, :test)

data/redmine_events_manager.gemspec

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+# Maintain your gem's version:
+require 'redmine_events_manager/version'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = 'redmine_events_manager'
+  s.version     = ::RedmineEventsManager::VERSION
+  s.authors     = [::RedmineEventsManager::AUTHOR]
+  s.summary     = ::RedmineEventsManager::SUMMARY
+  s.homepage    = ::RedmineEventsManager::HOMEPAGE
+
+  s.require_paths = ['lib']
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files spec test`.split("\n")
+
+  s.add_dependency 'delayed_job_active_record'
+
+  # Test/development gems
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.1', '>= 0.1.2'
+end

data/spec/controllers/event_exceptions_controller_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.describe EventExceptionsController, type: :feature do
+  include_context 'with logged user', 'admin' do
+    before do
+      EventsManager::Settings.event_exception_unchecked = true
+    end
+
+    it { expect(EventsManager::Settings.event_exception_unchecked).to be_truthy }
+    it { expect(::User.current.login).to eq('admin') }
+
+    context 'when index is accessed' do
+      before { visit '/event_exceptions' }
+
+      it { expect(EventsManager::Settings.event_exception_unchecked).to be_falsy }
+    end
+  end
+end

data/spec/lib/events_manager_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe(::EventsManager) do
+  let(:stub_entity_class) { ::Class.new }
+  let(:stub_listener_class) { ::Class.new }
+
+  before do
+    described_class.add_listener(stub_entity_class, 'create', stub_listener_class)
+    described_class.add_listener(stub_entity_class, 'update', stub_listener_class)
+  end
+
+  it { expect(described_class.all_listeners).to be_a(Array) }
+  it { expect(described_class.all_listeners.count).to be_positive }
+  it { expect(described_class.all_listeners).to(be_all { |l| l.is_a?(::String) }) }
+  it { expect(described_class.all_listeners.count).to eq(described_class.all_listeners.uniq.count) }
+end

data/spec/models/event_exception_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+class DummyListener
+  def initialize(event)
+    @event = event
+  end
+
+  def to_s
+    'dummy_listener_instance'
+  end
+
+  def run
+    raise 'Dummy failed!' if @event.data.failed
+  end
+end
+
+class DummyEntity
+  attr_reader :failed
+
+  def initialize(failed)
+    @failed = failed
+  end
+
+  def to_s
+    "dummy_entity_instance_#{failed}"
+  end
+
+  def id
+    1
+  end
+end
+
+RSpec.describe EventException do
+  let(:event_exception_count_start) { described_class.count }
+
+  before do
+    EventsManager.log_exceptions_disabled = false
+    event_exception_count_start
+    EventsManager.add_listener(DummyEntity, :create, 'DummyListener')
+  end
+
+  context 'when event triggered is successful' do
+    before do
+      EventsManager.trigger(DummyEntity, :create, DummyEntity.new(false))
+    end
+
+    it 'successful event should not generate event exception' do
+      expect(described_class.count).to eq(event_exception_count_start)
+    end
+
+    it { expect(EventsManager::Settings.event_exception_unchecked).to be_falsy }
+  end
+
+  context 'when event triggered is fail' do
+    let(:ee) { described_class.last }
+
+    before do
+      EventsManager.trigger(DummyEntity, :create, DummyEntity.new(true))
+    end
+
+    it 'failed event should generate event exception' do
+      expect(described_class.count).to eq(event_exception_count_start + 1)
+    end
+
+    it { expect(ee).to be_truthy }
+    it { expect(ee.event_entity).to eq('DummyEntity') }
+    it { expect(ee.event_action).to eq('create') }
+    it { expect(ee.event_data).to eq(<<~DATA_CONTENT) }
+      --- !ruby/object:DummyEntity
+      failed: true
+    DATA_CONTENT
+    it { expect(ee.listener_class).to eq('DummyListener') }
+    it { expect(ee.listener_instance).to eq('dummy_listener_instance') }
+    it { expect(ee.exception_class).to eq('RuntimeError') }
+    it { expect(ee.exception_message).to eq('Dummy failed!') }
+    it { expect(ee.exception_stack).to be_present }
+    it { expect(EventsManager::Settings.event_exception_unchecked).to be_truthy }
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: redmine_events_manager
+version: !ruby/object:Gem::Version
+  version: 0.4.8
+platform: ruby
+authors:
+- Eduardo Henrique Bogoni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: delayed_job_active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eac_ruby_gem_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".avm.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- SelfGemfile
+- app/controllers/event_exceptions_controller.rb
+- app/controllers/listener_options_controller.rb
+- app/models/event_exception.rb
+- app/models/listener_option.rb
+- assets/stylesheets/application.css
+- bin/bundle
+- config/initializers/000_dependencies.rb
+- config/initializers/assets.rb
+- config/locales/pt-BR.yml
+- config/routes.rb
+- db/migrate/20160509152749_create_delayed_jobs.rb
+- db/migrate/20160717222418_create_event_exceptions.rb
+- db/migrate/20180331122033_create_listener_options.rb
+- db/migrate/20180419202618_add_enabled_to_listener_options.rb
+- db/migrate/20180711170315_rename_plugin_events_manager_to_redmine_events_manager.rb
+- init.rb
+- lib/events_manager.rb
+- lib/events_manager/event.rb
+- lib/events_manager/hooks/add_assets.rb
+- lib/events_manager/patches/issue_patch.rb
+- lib/events_manager/patches/issue_relation_patch.rb
+- lib/events_manager/patches/journal_patch.rb
+- lib/events_manager/patches/repository/git_patch.rb
+- lib/events_manager/patches/test_case_patch.rb
+- lib/events_manager/patches/time_entry_patch.rb
+- lib/events_manager/removed_record.rb
+- lib/events_manager/settings.rb
+- lib/events_manager/updated_record.rb
+- lib/redmine_events_manager/test_config.rb
+- lib/redmine_events_manager/version.rb
+- lib/tasks/events.rake
+- lib/tasks/redmine_events_manager.rake
+- redmine_events_manager.gemspec
+- spec/controllers/event_exceptions_controller_spec.rb
+- spec/lib/events_manager_spec.rb
+- spec/models/event_exception_spec.rb
+homepage: https://github.com/esquilo-azul/redmine_events_manager
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Management for events
+test_files:
+- spec/controllers/event_exceptions_controller_spec.rb
+- spec/lib/events_manager_spec.rb
+- spec/models/event_exception_spec.rb