source_monitor 0.2.0 → 0.3.0

data/app/controllers/source_monitor/import_sessions/entry_annotation.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  module ImportSessions
+    module EntryAnnotation
+      extend ActiveSupport::Concern
+
+      private
+
+      def annotated_entries(selected_ids)
+        selected_ids ||= []
+        entries = Array(@import_session.parsed_sources)
+        return [] if entries.blank?
+
+        normalized = entries.map { |entry| normalize_entry(entry) }
+
+        feed_urls = normalized.filter_map { |entry| entry[:feed_url]&.downcase }
+        duplicate_lookup = if feed_urls.present?
+          SourceMonitor::Source.where("LOWER(feed_url) IN (?)", feed_urls).pluck(:feed_url).map(&:downcase)
+        else
+          []
+        end
+
+        normalized.map do |entry|
+          duplicate = entry[:feed_url].present? && duplicate_lookup.include?(entry[:feed_url].downcase)
+          entry.merge(
+            duplicate: duplicate,
+            selectable: entry[:status] == "valid" && !duplicate,
+            selected: selected_ids.include?(entry[:id])
+          )
+        end
+      end
+
+      def normalize_entry(entry)
+        entry = entry.to_h
+        SourceMonitor::ImportSessions::EntryNormalizer.normalize(entry)
+      end
+
+      def filter_entries(entries, filter)
+        case filter
+        when "new"
+          entries.select { |entry| entry[:selectable] }
+        when "existing"
+          entries.select { |entry| entry[:duplicate] }
+        else
+          entries
+        end
+      end
+
+      def selectable_entries_from(entries)
+        entries.select { |entry| entry[:selectable] }
+      end
+
+      def selectable_entries
+        @selectable_entries ||= annotated_entries(@selected_source_ids).select { |entry| entry[:selectable] }
+      end
+
+      def build_selection_from_params
+        @selected_source_ids ||= []
+
+        if params.dig(:import_session, :select_all) == "true"
+          return selectable_entries.map { |entry| entry[:id] }
+        end
+
+        if params.dig(:import_session, :select_none) == "true"
+          return []
+        end
+
+        ids = params.dig(:import_session, :selected_source_ids)
+        return [] unless ids
+
+        Array(ids).map { |id| id.to_s }.uniq
+      end
+
+      def health_check_selection_from_params
+        if params.dig(:import_session, :select_all) == "true"
+          return health_check_targets.dup
+        end
+
+        return [] if params.dig(:import_session, :select_none) == "true"
+
+        ids = params.dig(:import_session, :selected_source_ids)
+        return Array(@import_session.selected_source_ids).map(&:to_s) unless ids
+
+        Array(ids).map { |id| id.to_s }.uniq & health_check_targets
+      end
+
+      def advancing_from_health_check?
+        target_step != "health_check"
+      end
+
+      def advancing_from_preview?
+        target_step != "preview"
+      end
+
+      def normalize_page_param(value)
+        number = value.to_i
+        number = 1 if number <= 0
+        number
+      rescue StandardError
+        1
+      end
+
+      def permitted_filter(raw)
+        value = raw.to_s.presence
+        return unless value
+
+        %w[all new existing].find { |candidate| candidate == value }
+      end
+
+      def preview_per_page
+        25
+      end
+
+      def state_params
+        @state_params ||= begin
+          permitted = params.fetch(:import_session, {}).permit(
+            :current_step,
+            :next_step,
+            :select_all,
+            :select_none,
+            parsed_sources: [],
+            selected_source_ids: [],
+            bulk_settings: {},
+            opml_file_metadata: {}
+          )
+
+          SourceMonitor::Security::ParameterSanitizer.sanitize(permitted.to_h)
+        end
+      end
+
+      def permitted_step(value)
+        step = value.to_s.presence
+        return unless step
+
+        ImportSession::STEP_ORDER.find { |candidate| candidate == step }
+      end
+
+      def target_step
+        next_step = state_params[:next_step] || state_params["next_step"]
+        permitted_step(next_step) || @current_step || ImportSession.default_step
+      end
+
+      def session_attributes
+        attrs = state_params.except(:next_step, :current_step, "next_step", "current_step")
+        attrs[:opml_file_metadata] = build_file_metadata if uploading_file?
+        attrs[:current_step] = target_step
+        attrs
+      end
+
+      def prepare_preview_context(skip_default: false)
+        @filter = permitted_filter(params[:filter]) || "all"
+        @page = normalize_page_param(params[:page])
+        @selected_source_ids = Array(@import_session.selected_source_ids).map(&:to_s)
+
+        @preview_entries = annotated_entries(@selected_source_ids)
+
+        if !skip_default && @selected_source_ids.blank? && @preview_entries.present?
+          defaults = selectable_entries_from(@preview_entries).map { |entry| entry[:id] }
+          @selected_source_ids = defaults
+          @import_session.update_column(:selected_source_ids, defaults)
+          @preview_entries = annotated_entries(@selected_source_ids)
+        end
+
+        @filtered_entries = filter_entries(@preview_entries, @filter)
+
+        paginator = SourceMonitor::Pagination::Paginator.new(
+          scope: @filtered_entries,
+          page: @page,
+          per_page: preview_per_page
+        ).paginate
+
+        @paginated_entries = paginator.records
+        @has_next_page = paginator.has_next_page
+        @has_previous_page = paginator.has_previous_page
+        @page = paginator.page
+      end
+
+      def prepare_confirm_context
+        @selected_source_ids = Array(@import_session.selected_source_ids).map(&:to_s)
+        @selected_entries = annotated_entries(@selected_source_ids)
+          .select { |entry| @selected_source_ids.include?(entry[:id]) }
+        @bulk_settings = @import_session.bulk_settings || {}
+      end
+    end
+  end
+end

data/app/controllers/source_monitor/import_sessions/health_check_management.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  module ImportSessions
+    module HealthCheckManagement
+      extend ActiveSupport::Concern
+
+      private
+
+      def start_health_checks_if_needed
+        return unless @current_step == "health_check"
+
+        jobs_to_enqueue = []
+
+        @import_session.with_lock do
+          @import_session.reload
+          selected = Array(@import_session.selected_source_ids).map(&:to_s)
+
+          if selected.blank?
+            @import_session.update_columns(health_checks_active: false, health_check_target_ids: [])
+            next
+          end
+
+          if @import_session.health_checks_active? && @import_session.health_check_targets.sort == selected.sort
+            @health_check_target_ids = @import_session.health_check_targets
+            next
+          end
+
+          updated_entries = reset_health_results(@import_session.parsed_sources, selected)
+          @import_session.update!(
+            parsed_sources: updated_entries,
+            health_checks_active: true,
+            health_check_target_ids: selected,
+            health_check_started_at: Time.current,
+            health_check_completed_at: nil
+          )
+
+          @health_check_target_ids = selected
+          jobs_to_enqueue = selected
+        end
+
+        enqueue_health_check_jobs(@import_session, jobs_to_enqueue) if jobs_to_enqueue.any?
+      end
+
+      def reset_health_results(entries, target_ids)
+        Array(entries).map do |entry|
+          entry_hash = entry.to_h
+          entry_id = entry_hash["id"] || entry_hash[:id]
+          next entry_hash unless target_ids.include?(entry_id.to_s)
+
+          entry_hash.merge("health_status" => "pending", "health_error" => nil)
+        end
+      end
+
+      def enqueue_health_check_jobs(import_session, target_ids)
+        target_ids.each do |target_id|
+          SourceMonitor::ImportSessionHealthCheckJob.set(wait: 1.second).perform_later(import_session.id, target_id)
+        end
+      end
+
+      def deactivate_health_checks!
+        return unless @import_session.health_checks_active?
+
+        @import_session.update_columns(
+          health_checks_active: false,
+          health_check_completed_at: Time.current
+        )
+      end
+
+      def health_check_entries(selected_ids)
+        targets = health_check_targets
+        entries = Array(@import_session.parsed_sources).map { |entry| normalize_entry(entry) }
+
+        entries.select { |entry| targets.include?(entry[:id]) }.map do |entry|
+          entry.merge(selected: selected_ids.include?(entry[:id]))
+        end
+      end
+
+      def health_check_progress(entries)
+        total = health_check_targets.size
+        completed = entries.count { |entry| health_check_complete?(entry) }
+
+        {
+          completed: completed,
+          total: total,
+          pending: [ total - completed, 0 ].max,
+          active: @import_session.health_checks_active?,
+          done: total.positive? && completed >= total
+        }
+      end
+
+      def health_check_complete?(entry)
+        %w[healthy unhealthy].include?(entry[:health_status].to_s)
+      end
+
+      def health_check_targets
+        targets = @import_session.health_check_targets
+        targets = Array(@import_session.selected_source_ids).map(&:to_s) if targets.blank?
+        targets
+      end
+
+      def prepare_health_check_context
+        start_health_checks_if_needed
+
+        @selected_source_ids = Array(@import_session.selected_source_ids).map(&:to_s)
+        @health_check_entries = health_check_entries(@selected_source_ids)
+        @health_check_target_ids = health_check_targets
+        @health_progress = health_check_progress(@health_check_entries)
+      end
+    end
+  end
+end

data/app/controllers/source_monitor/import_sessions/opml_parser.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  module ImportSessions
+    module OpmlParser
+      extend ActiveSupport::Concern
+
+      ALLOWED_CONTENT_TYPES = %w[text/xml application/xml text/x-opml application/opml].freeze
+      GENERIC_CONTENT_TYPES = %w[application/octet-stream binary/octet-stream].freeze
+
+      class UploadError < StandardError; end
+
+      private
+
+      def build_file_metadata
+        return {} unless params[:opml_file].respond_to?(:original_filename)
+
+        file = params[:opml_file]
+        {
+          "filename" => file.original_filename,
+          "byte_size" => file.size,
+          "content_type" => file.content_type
+        }
+      end
+
+      def uploading_file?
+        params[:opml_file].present?
+      end
+
+      def validate_upload!
+        return [ "Upload an OPML file to continue." ] unless uploading_file?
+
+        file = params[:opml_file]
+        errors = []
+
+        errors << "The uploaded file is empty. Choose another OPML file." if file.size.to_i <= 0
+
+        if file.content_type.present? && !content_type_allowed?(file.content_type) && !generic_content_type?(file.content_type)
+          errors << "Upload must be an OPML or XML file."
+        end
+
+        errors
+      end
+
+      def content_type_allowed?(content_type)
+        ALLOWED_CONTENT_TYPES.include?(content_type)
+      end
+
+      def generic_content_type?(content_type)
+        GENERIC_CONTENT_TYPES.include?(content_type)
+      end
+
+      def parse_opml_file(file)
+        content = file.read
+        file.rewind if file.respond_to?(:rewind)
+
+        raise UploadError, "The uploaded file appears to be empty." if content.blank?
+
+        document = Nokogiri::XML(content) { |config| config.strict.nonet }
+        raise UploadError, "The uploaded file is not valid XML or OPML." if document.root.nil?
+
+        outlines = document.xpath("//outline")
+
+        entries = []
+
+        outlines.each_with_index do |outline, index|
+          next unless outline.attribute_nodes.any? { |attr| attr.name.casecmp("xmlurl").zero? }
+
+          entries << build_entry(outline, index)
+        end
+
+        entries
+      rescue Nokogiri::XML::SyntaxError => error
+        raise UploadError, "We couldn't parse that OPML file: #{error.message}"
+      end
+
+      def build_entry(outline, index)
+        feed_url = outline_attribute(outline, "xmlUrl")
+        website_url = outline_attribute(outline, "htmlUrl")
+        title = outline_attribute(outline, "title") || outline_attribute(outline, "text")
+
+        if feed_url.blank?
+          return malformed_entry(index, feed_url, title, website_url, "Missing feed URL")
+        end
+
+        unless valid_feed_url?(feed_url)
+          return malformed_entry(index, feed_url, title, website_url, "Feed URL must be HTTP or HTTPS")
+        end
+
+        {
+          id: "outline-#{index}",
+          raw_outline_index: index,
+          feed_url: feed_url,
+          title: title,
+          website_url: website_url,
+          status: "valid",
+          error: nil,
+          health_status: nil,
+          health_error: nil
+        }
+      end
+
+      def malformed_entry(index, feed_url, title, website_url, error)
+        {
+          id: "outline-#{index}",
+          raw_outline_index: index,
+          feed_url: feed_url.presence,
+          title: title,
+          website_url: website_url,
+          status: "malformed",
+          error: error,
+          health_status: nil,
+          health_error: nil
+        }
+      end
+
+      def outline_attribute(outline, name)
+        attribute = outline.attribute_nodes.find { |attr| attr.name.casecmp(name).zero? }
+        attribute&.value.to_s.presence
+      end
+
+      def valid_feed_url?(url)
+        parsed = URI.parse(url)
+        parsed.is_a?(URI::HTTP) && parsed.host.present?
+      rescue URI::InvalidURIError
+        false
+      end
+    end
+  end
+end