decidim-spam_signal 0.3.1

data/app/commands/decidim/spam_signal/admin/update_rule_command.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Admin
+      class UpdateRuleCommand < Decidim::SpamSignal::Command
+        attr_reader :form,
+                    :current_config,
+                    :settings_repo,
+                    :id
+
+        def initialize(config, settings_repo, form, id)
+          @current_config = config
+          @settings_repo = settings_repo
+          @form = form
+          @id = id
+          raise ArgumentError, "missing current_config" unless current_config
+          raise ArgumentError, "missing settings_repo" unless settings_repo
+        end
+
+        def call
+          return broadcast(:invalid) if form.invalid?
+          begin
+            rule = {}
+            rule["#{id}"] = attributes
+            rule["#{id}"]["handler_name"] = form.handler_name
+            settings_repo.set_rule(rule)
+            current_config.save_settings
+            broadcast(:ok, settings_repo)
+          rescue StandardError => e
+            broadcast(:invalid, e.message)
+          end
+        end
+
+        private
+
+          def form_blank?(form)
+            return true if form.nil?
+            attributes.blank?
+          end
+          def attributes
+            form.attributes.stringify_keys!
+          end
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/admin/update_scanner_command.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Admin
+      class UpdateScannerCommand < Decidim::SpamSignal::Command
+        attr_reader :form,
+                    :current_config,
+                    :settings_repo
+
+        def initialize(config, settings_repo, form)
+          @current_config = config
+          @settings_repo = settings_repo
+          @form = form
+          raise ArgumentError, "missing current_config" unless current_config
+          raise ArgumentError, "missing settings_repo" unless settings_repo
+        end
+
+        def call
+          return broadcast(:invalid) if form.invalid?
+          return broadcast(:invalid) if attributes.blank?
+
+          begin
+            settings_repo.set_scan(
+              form.handler_name,
+              attributes
+            )
+            current_config.save_settings
+            broadcast(:ok, settings_repo)
+          rescue StandardError => e
+            broadcast(:invalid, e.message)
+          end
+        end
+
+        private
+
+          def form_blank?(form)
+            return true if form.nil?
+            attributes.blank?
+          end
+          def attributes
+            form.attributes.stringify_keys!
+          end
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/application_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    class ApplicationHandler < Decidim::SpamSignal::Command
+      def self.form
+        raise Error, "Handler need to define a form or return null"
+      end
+
+      def self.handler_name
+        name.demodulize.underscore.sub(/(_cop|_scan)(_form|_command)/, "")
+      end
+
+      def handler_name
+        self.class.handler_name
+      end
+
+      def self.i18n_key
+        raise Error, "Not Implemented"
+      end
+
+      def config
+        raise Error, "Not Implemented"
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    # maintains compatibility with v0.26 which uses Rectify
+    if defined? ::Decidim::Command
+      class Command < ::Decidim::Command
+      end
+    else
+      class Command < ::Rectify::Command
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/cops/cop_handler.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Cops
+      class CopHandler < ApplicationHandler
+        attr_reader :errors, :error_key, :suspicious_user, :justification, :admin_reporter, :config, :reportable, :current_organization
+
+        def initialize(
+          errors:,
+          error_key: :base,
+          suspicious_user:,
+          config:,
+          reportable: nil,
+          justification: nil,
+          admin_reporter: nil
+        )
+          @errors = errors
+          @error_key = error_key
+          @reportable = reportable || suspicious_user
+          @suspicious_user = suspicious_user
+          @current_organization = suspicious_user.organization
+
+          @config = config
+          @justification = justification
+          @admin_reporter = admin_reporter || CopBot.get(suspicious_user.organization)
+        end
+
+        def self.i18n_key
+          "decidim.spam_signal.cops.#{handler_name}"
+        end
+        def now_tag
+          "\n[#{DateTime.now.strftime("%d/%m/%Y %H:%M")}]"
+        end
+        def sinalize!(send_emails=true)
+          is_user_reported = reportable == suspicious_user
+          if is_user_reported
+            moderation = Decidim::UserModeration.find_or_create_by!(user: suspicious_user) do |moderation|
+              moderation.report_count = 0
+            end
+          else
+            moderation = Decidim::Moderation.find_or_create_by!(reportable: reportable, participatory_space: reportable.participatory_space) do |moderation|
+              moderation.report_count = 0
+            end
+          end
+          is_new = moderation.report_count == 0
+          moderation.update(report_count: moderation.report_count + 1)
+          if is_user_reported
+            user_report = Decidim::UserReport.find_or_create_by!(moderation: moderation)  do |report|
+              report.moderation = moderation
+              report.user = admin_reporter
+              report.reason = "spam"
+              report.details = "#{now_tag}#{justification}"
+            end
+          else
+            user_report = Decidim::Report.find_or_create_by!(moderation: moderation)  do |report|
+              report.moderation = moderation
+              report.user = admin_reporter
+              report.reason = "spam"
+              report.details = "#{now_tag}#{justification}"
+            end
+          end
+          # append the new bad things (to have a log).
+          user_report.update(details: "#{user_report.details}#{now_tag} #{justification}") unless is_new
+          admin_accountable = Decidim::User.where(admin: true, email: ENV.fetch("ANTISPAM_ADMIN", "antispam@example.org")).first
+          Decidim::UserReportJob.perform_later(admin, admin_reporter, "spam", reportable)
+        end
+
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/cops/lock_cop_command.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Cops
+      class LockCopCommand < CopHandler
+        def self.form
+          ::Decidim::SpamSignal::Cops::LockSettingsForm
+        end
+
+        def call
+          errors.add(
+            error_key,
+            I18n.t("errors.spam",
+              scope: "decidim.spam_signal",
+              default: "this looks like spam."
+            )
+          ) unless config['forbid_creation_enabled']
+          unless suspicious_user.access_locked?
+            hide_comment! if config["hide_comments_enabled"]
+            sinalize! if config["sinalize_user_enabled"]
+            lock!
+          end
+          broadcast(config['forbid_creation_enabled'] ? :restore_value : :save)
+        end
+
+        private
+          def hide_comment!
+            suspicious_comments = Decidim::Comments::Comment.where(author: suspicious_user)
+            suspicious_comments.each do |spam|
+              moderation = Decidim::Moderation.find_or_create_by!(
+                reportable: spam,
+                participatory_space: spam.participatory_space
+              )
+              is_new = moderation.report_count == 0
+              moderation.update(reported_content: spam.body[admin_reporter.locale]) if !moderation.reported_content && spam.body[admin_reporter.locale]
+              report = Decidim::Report.find_or_create_by!(
+                moderation: moderation.reload,
+                user: admin_reporter) do |report|
+                  report.locale = admin_reporter.locale
+                  report.reason = "spam"
+                  report.details = "#{now_tag}cascade: #{spam}"
+              end
+              report.update(details: "#{report.details}#{now_tag}cascade: #{spam}")unless is_new
+              moderation.update!(report_count: moderation.report_count + 1, hidden_at: Time.current)
+            end
+          end
+
+          def lock!
+            suspicious_user.lock_access!(
+              send_instructions: true
+            )
+            suspicious_user.save!(validate: false)
+          end
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/cops/sinalize_cop_command.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Cops
+      class SinalizeCopCommand < CopHandler
+        def self.form
+          ::Decidim::SpamSignal::Cops::SinalizeSettingsForm
+        end
+
+        def call
+          errors.add(
+            error_key,
+            I18n.t("errors.spam",
+              scope: "decidim.spam_signal",
+              default: "this looks like spam."
+            )
+          ) if config['forbid_creation_enabled']
+          sinalize!(config['send_emails_enabled'])
+          broadcast(config['forbid_creation_enabled'] ? :restore_value : :save)
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/scans/allowed_tlds_scan_command.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Scans
+      class AllowedTldsScanCommand < ScanHandler
+        def self.form
+          ::Decidim::SpamSignal::Scans::AllowedTldsForm
+        end
+
+        def call
+          return broadcast(:ok) if allowed_tlds_csv.empty?
+          return broadcast(:ok) if all_allowed?
+          broadcast(:not_allowed_tlds_found)
+        end
+
+        def self.output_symbols
+          [:not_allowed_tlds_found]
+        end
+
+        private
+
+          def allowed_tlds_csv
+            @allowed_tlds_csv ||= (
+              config["allowed_tlds_csv"] || ""
+            ).split(",").map(&:strip).filter { |tlds| !tlds.empty? }
+          end
+
+          def all_allowed?
+            hosts.filter { |url| !allowed_tlds_csv.any? { |tld| url.include? tld } }.empty?
+          end
+
+          def hosts
+            URI.extract(suspicious_content, ["http", "https", "", "mailto" ]).map do |uri|
+              begin
+                (scheme, subdomain, host) = URI.split(uri)
+                host || ""
+              rescue URI::InvalidURIError
+                ""
+              end
+            end
+          end
+
+          def regex(patterns)
+            Regexp.union(patterns).source
+          end
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/scans/forbidden_tlds_scan_command.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Scans
+      class ForbiddenTldsScanCommand < ScanHandler
+        def self.form
+          ::Decidim::SpamSignal::Scans::ForbiddenTldsForm
+        end
+
+        def call
+          return broadcast(:forbidden_tlds_found) if any_forbidden_tlds?
+          broadcast(:ok)
+        end
+
+        def self.output_symbols
+          [:forbidden_tlds_found]
+        end
+
+        private
+
+          def forbidden_tlds_csv
+            @forbidden_tlds_csv ||= (
+              config["forbidden_tlds_csv"] || ""
+            ).split(",").map(&:strip)
+          end
+
+          def any_forbidden_tlds?
+            hosts.filter { |url| forbidden_tlds_csv.any? { |tld| url.include? tld } }.present?
+          end
+
+          def hosts
+            URI.extract(suspicious_content, ["http", "https", "", "mailto" ]).map do |uri|
+              begin
+                (scheme, subdomain, host) = URI.split(uri)
+                host
+              rescue URI::InvalidURIError
+                ""
+              end
+            end
+          end
+
+          def regex(patterns)
+            Regexp.union(patterns).source
+          end
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/scans/scan_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Scans
+      class ScanHandler < ApplicationHandler
+        attr_reader :suspicious_content, :config
+
+        def initialize(suspicious_content, config)
+          @suspicious_content = suspicious_content
+          @config = config
+        end
+
+        def self.i18n_key
+          "decidim.spam_signal.scans.#{handler_name}"
+        end
+
+        def self.output_symbols
+          []
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/spam_signal/scans/word_scan_command.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Scans
+      class WordScanCommand < ScanHandler
+        def self.form
+          ::Decidim::SpamSignal::Scans::WordSettingsForm
+        end
+
+        def call
+          return broadcast(:ok) if suspicious_content.empty?
+          return broadcast(:word_found) if contains_stop_words?
+          broadcast(:ok)
+        end
+
+        def self.output_symbols
+          [:word_found]
+        end
+
+        private
+          def contains_stop_words?
+            @contains_stop_words ||= suspicious_content.match(
+              /#{regex(stop_list_words)}/i
+            ).to_s.present?
+          end
+
+          def regex(patterns)
+            Regexp.union(patterns).source
+          end
+
+          def stop_list_words
+            @stop_list_words ||= (
+              config["stop_list_words_csv"] || ""
+            ).split("\n").map(&:strip)
+          end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/user_blocked_checker.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module UserBlockedChecker
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :check_user_not_blocked
+      around_action :store_request_metadata
+    end
+
+    def store_request_metadata
+      Thread.current[:current_request] = ::ActiveSupport::HashWithIndifferentAccess.new(
+        real_ip: request.ip || request.headers['X-Real-IP'],
+        user_agent: request.headers['User-Agent'],
+        xhr: request.xhr?,
+        id: request.request_id,
+        remote_ip: request.remote_ip,
+        referrer: request.headers['Refer'],
+        country: request.headers['X-GEO-COUNTRY-CODE']
+      )
+      yield
+      ensure
+        Thread.current[:current_request] = nil
+    end
+
+    def check_user_not_blocked
+      check_user_block_status(current_user)
+    end
+
+    def check_user_block_status(user)
+      if user.present? && user.blocked?
+        sign_out user
+        flash.delete(:notice)
+        flash[:error] = t("decidim.account.blocked")
+        root_path
+      end
+      if user.present? && user.access_locked?
+        sign_out user
+        flash.delete(:notice)
+        flash[:error] = t("decidim.account.locked")
+        root_path
+      end
+    end
+  end
+end

data/app/controllers/decidim/spam_signal/admin/application_controller.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Admin
+      # This controller is the abstract class from which all other controllers of
+      # this engine inherit.
+      #
+      # Note that it inherits from `Decidim::Admin::Components::BaseController`, which
+      # override its layout and provide all kinds of useful methods.
+      class ApplicationController < Decidim::Admin::ApplicationController
+        before_action do
+          enforce_permission_to :update, :organization, organization: current_organization
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/spam_signal/admin/application_cops_controller.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Decidim
+  module SpamSignal
+    module Admin
+      class ApplicationCopsController < ApplicationController
+        include FormFactory
+        before_action :config
+        helper Decidim::SpamSignal::Admin::SpamSignalHelper
+        helper_method :cop_type, :available_cops, :current_config, :current_cop
+        def index
+          output_symbols = scan_repository.strategies.map do |scan_name|
+            scanKlass = scan_repository.strategy(scan_name)
+            scanKlass.output_symbols
+          end.flatten
+        end
+
+        def destroy
+          raise "Missing id" unless cop_type
+          RemoveCopCommand.call(
+            current_config,
+            resource_config,
+            cop_type
+          ) do |on|
+            on(:invalid) { flash[:alert] = "Can not remove the agent" }
+            on(:ok) { flash[:notice] = "Remove has been removed"  }
+            redirect_to spam_filter_reports_path
+          end
+        end
+
+        def update
+          raise "No agent found" unless current_cop
+          form = current_cop.form.from_params(params.require("#{cop_key}")).with_context(
+            handler_name: current_cop.handler_name,
+            type: cop_type
+          )
+          UpdateCopCommand.call(
+            current_config,
+            resource_config,
+            form
+          ) do |on|
+            on(:invalid) { flash[:alert] = "Can not update the agent" }
+            on(:ok) { flash[:notice] = "Agent has been updated"  }
+            redirect_to spam_filter_reports_path
+          end
+        end
+
+        def edit
+          @form = nil
+          if current_cop && current_cop.form
+            @form = current_cop.form.new(
+              **(resource_config.cop_options(current_cop.handler_name, cop_type) || {})
+            ).with_context(
+              config: current_config,
+              handler_name: current_cop.handler_name
+            )
+          elsif current_cop
+            @form = Decidim::SpamSignal::NoSettingsForm.new.with_context(
+              config: current_config,
+              handler_name: current_cop.handler_name
+            )
+          end
+        end
+
+        def create
+          raise "No scanner found" unless current_cop
+          form = current_cop.form.from_params(
+            params.require("#{cop_type}".to_sym)
+          ).with_context(
+            handler_name: current_cop.handler_name,
+            type: cop_type
+          )
+          AddScannerCommand.call(
+            current_config,
+            resource_config,
+            form
+          ) do |on|
+            on(:invalid) { flash[:alert] = "Can not create the agent" }
+            on(:ok) { flash[:notice] = "Agent has been created"  }
+            redirect_to spam_filter_reports_path
+          end
+        end
+
+        def resource_config
+          raise Error, "Not implemented"
+        end
+        private
+          def available_cops
+            cop_repository.strategies.map do |cop, copKlass|
+              cop_repository.strategy cop
+            end
+          end
+
+          def cop_repository
+            Decidim::SpamSignal::Cops::CopsRepository.instance
+          end
+
+          def current_settings
+            resource_config
+          end
+          def cop_type
+            params.permit(:id)["id"] || nil
+          end
+          def cop_key
+            params.permit(:cop)["cop"] || nil
+          end
+
+          def current_cop
+            return nil unless cop_type && cop_key
+            cop_repository.strategy(cop_key)
+          end
+
+          def current_config
+            @current_config ||= Decidim::SpamSignal::Config.where(
+              id: params.require(:config_id),
+              organization: current_organization
+            ).first!
+          end
+      end
+    end
+  end
+end