snitch_reporting 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f36c08be1ea6ddb5163c77f6545cdf15d428fe924417659435f129371b111fb2
-  data.tar.gz: 782520924c3822bde5b12360862447bcdce9165cdadf8069206a35dea14ad25c
+  metadata.gz: 0360ae61e5fff96546f73c211a32e026f0c86e551d86a4ec56151fee0f16b55a
+  data.tar.gz: 3b11b38588632cd9bd5e214ac6e57626c836aebac9e007c3877b38709c7603e4
 SHA512:
-  metadata.gz: 9caebc02bbb9246c6296f40a0bb1b9b9adea201291fd9cd54cf83d5209ab4290a1a2ab82b5ae3b410881473bbbccf6015f6e1f22a9aa8046cb981423f90d246c
-  data.tar.gz: e5e6da918b33c4e2fcf40b80166e6507c902491da65f45db92c708205e6dcab74f6e3113064cd561b6b8dfb39b052b8a327e25f46decff74ad5149d162ddd253
+  metadata.gz: '0738cb273eb18dabd7a3d48baccfc5ee98bb2c039f1139cdadb39539d6eb572ccd8413dfb8dbb7d9e193021ddd78aa81346bd70d7fb1a9006ed7d8848f59045e'
+  data.tar.gz: 271b1f3fdb87d533c154c4b5d90e20acdf61681e670bb552f847ed5e407d77db95e74e564d59c296d7839969051cdae75fe25573ee402ef57fe7b0aaa9149319

data/app/controllers/snitch_reporting/snitch_reports_controller.rb

@@ -2,246 +2,169 @@ require_dependency "snitch_reporting/application_controller"
 
 class ::SnitchReporting::SnitchReportsController < ApplicationController
   include ::SnitchReporting::ParamsHelper
+  include ::SnitchReporting::SnitchReportHelper
   helper ::SnitchReporting::SnitchReportHelper
 
   layout "application"
 
-    def index
-      ::SnitchReporting::SnitchReport.warn("Error", some: :data)
-      @reports = ::SnitchReporting::SnitchReport.order("last_occurrence_at DESC NULLS LAST").page(params[:page]).per(params[:per] || 25)
-
-      # set_report_preferences
-      filter_reports
-      # sort_reports
-    end
-
-    def interpret_search
-      redirect_to snitch_reports_path(filter_string: params[:filter_string])
-    end
-
-    def show
-      @report = ::SnitchReporting::SnitchReport.find(params[:id])
-      occurrences = @report.occurrences.order(created_at: :asc)
-      @occurrence = occurrences.find_by(id: params[:occurrence]) || occurrences.last
-      occurrence_ids = occurrences.ids
-      occurrence_idx = occurrence_ids.index(@occurrence.id)
-      @paged_ids = {
-        first: occurrence_idx == 0 ? nil : occurrence_ids.first,
-        prev:  occurrence_idx == 0 ? nil : occurrence_ids[occurrence_idx - 1],
-        next:  occurrence_idx == occurrence_ids.length - 1 ? nil : occurrence_ids[occurrence_idx + 1],
-        last:  occurrence_idx == occurrence_ids.length - 1 ? nil : occurrence_ids.last,
-      }
-      # @formatted_occurrence_data = occurrences.staggered_occurrence_data
-      # @comments = @report.comments.order(created_at: :desc)
-    end
-
-
-    def update
-      @report = ::SnitchReporting::SnitchReport.find(params[:id])
-      # @report.acting_user = current_user
-      @report.update(report_params)
-
-      respond_to do |format|
-        format.html { redirect_to @report }
-        format.json
-      end
-    end
-  #
-  #   def comment
-  #     if @report.comments.create(comment_params.merge(author: current_credential).merge(params.permit(:resolved, :ignored)))
-  #       update_report_for(:resolved, comment: false)
-  #       update_report_for(:ignored, comment: false)
-  #
-  #       redirect_to snitch_report_path(@report)
-  #     else
-  #       redirect_to snitch_report_path(@report), alert: "Failed to comment. Please try again."
-  #     end
-  #   end
-  #
-    private
-
-    def report_params
-      params.require(:snitch_report).permit(
-        :ignored,
-        :resolved
-      )
-    end
-  #
-  #   def current_snitch_report
-  #     @report = SnitchReporting::SnitchReport.find(params[:id])
-  #   end
-  #
-  #   def update_report_for(status, comment: true)
-  #     raise "Value not allowed: #{status}" unless status.in?([:resolved, :ignored])
-  #
-  #     if true_param?(status)
-  #       @report.update("#{status}_at": Time.current, "#{status}_by": current_credential)
-  #       # @report.comments.create(author: current_credential, message: ">>> Marked as #{status} <<<", skip_notify: true, status => true) if comment
-  #     elsif params[status].present?
-  #       # @report.comments.create(author: current_credential, message: ">>> Marked as un#{status} <<<", skip_notify: true, status => false) if comment
-  #       @report.update("#{status}_at": nil, "#{status}_by": nil)
-  #     end
-  #   end
-  #
-  #   def report_params
-  #     params.require(:snitch_report).permit(
-  #       :source,
-  #       :severity,
-  #       :assigned_to_id,
-  #       :title,
-  #       :custom_details
-  #     )
-  #   end
-  #
-  #   def comment_params
-  #     params.require(:snitch_comment).permit(:message)
-  #   end
-  #
-  #   def set_report_preferences
-  #     @filters = begin
-  #       preferences = JSON.parse(session[:filters].presence || "{}").symbolize_keys
-  #
-  #       available_preferences = [:level_tags, :severity_tags, :source_tags, :resolved, :ignored]
-  #       available_preferences.each do |pref_key|
-  #         pref_val = params[pref_key]
-  #         preferences[pref_key] = pref_val if pref_val.present?
-  #         preferences.delete(pref_key) if pref_val == "all"
-  #       end
-  #
-  #       session[:filters] = preferences.to_json
-  #       preferences
-  #     end
-  #   end
-    def set_filters
-      @filter_sets = {
-        status: {
-          default: :unresolved,
-          values: [:all, :resolved, :unresolved]
-        },
-        # assignee: {
-        #   default: :any,
-        #   values: [:any, :me, :not_me, :not_assigned]
-        # },
-        log_level: {
-          default: :any,
-          values: [:any] + ::SnitchReporting::SnitchReport.log_levels.keys.map(&:to_sym)
-        },
-        # ignored: {
-        #   default: :not_ignored,
-        #   values: [:all, :ignored, :not_ignored]
-        # }
-      }
-
-      set_filter_string
-
-      # @filters = @filter_sets.each_with_object({set_filters: {}}) do |(filter_name, filter_set), filters|
-      #   filters[filter_name] = filter_set[:default]
-      #   filter_in_param = params[filter_name].try(:to_sym)
-      #   next unless filter_in_param && filter_set[:values].include?(filter_in_param)
-      #   filters[filter_name] = filter_in_param
-      #   filters[:set_filters][filter_name] = filter_in_param
-      # end
-    end
-
-    def filter_reports
-      set_filters
-
-      @reports = @reports.resolved if @filters[:status] == :resolved
-      @reports = @reports.unresolved if @filters[:status] == :unresolved
-      @reports = @reports.search(@filters[:search]) if @filters[:search].present?
-      @reports = @reports.by_level(@filters[:log_level]) if @filters[:log_level].present?
-
-      @reports = @reports.by_tag(*@filters[:tag]) if @filters[:tag].any?
-      # @reports = @reports.by_severity(@filters[:severity_tags]) if @filters[:severity_tags].present?
-      # @reports = @reports.by_source(@filters[:source_tags]) if @filters[:source_tags].present?
-      #
-      # @reports = @filters[:resolved].present? && truthy?(@filters[:resolved]) ? @reports.resolved : @reports.unresolved
-      # @reports = @filters[:ignored].present? && truthy?(@filters[:ignored]) ? @reports.ignored : @reports.unignored
-    end
-
-    def encode_string(token, str)
-      @interpolated_strings ||= []
-
-      @interpolated_strings << str
-      "#{token}(#{@interpolated_strings.length})"
-    end
-
-    def decode_string(token, encoded_str)
-      @interpolated_strings ||= []
-
-      encoded_str.gsub(/(\w+)\((\d+)\)/) do |found|
-        token = Regexp.last_match(1)
-        idx = Regexp.last_match(2)
-
-        if idx.to_i.to_s == idx
-          @interpolated_strings[idx.to_i - 1]
-        else
-          found
-        end
-      end
-    end
-
-    def param_safe_value(str)
-      return str unless str.include?(" ")
-
-      "\"#{str}\""
-    end
-
-    def set_filter_string
-      @filter_string = params[:filter_string] || session[:snitch_filter_string] || "status:unresolved"
-      @unknown_strings = []
-      @filters = {}
-
-      secret_key = loop do
-        token = SecureRandom.hex(10)
-        break token unless @filter_string.include?(token)
-      end
-
-      temp_filter_string = @filter_string.gsub(/\"(.*?)\"/) do |found|
-        encode_string(secret_key, Regexp.last_match(1))
-      end
-
-      search_strings = []
-      tag_strings = []
-      filter_strings = temp_filter_string.split(" ").select do |filter_string|
-        search_strings << filter_string unless filter_string.include?(":")
-        filter_string.include?(":")
-      end
-
-      filter_strings.each do |filter_string|
-        filter, value, * = filter_string.split(":")
-        if value.blank?
-          # Search pure text by itself
-          search_strings << value
-        elsif @filter_sets.keys.include?(filter.to_s.to_sym)
-          value = decode_string(secret_key, value)
-          @filters[filter.to_sym] = value.to_sym
-        elsif filter == "search"
-          search_strings << decode_string(secret_key, value)
-        elsif filter == "tag" || filter == "tags"
-          tag_strings << decode_string(secret_key, value)
-        else
-          @unknown_strings << filter_string
-        end
-      end
-
-      @filters[:search] = "\"#{search_strings.join(' ')}\"" if search_strings.any?
-      @filters[:tag] = tag_strings
-
-      new_filter_strings = @filters.each_with_object([]) do |(filter_string, filter_value), filter_array|
-        next unless filter_value.present?
-        if filter_value.is_a?(Array)
-          filter_value.each do |filter_value_i|
-            filter_array << "#{filter_string}:#{filter_value_i}"
-          end
-        else
-          filter_array << "#{filter_string}:#{filter_value}"
-        end
-      end
-
-      @filter_string = new_filter_strings.join(" ")
-      session[:snitch_filter_string] = @filter_string.dup
+  def index
+    ::SnitchReporting::SnitchReport.warn("Error", some: :data)
+    @reports = ::SnitchReporting::SnitchReport.order("last_occurrence_at DESC NULLS LAST").page(params[:page]).per(params[:per] || 25)
+
+    # set_report_preferences
+    filter_reports
+    # sort_reports
+  end
+
+  def interpret_search
+    redirect_to snitch_reports_path(filter_string: params[:filter_string])
+  end
+
+  def show
+    @report = ::SnitchReporting::SnitchReport.find(params[:id])
+    occurrences = @report.occurrences.order(created_at: :asc)
+    @occurrence = occurrences.find_by(id: params[:occurrence]) || occurrences.last
+    occurrence_ids = occurrences.ids
+    occurrence_idx = occurrence_ids.index(@occurrence.id)
+    @paged_ids = {
+      first: occurrence_idx == 0 ? nil : occurrence_ids.first,
+      prev:  occurrence_idx == 0 ? nil : occurrence_ids[occurrence_idx - 1],
+      next:  occurrence_idx == occurrence_ids.length - 1 ? nil : occurrence_ids[occurrence_idx + 1],
+      last:  occurrence_idx == occurrence_ids.length - 1 ? nil : occurrence_ids.last,
+    }
+    # @formatted_occurrence_data = occurrences.staggered_occurrence_data
+    # @comments = @report.comments.order(created_at: :desc)
+  end
+
+
+  def update
+    @report = ::SnitchReporting::SnitchReport.find(params[:id])
+    # @report.acting_user = current_user
+    @report.update(report_params)
+
+    respond_to do |format|
+      format.html { redirect_to @report }
+      format.json
     end
+  end
+#
+#   def comment
+#     if @report.comments.create(comment_params.merge(author: current_credential).merge(params.permit(:resolved, :ignored)))
+#       update_report_for(:resolved, comment: false)
+#       update_report_for(:ignored, comment: false)
+#
+#       redirect_to snitch_report_path(@report)
+#     else
+#       redirect_to snitch_report_path(@report), alert: "Failed to comment. Please try again."
+#     end
+#   end
+#
+  private
+
+  def report_params
+    params.require(:snitch_report).permit(
+      :ignored,
+      :resolved
+    )
+  end
+#
+#   def current_snitch_report
+#     @report = SnitchReporting::SnitchReport.find(params[:id])
+#   end
+#
+#   def update_report_for(status, comment: true)
+#     raise "Value not allowed: #{status}" unless status.in?([:resolved, :ignored])
+#
+#     if true_param?(status)
+#       @report.update("#{status}_at": Time.current, "#{status}_by": current_credential)
+#       # @report.comments.create(author: current_credential, message: ">>> Marked as #{status} <<<", skip_notify: true, status => true) if comment
+#     elsif params[status].present?
+#       # @report.comments.create(author: current_credential, message: ">>> Marked as un#{status} <<<", skip_notify: true, status => false) if comment
+#       @report.update("#{status}_at": nil, "#{status}_by": nil)
+#     end
+#   end
+#
+#   def report_params
+#     params.require(:snitch_report).permit(
+#       :source,
+#       :severity,
+#       :assigned_to_id,
+#       :title,
+#       :custom_details
+#     )
+#   end
+#
+#   def comment_params
+#     params.require(:snitch_comment).permit(:message)
+#   end
+#
+#   def set_report_preferences
+#     @filters = begin
+#       preferences = JSON.parse(session[:filters].presence || "{}").symbolize_keys
+#
+#       available_preferences = [:level_tags, :severity_tags, :source_tags, :resolved, :ignored]
+#       available_preferences.each do |pref_key|
+#         pref_val = params[pref_key]
+#         preferences[pref_key] = pref_val if pref_val.present?
+#         preferences.delete(pref_key) if pref_val == "all"
+#       end
+#
+#       session[:filters] = preferences.to_json
+#       preferences
+#     end
+#   end
+  def set_filters
+    @filter_sets = {
+      status: {
+        default: :unresolved,
+        values: [:all, :resolved, :unresolved]
+      },
+      # assignee: {
+      #   default: :any,
+      #   values: [:any, :me, :not_me, :not_assigned]
+      # },
+      log_level: {
+        default: :any,
+        values: [:any] + ::SnitchReporting::SnitchReport.log_levels.keys.map(&:to_sym)
+      },
+      # ignored: {
+      #   default: :not_ignored,
+      #   values: [:all, :ignored, :not_ignored]
+      # }
+    }
+
+    filter_string_from_params
+
+    # @filters = @filter_sets.each_with_object({set_filters: {}}) do |(filter_name, filter_set), filters|
+    #   filters[filter_name] = filter_set[:default]
+    #   filter_in_param = params[filter_name].try(:to_sym)
+    #   next unless filter_in_param && filter_set[:values].include?(filter_in_param)
+    #   filters[filter_name] = filter_in_param
+    #   filters[:set_filters][filter_name] = filter_in_param
+    # end
+  end
+
+  def filter_reports
+    set_filters
+
+    @reports = @reports.resolved if @filters[:status] == :resolved
+    @reports = @reports.unresolved if @filters[:status] == :unresolved
+    @reports = @reports.search(@filters[:search]) if @filters[:search].present?
+    @reports = @reports.by_level(@filters[:log_level]) if @filters[:log_level].present? && @filters[:log_level] != :any
+
+    @reports = @reports.by_tag(*@filters[:tags]) if @filters[:tags].present?
+    # @reports = @reports.by_severity(@filters[:severity_tags]) if @filters[:severity_tags].present?
+    # @reports = @reports.by_source(@filters[:source_tags]) if @filters[:source_tags].present?
+    #
+    # @reports = @filters[:resolved].present? && truthy?(@filters[:resolved]) ? @reports.resolved : @reports.unresolved
+    # @reports = @filters[:ignored].present? && truthy?(@filters[:ignored]) ? @reports.ignored : @reports.unignored
+  end
+
+  def param_safe_value(str)
+    return str unless str.include?(" ")
+
+    "\"#{str}\""
+  end
   #
   #   def sort_reports
   #     order = sort_order || "desc"

data/app/helpers/snitch_reporting/snitch_report_helper.rb

@@ -1,2 +1,13 @@
 module ::SnitchReporting::SnitchReportHelper
+  def search_path_from_filter_string(new_params={})
+    snitch_reports_path(filter_string: filter_string_from_params(new_params))
+  end
+
+  def filter_string_from_params(extra_params={})
+    @filter_builder = ::SnitchReporting::Service::FilterStringBuilder.new(from_string: params[:filter_string] || session[:snitch_filter_string] || "status:unresolved")
+    @filter_string = @filter_builder.to_filter_string
+    @filters = @filter_builder.filters
+
+    session[:snitch_filter_string] = @filter_string.dup
+  end
 end

data/app/models/snitch_reporting/service/filter_string_builder.rb

@@ -0,0 +1,160 @@
+class ::SnitchReporting::Service::FilterStringBuilder
+  attr_accessor :filter_hash, :filters, :unknown_filters
+
+  def self.filter_sets
+    {
+      status: {
+        default: :unresolved,
+        values: [:all, :resolved, :unresolved]
+      },
+      # assignee: {
+      #   default: :any,
+      #   values: [:any, :me, :not_me, :not_assigned]
+      # },
+      log_level: {
+        default: :any,
+        values: [:any] + ::SnitchReporting::SnitchReport.log_levels.keys.map(&:to_sym)
+      },
+      # ignored: {
+      #   default: :not_ignored,
+      #   values: [:all, :ignored, :not_ignored]
+      # }
+    }
+  end
+
+  # extra_params.each do |param_key, param_value|
+  #   param_key = param_key.to_s
+  #   param_value = param_value.to_s
+  #
+  #   if param_value.blank?
+  #     # Search pure text by itself
+  #     search_strings << param_key
+  #   elsif @filter_sets.keys.include?(param_key.to_s.to_sym)
+  #     param_value = decode_string(secret_key, param_value)
+  #     @filters[param_key.to_sym] = param_value.to_sym
+  #   elsif param_key == "search"
+  #     search_strings << decode_string(secret_key, param_value)
+  #   elsif param_key == "tag" || param_key == "tags"
+  #     tag_strings << decode_string(secret_key, param_value)
+  #   else
+  #     @unknown_strings << "#{param_key}:#{param_value}"
+  #   end
+  # end
+
+  def filter_sets
+    self.class.filter_sets
+  end
+
+  def initialize(from_string: nil, from_data: nil)
+    parse_filters_from_string(from_string) if from_string.present?
+  end
+
+  def to_param
+    { filter_string: to_filter_string }
+  end
+
+  def to_filter_string
+    filter_strings = []
+    tag_strings = []
+    search_strings = []
+
+    @filters.each do |filter_key, filter_value|
+      if filter_key == :search
+        search_strings += filter_value
+      elsif filter_key == :tags
+        tag_strings += filter_value.map { |value| filter_to_string(filter_key, filter_value) }
+      elsif filter_sets.keys.include?(filter_key.to_s.to_sym)
+        filter_strings << filter_to_string(filter_key, filter_value)
+      else
+        # No-op for now. Probably should display these somewhere?
+      end
+    end
+
+    (filter_strings + tag_strings + search_strings).join(" ")
+  end
+
+  def add_filter(filter_key, filter_value)
+    filter_key = filter_key.to_s.to_sym
+    @filters ||= {search: [], tags: [], unknown: []}
+
+    if filter_value.blank?
+      @filters[:search] << filter_key
+    elsif filter_key == :search
+      @filters[:search] << filter_key
+    elsif filter_key == :tags
+      @filters[:tags] << {filter_key => filter_value}
+    else
+      @filters[filter_key] = filter_value.to_s.to_sym
+    end
+  end
+
+  private
+
+  def encode_string(str)
+    @encoded_strings ||= []
+
+    @encoded_strings << str
+    "#{@parse_token}(#{@encoded_strings.length - 1})"
+  end
+
+  def decode_string(encoded_str)
+    @encoded_strings ||= []
+
+    encoded_str.gsub(/#{Regexp.escape(@parse_token)}\((\d+)\)/) do |found|
+      encoded_idx = Regexp.last_match(1)
+
+      if encoded_idx.to_i.to_s == encoded_idx
+        @encoded_strings[encoded_idx.to_i]
+      else
+        found
+      end
+    end
+  end
+
+  def parse_filters_from_string(filter_string)
+    @parse_token = generate_uniq_key(filter_string)
+    encoded_string = extract_quoted_strings(filter_string)
+    parsed_strings = group_values_without_filter(encoded_string)
+
+    parsed_strings[:filters].each do |parsed_string|
+      filter, value, * = parsed_string.split(":")
+
+      add_filter(filter, decode_string(value))
+    end
+  end
+
+  def group_values_without_filter(encoded_string)
+    filter_group_hash = {
+      filters: [],
+      search: [],
+      tags: [],
+      unknown: []
+    }
+    encoded_string.split(" ").each_with_object(filter_group_hash) do |filter, filter_groups|
+      if filter.include?(":")
+        filter_groups[:filters] << filter
+      else
+        filter_groups[:search] << filter
+      end
+    end
+  end
+
+  def filter_to_string(filter, value)
+    filter = "\"#{filter}\"" if filter.to_s.include?(" ")
+    value = "\"#{value}\"" if value.to_s.include?(" ")
+    [filter.presence, value.presence].compact.join(":")
+  end
+
+  def extract_quoted_strings(filter_string)
+    filter_string.gsub(/\"(.*?)\"/) do |found|
+      encode_string(secret_key, Regexp.last_match(1))
+    end
+  end
+
+  def generate_uniq_key(filter_string)
+    loop do
+      token = SecureRandom.hex(10)
+      break token unless filter_string.to_s.include?(token)
+    end
+  end
+end

data/lib/snitch_reporting/version.rb

@@ -1,3 +1,3 @@
 module SnitchReporting
-  VERSION = '1.2.3'
+  VERSION = '1.2.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: snitch_reporting
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.4
 platform: ruby
 authors:
 - Rocco Nicholls
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-26 00:00:00.000000000 Z
+date: 2020-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  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: pg
   requirement: !ruby/object:Gem::Requirement
@@ -92,6 +106,7 @@ files:
 - app/controllers/snitch_reporting/snitch_reports_controller.rb
 - app/helpers/snitch_reporting/params_helper.rb
 - app/helpers/snitch_reporting/snitch_report_helper.rb
+- app/models/snitch_reporting/service/filter_string_builder.rb
 - app/models/snitch_reporting/service/json_wrapper.rb
 - app/models/snitch_reporting/snitch_comment.rb
 - app/models/snitch_reporting/snitch_history.rb