From 4d7715fbb663229b3fdc6278f7ac678a286a7697 Mon Sep 17 00:00:00 2001 From: simon lehericey Date: Mon, 14 Oct 2024 21:46:52 +0200 Subject: [PATCH] extract filter and sort function to a filter_service --- .../concerns/dossier_filtering_concern.rb | 4 +- app/models/procedure_presentation.rb | 150 ---- app/services/dossier_filter_service.rb | 157 ++++ config/brakeman.ignore | 54 +- spec/models/procedure_presentation_spec.rb | 697 ----------------- spec/services/dossier_filter_service_spec.rb | 709 ++++++++++++++++++ 6 files changed, 895 insertions(+), 876 deletions(-) create mode 100644 app/services/dossier_filter_service.rb create mode 100644 spec/services/dossier_filter_service_spec.rb diff --git a/app/models/concerns/dossier_filtering_concern.rb b/app/models/concerns/dossier_filtering_concern.rb index e102c1239..a1470bbda 100644 --- a/app/models/concerns/dossier_filtering_concern.rb +++ b/app/models/concerns/dossier_filtering_concern.rb @@ -29,13 +29,13 @@ module DossierFilteringConcern } scope :filter_ilike, lambda { |table, column, values| - table_column = ProcedurePresentation.sanitized_column(table, column) + table_column = DossierFilterService.sanitized_column(table, column) q = Array.new(values.count, "(#{table_column} ILIKE ?)").join(' OR ') where(q, *(values.map { |value| "%#{value}%" })) } scope :filter_enum, lambda { |table, column, values| - table_column = ProcedurePresentation.sanitized_column(table, column) + table_column = DossierFilterService.sanitized_column(table, column) q = Array.new(values.count, "(#{table_column} = ?)").join(' OR ') where(q, *(values)) } diff --git a/app/models/procedure_presentation.rb b/app/models/procedure_presentation.rb index 37247174a..42345edd9 100644 --- a/app/models/procedure_presentation.rb +++ b/app/models/procedure_presentation.rb @@ -42,17 +42,6 @@ class ProcedurePresentation < ApplicationRecord ] end - def filtered_sorted_ids(dossiers, statut, count: nil) - dossiers_by_statut = dossiers.by_statut(statut, instructeur) - dossiers_sorted_ids = self.sorted_ids(dossiers_by_statut, count || dossiers_by_statut.size) - - if filters_for(statut).present? - dossiers_sorted_ids.intersection(filtered_ids(dossiers_by_statut, statut)) - else - dossiers_sorted_ids - end - end - def human_value_for_filter(filtered_column) if filtered_column.column.table == TYPE_DE_CHAMP find_type_de_champ(filtered_column.column.column).dynamic_type.filter_to_human(filtered_column.filter) @@ -90,120 +79,6 @@ class ProcedurePresentation < ApplicationRecord private - def sorted_ids(dossiers, count) - table = sorted_column.column.table - column = sorted_column.column.column - order = sorted_column.order - - case table - when 'notifications' - dossiers_id_with_notification = dossiers.merge(instructeur.followed_dossiers).with_notifications.ids - if order == 'desc' - dossiers_id_with_notification + - (dossiers.order('dossiers.updated_at desc').ids - dossiers_id_with_notification) - else - (dossiers.order('dossiers.updated_at asc').ids - dossiers_id_with_notification) + - dossiers_id_with_notification - end - when TYPE_DE_CHAMP - ids = dossiers - .with_type_de_champ(column) - .order("champs.value #{order}") - .pluck(:id) - if ids.size != count - rest = dossiers.where.not(id: ids).order(id: order).pluck(:id) - order == 'asc' ? ids + rest : rest + ids - else - ids - end - when 'followers_instructeurs' - assert_supported_column(table, column) - # LEFT OUTER JOIN allows to keep dossiers without assigned instructeurs yet - dossiers - .includes(:followers_instructeurs) - .joins('LEFT OUTER JOIN users instructeurs_users ON instructeurs_users.id = instructeurs.user_id') - .order("instructeurs_users.email #{order}") - .pluck(:id) - .uniq - when 'avis' - dossiers.includes(table) - .order("#{self.class.sanitized_column(table, column)} #{order}") - .pluck(:id) - .uniq - when 'self', 'user', 'individual', 'etablissement', 'groupe_instructeur' - (table == 'self' ? dossiers : dossiers.includes(table)) - .order("#{self.class.sanitized_column(table, column)} #{order}") - .pluck(:id) - end - end - - def filtered_ids(dossiers, statut) - filters_for(statut) - .group_by { |filter| filter.column.then { [_1.table, _1.column] } } - .map do |(table, column), filters_for_column| - values = filters_for_column.map(&:filter) - filtered_column = filters_for_column.first.column - value_column = filtered_column.value_column - - if filtered_column.is_a?(Columns::JSONPathColumn) - filtered_column.filtered_ids(dossiers, values) - else - case table - when 'self' - if filtered_column.type == :date - dates = values - .filter_map { |v| Time.zone.parse(v).beginning_of_day rescue nil } - - dossiers.filter_by_datetimes(column, dates) - elsif filtered_column.column == "state" && values.include?("pending_correction") - dossiers.joins(:corrections).where(corrections: DossierCorrection.pending) - elsif filtered_column.column == "state" && values.include?("en_construction") - dossiers.where("dossiers.#{column} IN (?)", values).includes(:corrections).where.not(corrections: DossierCorrection.pending) - else - dossiers.where("dossiers.#{column} IN (?)", values) - end - when TYPE_DE_CHAMP - if filtered_column.type == :enum - dossiers.with_type_de_champ(column) - .filter_enum(:champs, value_column, values) - else - dossiers.with_type_de_champ(column) - .filter_ilike(:champs, value_column, values) - end - when 'etablissement' - if column == 'entreprise_date_creation' - dates = values - .filter_map { |v| v.to_date rescue nil } - - dossiers - .includes(table) - .where(table.pluralize => { column => dates }) - else - dossiers - .includes(table) - .filter_ilike(table, column, values) - end - when 'followers_instructeurs' - assert_supported_column(table, column) - dossiers - .includes(:followers_instructeurs) - .joins('INNER JOIN users instructeurs_users ON instructeurs_users.id = instructeurs.user_id') - .filter_ilike('instructeurs_users', :email, values) # ilike OK, user may want to search by *@domain - when 'user', 'individual' # user_columns: [email], individual_columns: ['nom', 'prenom', 'gender'] - dossiers - .includes(table) - .filter_ilike(table, column, values) # ilike or where column == 'value' are both valid, we opted for ilike - when 'groupe_instructeur' - assert_supported_column(table, column) - - dossiers - .joins(:groupe_instructeur) - .where(groupe_instructeur_id: values) - end.pluck(:id) - end - end.reduce(:&) - end - def find_type_de_champ(column) TypeDeChamp .joins(:revision_types_de_champ) @@ -211,29 +86,4 @@ class ProcedurePresentation < ApplicationRecord .order(created_at: :desc) .find_by(stable_id: column) end - - def self.sanitized_column(association, column) - table = if association == 'self' - Dossier.table_name - elsif (association_reflection = Dossier.reflect_on_association(association)) - association_reflection.klass.table_name - else - # Allow filtering on a joined table alias (which doesn’t exist - # in the ActiveRecord domain). - association - end - - [table, column] - .map { |name| ActiveRecord::Base.connection.quote_column_name(name) } - .join('.') - end - - def assert_supported_column(table, column) - if table == 'followers_instructeurs' && column != 'email' - raise ArgumentError, 'Table `followers_instructeurs` only supports the `email` column.' - end - if table == 'groupe_instructeur' && (column != 'label' && column != 'id') - raise ArgumentError, 'Table `groupe_instructeur` only supports the `label` or `id` column.' - end - end end diff --git a/app/services/dossier_filter_service.rb b/app/services/dossier_filter_service.rb new file mode 100644 index 000000000..586213451 --- /dev/null +++ b/app/services/dossier_filter_service.rb @@ -0,0 +1,157 @@ +# frozen_string_literal: true + +class DossierFilterService + TYPE_DE_CHAMP = 'type_de_champ' + + def self.filtered_sorted_ids(dossiers, statut, filters, sorted_column, instructeur, count: nil) + dossiers_by_statut = dossiers.by_statut(statut, instructeur) + dossiers_sorted_ids = self.sorted_ids(dossiers_by_statut, sorted_column, instructeur, count || dossiers_by_statut.size) + + if filters.present? + dossiers_sorted_ids.intersection(filtered_ids(dossiers_by_statut, filters)) + else + dossiers_sorted_ids + end + end + + private + + def self.sorted_ids(dossiers, sorted_column, instructeur, count) + table = sorted_column.column.table + column = sorted_column.column.column + order = sorted_column.order + + case table + when 'notifications' + dossiers_id_with_notification = dossiers.merge(instructeur.followed_dossiers).with_notifications.ids + if order == 'desc' + dossiers_id_with_notification + + (dossiers.order('dossiers.updated_at desc').ids - dossiers_id_with_notification) + else + (dossiers.order('dossiers.updated_at asc').ids - dossiers_id_with_notification) + + dossiers_id_with_notification + end + when TYPE_DE_CHAMP + ids = dossiers + .with_type_de_champ(column) + .order("champs.value #{order}") + .pluck(:id) + if ids.size != count + rest = dossiers.where.not(id: ids).order(id: order).pluck(:id) + order == 'asc' ? ids + rest : rest + ids + else + ids + end + when 'followers_instructeurs' + assert_supported_column(table, column) + # LEFT OUTER JOIN allows to keep dossiers without assigned instructeurs yet + dossiers + .includes(:followers_instructeurs) + .joins('LEFT OUTER JOIN users instructeurs_users ON instructeurs_users.id = instructeurs.user_id') + .order("instructeurs_users.email #{order}") + .pluck(:id) + .uniq + when 'avis' + dossiers.includes(table) + .order("#{sanitized_column(table, column)} #{order}") + .pluck(:id) + .uniq + when 'self', 'user', 'individual', 'etablissement', 'groupe_instructeur' + (table == 'self' ? dossiers : dossiers.includes(table)) + .order("#{sanitized_column(table, column)} #{order}") + .pluck(:id) + end + end + + def self.filtered_ids(dossiers, filters) + filters + .group_by { |filter| filter.column.then { [_1.table, _1.column] } } + .map do |(table, column), filters_for_column| + values = filters_for_column.map(&:filter) + filtered_column = filters_for_column.first.column + value_column = filtered_column.value_column + + if filtered_column.is_a?(Columns::JSONPathColumn) + filtered_column.filtered_ids(dossiers, values) + else + case table + when 'self' + if filtered_column.type == :date + dates = values + .filter_map { |v| Time.zone.parse(v).beginning_of_day rescue nil } + + dossiers.filter_by_datetimes(column, dates) + elsif filtered_column.column == "state" && values.include?("pending_correction") + dossiers.joins(:corrections).where(corrections: DossierCorrection.pending) + elsif filtered_column.column == "state" && values.include?("en_construction") + dossiers.where("dossiers.#{column} IN (?)", values).includes(:corrections).where.not(corrections: DossierCorrection.pending) + else + dossiers.where("dossiers.#{column} IN (?)", values) + end + when TYPE_DE_CHAMP + if filtered_column.type == :enum + dossiers.with_type_de_champ(column) + .filter_enum(:champs, value_column, values) + else + dossiers.with_type_de_champ(column) + .filter_ilike(:champs, value_column, values) + end + when 'etablissement' + if column == 'entreprise_date_creation' + dates = values + .filter_map { |v| v.to_date rescue nil } + + dossiers + .includes(table) + .where(table.pluralize => { column => dates }) + else + dossiers + .includes(table) + .filter_ilike(table, column, values) + end + when 'followers_instructeurs' + assert_supported_column(table, column) + dossiers + .includes(:followers_instructeurs) + .joins('INNER JOIN users instructeurs_users ON instructeurs_users.id = instructeurs.user_id') + .filter_ilike('instructeurs_users', :email, values) # ilike OK, user may want to search by *@domain + when 'user', 'individual' # user_columns: [email], individual_columns: ['nom', 'prenom', 'gender'] + dossiers + .includes(table) + .filter_ilike(table, column, values) # ilike or where column == 'value' are both valid, we opted for ilike + when 'groupe_instructeur' + assert_supported_column(table, column) + + dossiers + .joins(:groupe_instructeur) + .where(groupe_instructeur_id: values) + end.pluck(:id) + end + end.reduce(:&) + end + + def self.sanitized_column(association, column) + table = if association == 'self' + Dossier.table_name + elsif (association_reflection = Dossier.reflect_on_association(association)) + association_reflection.klass.table_name + else + # Allow filtering on a joined table alias (which doesn’t exist + # in the ActiveRecord domain). + association + end + + [table, column] + .map { |name| ActiveRecord::Base.connection.quote_column_name(name) } + .join('.') + end + + def self.assert_supported_column(table, column) + if table == 'followers_instructeurs' && column != 'email' + raise ArgumentError, 'Table `followers_instructeurs` only supports the `email` column.' + end + if table == 'groupe_instructeur' && (column != 'label' && column != 'id') + raise ArgumentError, 'Table `groupe_instructeur` only supports the `label` or `id` column.' + end + end +end diff --git a/config/brakeman.ignore b/config/brakeman.ignore index 4cb15c70d..69ad55629 100644 --- a/config/brakeman.ignore +++ b/config/brakeman.ignore @@ -44,29 +44,6 @@ ], "note": "" }, - { - "warning_type": "SQL Injection", - "warning_code": 0, - "fingerprint": "31693060072e27c02ca4f884f2a07f4f1c1247b7a6f5cc5c724e88e6ca9b4873", - "check_name": "SQL", - "message": "Possible SQL injection", - "file": "app/models/concerns/dossier_filtering_concern.rb", - "line": 40, - "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/", - "code": "where(\"#{values.count} OR #{\"(#{ProcedurePresentation.sanitized_column(table, column)} = ?)\"}\", *values)", - "render_path": null, - "location": { - "type": "method", - "class": "DossierFilteringConcern", - "method": null - }, - "user_input": "values.count", - "confidence": "Medium", - "cwe_id": [ - 89 - ], - "note": "filtered by rails query params where(something: ?, values)" - }, { "warning_type": "SQL Injection", "warning_code": 0, @@ -136,6 +113,29 @@ ], "note": "" }, + { + "warning_type": "SQL Injection", + "warning_code": 0, + "fingerprint": "91ff8031e7c639c95fe6c244867349a72078ef456d8b3507deaf2bdb9bf62fe2", + "check_name": "SQL", + "message": "Possible SQL injection", + "file": "app/models/concerns/dossier_filtering_concern.rb", + "line": 34, + "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/", + "code": "where(\"#{values.count} OR #{\"(#{DossierFilterService.sanitized_column(table, column)} ILIKE ?)\"}\", *values.map do\n \"%#{value}%\"\n end)", + "render_path": null, + "location": { + "type": "method", + "class": "DossierFilteringConcern", + "method": null + }, + "user_input": "values.count", + "confidence": "Medium", + "cwe_id": [ + 89 + ], + "note": "filtered by rails query params where(something: ?, values)" + }, { "warning_type": "Cross-Site Scripting", "warning_code": 2, @@ -196,13 +196,13 @@ { "warning_type": "SQL Injection", "warning_code": 0, - "fingerprint": "bd1df30f95135357b646e21a03d95498874faffa32e3804fc643e9b6b957ee14", + "fingerprint": "aaff41afa7bd5a551cd2e3a385071090cb53c95caa40fad3785cd3d68c9b939c", "check_name": "SQL", "message": "Possible SQL injection", "file": "app/models/concerns/dossier_filtering_concern.rb", - "line": 34, + "line": 40, "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/", - "code": "where(\"#{values.count} OR #{\"(#{ProcedurePresentation.sanitized_column(table, column)} ILIKE ?)\"}\", *values.map do\n \"%#{value}%\"\n end)", + "code": "where(\"#{values.count} OR #{\"(#{DossierFilterService.sanitized_column(table, column)} = ?)\"}\", *values)", "render_path": null, "location": { "type": "method", @@ -272,6 +272,6 @@ "note": "Current is not a model" } ], - "updated": "2024-09-24 20:56:24 +0200", + "updated": "2024-10-15 15:57:27 +0200", "brakeman_version": "6.1.2" } diff --git a/spec/models/procedure_presentation_spec.rb b/spec/models/procedure_presentation_spec.rb index ecf427de9..ac30ea06e 100644 --- a/spec/models/procedure_presentation_spec.rb +++ b/spec/models/procedure_presentation_spec.rb @@ -55,655 +55,6 @@ describe ProcedurePresentation do end end - describe '#sorted_ids' do - let(:instructeur) { create(:instructeur) } - let(:assign_to) { create(:assign_to, procedure:, instructeur:) } - let(:sorted_column) { SortedColumn.new(column:, order:) } - let(:procedure_presentation) { create(:procedure_presentation, assign_to:, sorted_column:) } - - subject { procedure_presentation.send(:sorted_ids, procedure.dossiers, procedure.dossiers.count) } - - context 'for notifications table' do - let(:column) { procedure.notifications_column } - - let!(:notified_dossier) { create(:dossier, :en_construction, procedure:) } - let!(:recent_dossier) { create(:dossier, :en_construction, procedure:) } - let!(:older_dossier) { create(:dossier, :en_construction, procedure:) } - - before do - notified_dossier.update!(last_champ_updated_at: Time.zone.local(2018, 9, 20)) - create(:follow, instructeur: instructeur, dossier: notified_dossier, demande_seen_at: Time.zone.local(2018, 9, 10)) - notified_dossier.touch(time: Time.zone.local(2018, 9, 20)) - recent_dossier.touch(time: Time.zone.local(2018, 9, 25)) - older_dossier.touch(time: Time.zone.local(2018, 5, 13)) - end - - context 'in ascending order' do - let(:order) { 'asc' } - - it { is_expected.to eq([older_dossier, recent_dossier, notified_dossier].map(&:id)) } - end - - context 'in descending order' do - let(:order) { 'desc' } - - it { is_expected.to eq([notified_dossier, recent_dossier, older_dossier].map(&:id)) } - end - - context 'with a dossier terminé' do - let!(:notified_dossier) { create(:dossier, :accepte, procedure:) } - let(:order) { 'desc' } - - it { is_expected.to eq([notified_dossier, recent_dossier, older_dossier].map(&:id)) } - end - end - - context 'for self table' do - let(:order) { 'asc' } # Desc works the same, no extra test required - - context 'for created_at column' do - let!(:column) { procedure.find_column(label: 'Créé le') } - let!(:recent_dossier) { Timecop.freeze(Time.zone.local(2018, 10, 17)) { create(:dossier, procedure: procedure) } } - let!(:older_dossier) { Timecop.freeze(Time.zone.local(2003, 11, 11)) { create(:dossier, procedure: procedure) } } - - it { is_expected.to eq([older_dossier, recent_dossier].map(&:id)) } - end - - context 'for en_construction_at column' do - let!(:column) { procedure.find_column(label: 'En construction le') } - let!(:recent_dossier) { create(:dossier, :en_construction, procedure: procedure, en_construction_at: Time.zone.local(2018, 10, 17)) } - let!(:older_dossier) { create(:dossier, :en_construction, procedure: procedure, en_construction_at: Time.zone.local(2013, 1, 1)) } - - it { is_expected.to eq([older_dossier, recent_dossier].map(&:id)) } - end - - context 'for updated_at column' do - let(:column) { procedure.find_column(label: 'Mis à jour le') } - let(:recent_dossier) { create(:dossier, procedure: procedure) } - let(:older_dossier) { create(:dossier, procedure: procedure) } - - before do - recent_dossier.touch(time: Time.zone.local(2018, 9, 25)) - older_dossier.touch(time: Time.zone.local(2018, 5, 13)) - end - - it { is_expected.to eq([older_dossier, recent_dossier].map(&:id)) } - end - end - - context 'for type_de_champ table' do - context 'with no revisions' do - let(:column) { procedure.find_column(label: first_type_de_champ.libelle) } - - let(:beurre_dossier) { create(:dossier, procedure:) } - let(:tartine_dossier) { create(:dossier, procedure:) } - - before do - beurre_dossier.project_champs_public.first.update(value: 'beurre') - tartine_dossier.project_champs_public.first.update(value: 'tartine') - end - - context 'asc' do - let(:order) { 'asc' } - - it { is_expected.to eq([beurre_dossier, tartine_dossier].map(&:id)) } - end - - context 'desc' do - let(:order) { 'desc' } - - it { is_expected.to eq([tartine_dossier, beurre_dossier].map(&:id)) } - end - end - - context 'with a revision adding a new type_de_champ' do - let!(:tdc) { { type_champ: :text, libelle: 'nouveau champ' } } - let(:column) { procedure.find_column(label: 'nouveau champ') } - - let!(:nothing_dossier) { create(:dossier, procedure:) } - let!(:beurre_dossier) { create(:dossier, procedure:) } - let!(:tartine_dossier) { create(:dossier, procedure:) } - - before do - nothing_dossier - procedure.draft_revision.add_type_de_champ(tdc) - procedure.publish_revision! - beurre_dossier.project_champs_public.last.update(value: 'beurre') - tartine_dossier.project_champs_public.last.update(value: 'tartine') - end - - context 'asc' do - let(:order) { 'asc' } - it { is_expected.to eq([nothing_dossier, beurre_dossier, tartine_dossier].map(&:id)) } - end - - context 'desc' do - let(:order) { 'desc' } - it { is_expected.to eq([tartine_dossier, beurre_dossier, nothing_dossier].map(&:id)) } - end - end - end - - context 'for type_de_champ_private table' do - context 'with no revisions' do - let(:column) { procedure.find_column(label: procedure.active_revision.types_de_champ_private.first.libelle) } - - let(:biere_dossier) { create(:dossier, procedure: procedure) } - let(:vin_dossier) { create(:dossier, procedure: procedure) } - - before do - biere_dossier.project_champs_private.first.update(value: 'biere') - vin_dossier.project_champs_private.first.update(value: 'vin') - end - - context 'asc' do - let(:order) { 'asc' } - - it { is_expected.to eq([biere_dossier, vin_dossier].map(&:id)) } - end - - context 'desc' do - let(:order) { 'desc' } - - it { is_expected.to eq([vin_dossier, biere_dossier].map(&:id)) } - end - end - end - - context 'for individual table' do - let(:order) { 'asc' } # Desc works the same, no extra test required - - let(:procedure) { create(:procedure, :for_individual) } - - let!(:first_dossier) { create(:dossier, procedure: procedure, individual: build(:individual, gender: 'M', prenom: 'Alain', nom: 'Antonelli')) } - let!(:last_dossier) { create(:dossier, procedure: procedure, individual: build(:individual, gender: 'Mme', prenom: 'Zora', nom: 'Zemmour')) } - - context 'for gender column' do - let(:column) { procedure.find_column(label: 'Civilité') } - - it { is_expected.to eq([first_dossier, last_dossier].map(&:id)) } - end - - context 'for prenom column' do - let(:column) { procedure.find_column(label: 'Prénom') } - - it { is_expected.to eq([first_dossier, last_dossier].map(&:id)) } - end - - context 'for nom column' do - let(:column) { procedure.find_column(label: 'Nom') } - - it { is_expected.to eq([first_dossier, last_dossier].map(&:id)) } - end - end - - context 'for followers_instructeurs table' do - let(:order) { 'asc' } # Desc works the same, no extra test required - - let!(:dossier_z) { create(:dossier, :en_construction, procedure: procedure) } - let!(:dossier_a) { create(:dossier, :en_construction, procedure: procedure) } - let!(:dossier_without_instructeur) { create(:dossier, :en_construction, procedure: procedure) } - - before do - create(:follow, dossier: dossier_z, instructeur: create(:instructeur, email: 'zythum@exemple.fr')) - create(:follow, dossier: dossier_a, instructeur: create(:instructeur, email: 'abaca@exemple.fr')) - create(:follow, dossier: dossier_a, instructeur: create(:instructeur, email: 'abaca2@exemple.fr')) - end - - context 'for email column' do - let(:column) { procedure.find_column(label: 'Email instructeur') } - - it { is_expected.to eq([dossier_a, dossier_z, dossier_without_instructeur].map(&:id)) } - end - end - - context 'for avis table' do - let(:column) { procedure.find_column(label: 'Avis oui/non') } - let(:order) { 'asc' } - - let!(:dossier_yes) { create(:dossier, procedure:) } - let!(:dossier_no) { create(:dossier, procedure:) } - - before do - create_list(:avis, 2, dossier: dossier_yes, question_answer: true) - create(:avis, dossier: dossier_no, question_answer: true) - create(:avis, dossier: dossier_no, question_answer: false) - end - - it { is_expected.to eq([dossier_no, dossier_yes].map(&:id)) } - end - - context 'for other tables' do - # All other columns and tables work the same so it’s ok to test only one - let(:column) { procedure.find_column(label: 'Code postal') } - let(:order) { 'asc' } # Desc works the same, no extra test required - - let!(:huitieme_dossier) { create(:dossier, procedure: procedure, etablissement: create(:etablissement, code_postal: '75008')) } - let!(:vingtieme_dossier) { create(:dossier, procedure: procedure, etablissement: create(:etablissement, code_postal: '75020')) } - - it { is_expected.to eq([huitieme_dossier, vingtieme_dossier].map(&:id)) } - end - end - - describe '#filtered_ids' do - let(:procedure_presentation) { create(:procedure_presentation, assign_to:, suivis_filters: filtered_columns) } - let(:filtered_columns) { filters.map { to_filter(_1) } } - let(:filters) { [filter] } - - subject { procedure_presentation.send(:filtered_ids, procedure.dossiers.joins(:user), 'suivis') } - - context 'for self table' do - context 'for created_at column' do - let(:filter) { ['Créé le', '18/9/2018'] } - - let!(:kept_dossier) { create(:dossier, procedure: procedure, created_at: Time.zone.local(2018, 9, 18, 14, 28)) } - let!(:discarded_dossier) { create(:dossier, procedure: procedure, created_at: Time.zone.local(2018, 9, 17, 23, 59)) } - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'for en_construction_at column' do - let(:filter) { ['En construction le', '17/10/2018'] } - - let!(:kept_dossier) { create(:dossier, :en_construction, procedure: procedure, en_construction_at: Time.zone.local(2018, 10, 17)) } - let!(:discarded_dossier) { create(:dossier, :en_construction, procedure: procedure, en_construction_at: Time.zone.local(2013, 1, 1)) } - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'for updated_at column' do - let(:filter) { ['Mis à jour le', '18/9/2018'] } - - let(:kept_dossier) { create(:dossier, procedure: procedure) } - let(:discarded_dossier) { create(:dossier, procedure: procedure) } - - before do - kept_dossier.touch(time: Time.zone.local(2018, 9, 18, 14, 28)) - discarded_dossier.touch(time: Time.zone.local(2018, 9, 17, 23, 59)) - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'for updated_since column' do - let(:filter) { ['Mis à jour depuis', '18/9/2018'] } - - let(:kept_dossier) { create(:dossier, procedure: procedure) } - let(:later_dossier) { create(:dossier, procedure: procedure) } - let(:discarded_dossier) { create(:dossier, procedure: procedure) } - - before do - kept_dossier.touch(time: Time.zone.local(2018, 9, 18, 14, 28)) - later_dossier.touch(time: Time.zone.local(2018, 9, 19, 14, 28)) - discarded_dossier.touch(time: Time.zone.local(2018, 9, 17, 14, 28)) - end - - it { is_expected.to match_array([kept_dossier.id, later_dossier.id]) } - end - - context 'for sva_svr_decision_before column' do - before do - travel_to Time.zone.local(2023, 6, 10, 10) - end - - let(:procedure) { create(:procedure, :published, :sva, types_de_champ_public: [{}], types_de_champ_private: [{}]) } - let(:filter) { ['Date décision SVA avant', '15/06/2023'] } - - let!(:kept_dossier) { create(:dossier, :en_instruction, procedure:, sva_svr_decision_on: Date.current) } - let!(:later_dossier) { create(:dossier, :en_instruction, procedure:, sva_svr_decision_on: Date.current + 2.days) } - let!(:discarded_dossier) { create(:dossier, :en_instruction, procedure:, sva_svr_decision_on: Date.current + 10.days) } - let!(:en_construction_dossier) { create(:dossier, :en_construction, procedure:, sva_svr_decision_on: Date.current + 2.days) } - let!(:accepte_dossier) { create(:dossier, :accepte, procedure:, sva_svr_decision_on: Date.current + 2.days) } - - it { is_expected.to match_array([kept_dossier.id, later_dossier.id, en_construction_dossier.id]) } - end - - context 'ignore time of day' do - let(:filter) { ['En construction le', '17/10/2018 19:30'] } - - let!(:kept_dossier) { create(:dossier, :en_construction, procedure: procedure, en_construction_at: Time.zone.local(2018, 10, 17, 15, 56)) } - let!(:discarded_dossier) { create(:dossier, :en_construction, procedure: procedure, en_construction_at: Time.zone.local(2018, 10, 18, 5, 42)) } - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'for a malformed date' do - context 'when its a string' do - let(:filter) { ['Mis à jour le', 'malformed date'] } - - it { is_expected.to match([]) } - end - - context 'when its a number' do - let(:filter) { ['Mis à jour le', '177500'] } - - it { is_expected.to match([]) } - end - end - - context 'with multiple search values' do - let(:filters) { [['En construction le', '17/10/2018'], ['En construction le', '19/10/2018']] } - - let!(:kept_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2018, 10, 17)) } - let!(:other_kept_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2018, 10, 19)) } - let!(:discarded_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2013, 1, 1)) } - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - - context 'with multiple state filters' do - let(:filters) { [['Statut', 'en_construction'], ['Statut', 'en_instruction']] } - - let!(:kept_dossier) { create(:dossier, :en_construction, procedure:) } - let!(:other_kept_dossier) { create(:dossier, :en_instruction, procedure:) } - let!(:discarded_dossier) { create(:dossier, :accepte, procedure:) } - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - - context 'with en_construction state filters' do - let(:filter) { ['Statut', 'en_construction'] } - - let!(:en_construction) { create(:dossier, :en_construction, procedure:) } - let!(:en_construction_with_correction) { create(:dossier, :en_construction, procedure:) } - let!(:correction) { create(:dossier_correction, dossier: en_construction_with_correction) } - it 'excludes dossier en construction with pending correction' do - is_expected.to contain_exactly(en_construction.id) - end - end - end - - context 'for type_de_champ table' do - let(:filter) { [type_de_champ.libelle, 'keep'] } - - let(:kept_dossier) { create(:dossier, procedure: procedure) } - let(:discarded_dossier) { create(:dossier, procedure: procedure) } - let(:type_de_champ) { procedure.active_revision.types_de_champ_public.first } - - context 'with single value' do - before do - kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'keep me') - discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'discard me') - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'with multiple search values' do - let(:filters) { [[type_de_champ.libelle, 'keep'], [type_de_champ.libelle, 'and']] } - let(:other_kept_dossier) { create(:dossier, procedure: procedure) } - - before do - kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'keep me') - discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'discard me') - other_kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'and me too') - end - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - - context 'with yes_no type_de_champ' do - let(:filter) { [type_de_champ.libelle, 'true'] } - let(:types_de_champ_public) { [{ type: :yes_no }] } - - before do - kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'true') - discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'false') - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'with departement type_de_champ' do - let(:filter) { [type_de_champ.libelle, '13'] } - let(:types_de_champ_public) { [{ type: :departements }] } - - before do - kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(external_id: '13') - discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(external_id: '69') - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'with enum type_de_champ' do - let(:filter) { [type_de_champ.libelle, 'Favorable'] } - let(:types_de_champ_public) { [{ type: :drop_down_list, options: ['Favorable', 'Defavorable'] }] } - - before do - kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'Favorable') - discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(external_id: 'Defavorable') - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - end - - context 'for type_de_champ_private table' do - let(:filter) { [type_de_champ_private.libelle, 'keep'] } - - let(:kept_dossier) { create(:dossier, procedure: procedure) } - let(:discarded_dossier) { create(:dossier, procedure: procedure) } - let(:type_de_champ_private) { procedure.active_revision.types_de_champ_private.first } - - before do - kept_dossier.champs.find_by(stable_id: type_de_champ_private.stable_id).update(value: 'keep me') - discarded_dossier.champs.find_by(stable_id: type_de_champ_private.stable_id).update(value: 'discard me') - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'for type_de_champ using AddressableColumnConcern' do - let(:column) { filtered_columns.first.column } - let(:types_de_champ_public) { [{ type: :rna, stable_id: 1, libelle: 'rna' }] } - let(:type_de_champ) { procedure.active_revision.types_de_champ.first } - let(:kept_dossier) { create(:dossier, procedure: procedure) } - - context "when searching by postal_code (text)" do - let(:value) { "60580" } - let(:filter) { ["rna – code postal (5 chiffres)", value] } - - before do - kept_dossier.project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "postal_code" => value }) - create(:dossier, procedure: procedure).project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "postal_code" => "unknown" }) - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - - it 'describes column' do - expect(column.type).to eq(:text) - expect(column.options_for_select).to eq([]) - end - end - - context "when searching by departement_code (enum)" do - let(:value) { "99" } - let(:filter) { ["rna – département", value] } - - before do - kept_dossier.project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "departement_code" => value }) - create(:dossier, procedure: procedure).project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "departement_code" => "unknown" }) - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - - it 'describes column' do - expect(column.type).to eq(:enum) - expect(column.options_for_select.first).to eq(["99 – Etranger", "99"]) - end - end - - context "when searching by region_name" do - let(:value) { "60" } - let(:filter) { ["rna – region", value] } - - before do - kept_dossier.project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "region_name" => value }) - create(:dossier, procedure: procedure).project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "region_name" => "unknown" }) - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - - it 'describes column' do - expect(column.type).to eq(:enum) - expect(column.options_for_select.first).to eq(["Auvergne-Rhône-Alpes", "Auvergne-Rhône-Alpes"]) - end - end - end - - context 'for etablissement table' do - context 'for entreprise_date_creation column' do - let(:filter) { ['Date de création', '21/6/2018'] } - - let!(:kept_dossier) { create(:dossier, procedure: procedure, etablissement: create(:etablissement, entreprise_date_creation: Time.zone.local(2018, 6, 21))) } - let!(:discarded_dossier) { create(:dossier, procedure: procedure, etablissement: create(:etablissement, entreprise_date_creation: Time.zone.local(2008, 6, 21))) } - - it { is_expected.to contain_exactly(kept_dossier.id) } - - context 'with multiple search values' do - let(:filters) { [['Date de création', '21/6/2016'], ['Date de création', '21/6/2018']] } - - let!(:other_kept_dossier) { create(:dossier, procedure: procedure, etablissement: create(:etablissement, entreprise_date_creation: Time.zone.local(2016, 6, 21))) } - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - end - - context 'for code_postal column' do - # All columns except entreprise_date_creation work exacly the same, just testing one - - let(:filter) { ['Code postal', '75017'] } - - let!(:kept_dossier) { create(:dossier, procedure: procedure, etablissement: create(:etablissement, code_postal: '75017')) } - let!(:discarded_dossier) { create(:dossier, procedure: procedure, etablissement: create(:etablissement, code_postal: '25000')) } - - it { is_expected.to contain_exactly(kept_dossier.id) } - - context 'with multiple search values' do - let(:filters) { [['Code postal', '75017'], ['Code postal', '88100']] } - - let!(:other_kept_dossier) { create(:dossier, procedure: procedure, etablissement: create(:etablissement, code_postal: '88100')) } - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - end - end - - context 'for user table' do - let(:filter) { ['Demandeur', 'keepmail'] } - - let!(:kept_dossier) { create(:dossier, procedure: procedure, user: create(:user, email: 'me@keepmail.com')) } - let!(:discarded_dossier) { create(:dossier, procedure: procedure, user: create(:user, email: 'me@discard.com')) } - - it { is_expected.to contain_exactly(kept_dossier.id) } - - context 'with multiple search values' do - let(:filters) { [['Demandeur', 'keepmail'], ['Demandeur', 'beta.gouv.fr']] } - - let!(:other_kept_dossier) { create(:dossier, procedure: procedure, user: create(:user, email: 'bazinga@beta.gouv.fr')) } - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - end - - context 'for individual table' do - let(:procedure) { create(:procedure, :for_individual) } - let!(:kept_dossier) { create(:dossier, procedure: procedure, individual: build(:individual, gender: 'Mme', prenom: 'Josephine', nom: 'Baker')) } - let!(:discarded_dossier) { create(:dossier, procedure: procedure, individual: build(:individual, gender: 'M', prenom: 'Jean', nom: 'Tremblay')) } - - context 'for gender column' do - let(:filter) { ['Civilité', 'Mme'] } - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'for prenom column' do - let(:filter) { ['Prénom', 'Josephine'] } - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'for nom column' do - let(:filter) { ['Nom', 'Baker'] } - - it { is_expected.to contain_exactly(kept_dossier.id) } - end - - context 'with multiple search values' do - let(:filters) { [['Prénom', 'Josephine'], ['Prénom', 'Romuald']] } - - let!(:other_kept_dossier) { create(:dossier, procedure: procedure, individual: build(:individual, gender: 'M', prenom: 'Romuald', nom: 'Pistis')) } - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - end - - context 'for followers_instructeurs table' do - let(:filter) { ['Email instructeur', 'keepmail'] } - - let!(:kept_dossier) { create(:dossier, procedure: procedure) } - let!(:discarded_dossier) { create(:dossier, procedure: procedure) } - - before do - create(:follow, dossier: kept_dossier, instructeur: create(:instructeur, email: 'me@keepmail.com')) - create(:follow, dossier: discarded_dossier, instructeur: create(:instructeur, email: 'me@discard.com')) - end - - it { is_expected.to contain_exactly(kept_dossier.id) } - - context 'with multiple search values' do - let(:filters) { [['Email instructeur', 'keepmail'], ['Email instructeur', 'beta.gouv.fr']] } - - let(:other_kept_dossier) { create(:dossier, procedure:) } - - before do - create(:follow, dossier: other_kept_dossier, instructeur: create(:instructeur, email: 'bazinga@beta.gouv.fr')) - end - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - end - - context 'for groupe_instructeur table' do - let(:filter) { ['Groupe instructeur', procedure.defaut_groupe_instructeur.id.to_s] } - - let!(:gi_2) { create(:groupe_instructeur, label: 'gi2', procedure:) } - let!(:gi_3) { create(:groupe_instructeur, label: 'gi3', procedure:) } - - let!(:kept_dossier) { create(:dossier, :en_construction, procedure:) } - let!(:discarded_dossier) { create(:dossier, :en_construction, procedure:, groupe_instructeur: gi_2) } - - it { is_expected.to contain_exactly(kept_dossier.id) } - - context 'with multiple search values' do - let(:filters) { [['Groupe instructeur', procedure.defaut_groupe_instructeur.id.to_s], ['Groupe instructeur', gi_3.id.to_s]] } - - let!(:other_kept_dossier) { create(:dossier, procedure:, groupe_instructeur: gi_3) } - - it 'returns every dossier that matches any of the search criteria for a given column' do - is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) - end - end - end - end - describe "#human_value_for_filter" do let(:filtered_column) { to_filter([first_type_de_champ.libelle, "true"]) } @@ -742,54 +93,6 @@ describe ProcedurePresentation do end end - describe '#filtered_sorted_ids' do - let(:procedure_presentation) { create(:procedure_presentation, assign_to:) } - - subject { procedure_presentation.filtered_sorted_ids(dossiers, statut) } - - context 'with no filters' do - let(:statut) { 'suivis' } - let(:dossiers) { procedure.dossiers } - - before do - create(:follow, dossier: en_construction_dossier, instructeur: procedure_presentation.instructeur) - create(:follow, dossier: accepte_dossier, instructeur: procedure_presentation.instructeur) - end - - let(:en_construction_dossier) { create(:dossier, :en_construction, procedure:) } - let(:accepte_dossier) { create(:dossier, :accepte, procedure:) } - - it { is_expected.to contain_exactly(en_construction_dossier.id) } - end - - context 'with mocked sorted_ids' do - let(:dossier_1) { create(:dossier) } - let(:dossier_2) { create(:dossier) } - let(:dossier_3) { create(:dossier) } - let(:dossiers) { Dossier.where(id: [dossier_1, dossier_2, dossier_3].map(&:id)) } - - let(:sorted_ids) { [dossier_2, dossier_3, dossier_1].map(&:id) } - let(:statut) { 'tous' } - - before do - expect(procedure_presentation).to receive(:sorted_ids).and_return(sorted_ids) - end - - it { is_expected.to eq(sorted_ids) } - - context 'when a filter is present' do - let(:filtered_ids) { [dossier_1, dossier_2, dossier_3].map(&:id) } - - before do - procedure_presentation.tous_filters = [to_filter(['Statut', 'en_construction'])] - expect(procedure_presentation).to receive(:filtered_ids).and_return(filtered_ids) - end - - it { is_expected.to eq(sorted_ids) } - end - end - end - describe '#update_displayed_fields' do let(:en_construction_column) { procedure.find_column(label: 'En construction le') } let(:mise_a_jour_column) { procedure.find_column(label: 'Mis à jour le') } diff --git a/spec/services/dossier_filter_service_spec.rb b/spec/services/dossier_filter_service_spec.rb new file mode 100644 index 000000000..95737dd25 --- /dev/null +++ b/spec/services/dossier_filter_service_spec.rb @@ -0,0 +1,709 @@ +# frozen_string_literal: true + +describe DossierFilterService do + def to_filter((label, filter)) = FilteredColumn.new(column: procedure.find_column(label:), filter:) + + describe '.filtered_sorted_ids' do + let(:procedure) { create(:procedure) } + let(:instructeur) { create(:instructeur) } + let(:dossiers) { procedure.dossiers } + let(:statut) { 'suivis' } + let(:filters) { [] } + let(:sorted_columns) { procedure.default_sorted_column } + + subject { described_class.filtered_sorted_ids(dossiers, statut, filters, sorted_columns, instructeur) } + + context 'with no filters' do + let(:en_construction_dossier) { create(:dossier, :en_construction, procedure:) } + let(:accepte_dossier) { create(:dossier, :accepte, procedure:) } + + before do + create(:follow, dossier: en_construction_dossier, instructeur:) + create(:follow, dossier: accepte_dossier, instructeur:) + end + + it { is_expected.to contain_exactly(en_construction_dossier.id) } + end + + context 'with mocked sorted_ids' do + let(:dossier_1) { create(:dossier) } + let(:dossier_2) { create(:dossier) } + let(:dossier_3) { create(:dossier) } + let(:dossiers) { Dossier.where(id: [dossier_1, dossier_2, dossier_3].map(&:id)) } + + let(:sorted_ids) { [dossier_2, dossier_3, dossier_1].map(&:id) } + + before do + expect(described_class).to receive(:sorted_ids).and_return(sorted_ids) + end + + it { is_expected.to eq(sorted_ids) } + + context 'when a filter is present' do + let(:filtered_ids) { [dossier_1, dossier_2, dossier_3].map(&:id) } + let(:filters) { [to_filter(['Statut', 'en_construction'])] } + + before do + expect(described_class).to receive(:filtered_ids).and_return(filtered_ids) + end + + it { is_expected.to eq(sorted_ids) } + end + end + end + + describe '#sorted_ids' do + let(:procedure) { create(:procedure, :published, types_de_champ_public:, types_de_champ_private: [{}]) } + let(:types_de_champ_public) { [{}] } + let(:first_type_de_champ) { assign_to.procedure.active_revision.types_de_champ_public.first } + let(:dossiers) { procedure.dossiers } + let(:instructeur) { create(:instructeur) } + let(:assign_to) { create(:assign_to, procedure:, instructeur:) } + let(:sorted_column) { SortedColumn.new(column:, order:) } + + subject { described_class.send(:sorted_ids, dossiers, sorted_column, instructeur, dossiers.count) } + + context 'for notifications table' do + let(:column) { procedure.notifications_column } + + let!(:notified_dossier) { create(:dossier, :en_construction, procedure:) } + let!(:recent_dossier) { create(:dossier, :en_construction, procedure:) } + let!(:older_dossier) { create(:dossier, :en_construction, procedure:) } + + before do + notified_dossier.update!(last_champ_updated_at: Time.zone.local(2018, 9, 20)) + create(:follow, instructeur: instructeur, dossier: notified_dossier, demande_seen_at: Time.zone.local(2018, 9, 10)) + notified_dossier.touch(time: Time.zone.local(2018, 9, 20)) + recent_dossier.touch(time: Time.zone.local(2018, 9, 25)) + older_dossier.touch(time: Time.zone.local(2018, 5, 13)) + end + + context 'in ascending order' do + let(:order) { 'asc' } + + it { is_expected.to eq([older_dossier, recent_dossier, notified_dossier].map(&:id)) } + end + + context 'in descending order' do + let(:order) { 'desc' } + + it { is_expected.to eq([notified_dossier, recent_dossier, older_dossier].map(&:id)) } + end + + context 'with a dossier terminé' do + let!(:notified_dossier) { create(:dossier, :accepte, procedure:) } + let(:order) { 'desc' } + + it { is_expected.to eq([notified_dossier, recent_dossier, older_dossier].map(&:id)) } + end + end + + context 'for self table' do + let(:order) { 'asc' } # Desc works the same, no extra test required + + context 'for created_at column' do + let!(:column) { procedure.find_column(label: 'Créé le') } + let!(:recent_dossier) { Timecop.freeze(Time.zone.local(2018, 10, 17)) { create(:dossier, procedure:) } } + let!(:older_dossier) { Timecop.freeze(Time.zone.local(2003, 11, 11)) { create(:dossier, procedure:) } } + + it { is_expected.to eq([older_dossier, recent_dossier].map(&:id)) } + end + + context 'for en_construction_at column' do + let!(:column) { procedure.find_column(label: 'En construction le') } + let!(:recent_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2018, 10, 17)) } + let!(:older_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2013, 1, 1)) } + + it { is_expected.to eq([older_dossier, recent_dossier].map(&:id)) } + end + + context 'for updated_at column' do + let(:column) { procedure.find_column(label: 'Mis à jour le') } + let(:recent_dossier) { create(:dossier, procedure:) } + let(:older_dossier) { create(:dossier, procedure:) } + + before do + recent_dossier.touch(time: Time.zone.local(2018, 9, 25)) + older_dossier.touch(time: Time.zone.local(2018, 5, 13)) + end + + it { is_expected.to eq([older_dossier, recent_dossier].map(&:id)) } + end + end + + context 'for type_de_champ table' do + context 'with no revisions' do + let(:column) { procedure.find_column(label: first_type_de_champ.libelle) } + + let(:beurre_dossier) { create(:dossier, procedure:) } + let(:tartine_dossier) { create(:dossier, procedure:) } + + before do + beurre_dossier.project_champs_public.first.update(value: 'beurre') + tartine_dossier.project_champs_public.first.update(value: 'tartine') + end + + context 'asc' do + let(:order) { 'asc' } + + it { is_expected.to eq([beurre_dossier, tartine_dossier].map(&:id)) } + end + + context 'desc' do + let(:order) { 'desc' } + + it { is_expected.to eq([tartine_dossier, beurre_dossier].map(&:id)) } + end + end + + context 'with a revision adding a new type_de_champ' do + let!(:tdc) { { type_champ: :text, libelle: 'nouveau champ' } } + let(:column) { procedure.find_column(label: 'nouveau champ') } + + let!(:nothing_dossier) { create(:dossier, procedure:) } + let!(:beurre_dossier) { create(:dossier, procedure:) } + let!(:tartine_dossier) { create(:dossier, procedure:) } + + before do + nothing_dossier + procedure.draft_revision.add_type_de_champ(tdc) + procedure.publish_revision! + beurre_dossier.project_champs_public.last.update(value: 'beurre') + tartine_dossier.project_champs_public.last.update(value: 'tartine') + end + + context 'asc' do + let(:order) { 'asc' } + it { is_expected.to eq([nothing_dossier, beurre_dossier, tartine_dossier].map(&:id)) } + end + + context 'desc' do + let(:order) { 'desc' } + it { is_expected.to eq([tartine_dossier, beurre_dossier, nothing_dossier].map(&:id)) } + end + end + end + + context 'for type_de_champ_private table' do + context 'with no revisions' do + let(:column) { procedure.find_column(label: procedure.active_revision.types_de_champ_private.first.libelle) } + + let(:biere_dossier) { create(:dossier, procedure:) } + let(:vin_dossier) { create(:dossier, procedure:) } + + before do + biere_dossier.project_champs_private.first.update(value: 'biere') + vin_dossier.project_champs_private.first.update(value: 'vin') + end + + context 'asc' do + let(:order) { 'asc' } + + it { is_expected.to eq([biere_dossier, vin_dossier].map(&:id)) } + end + + context 'desc' do + let(:order) { 'desc' } + + it { is_expected.to eq([vin_dossier, biere_dossier].map(&:id)) } + end + end + end + + context 'for individual table' do + let(:order) { 'asc' } # Desc works the same, no extra test required + + let(:procedure) { create(:procedure, :for_individual) } + + let!(:first_dossier) { create(:dossier, procedure:, individual: build(:individual, gender: 'M', prenom: 'Alain', nom: 'Antonelli')) } + let!(:last_dossier) { create(:dossier, procedure:, individual: build(:individual, gender: 'Mme', prenom: 'Zora', nom: 'Zemmour')) } + + context 'for gender column' do + let(:column) { procedure.find_column(label: 'Civilité') } + + it { is_expected.to eq([first_dossier, last_dossier].map(&:id)) } + end + + context 'for prenom column' do + let(:column) { procedure.find_column(label: 'Prénom') } + + it { is_expected.to eq([first_dossier, last_dossier].map(&:id)) } + end + + context 'for nom column' do + let(:column) { procedure.find_column(label: 'Nom') } + + it { is_expected.to eq([first_dossier, last_dossier].map(&:id)) } + end + end + + context 'for followers_instructeurs table' do + let(:order) { 'asc' } # Desc works the same, no extra test required + + let!(:dossier_z) { create(:dossier, :en_construction, procedure:) } + let!(:dossier_a) { create(:dossier, :en_construction, procedure:) } + let!(:dossier_without_instructeur) { create(:dossier, :en_construction, procedure:) } + + before do + create(:follow, dossier: dossier_z, instructeur: create(:instructeur, email: 'zythum@exemple.fr')) + create(:follow, dossier: dossier_a, instructeur: create(:instructeur, email: 'abaca@exemple.fr')) + create(:follow, dossier: dossier_a, instructeur: create(:instructeur, email: 'abaca2@exemple.fr')) + end + + context 'for email column' do + let(:column) { procedure.find_column(label: 'Email instructeur') } + + it { is_expected.to eq([dossier_a, dossier_z, dossier_without_instructeur].map(&:id)) } + end + end + + context 'for avis table' do + let(:column) { procedure.find_column(label: 'Avis oui/non') } + let(:order) { 'asc' } + + let!(:dossier_yes) { create(:dossier, procedure:) } + let!(:dossier_no) { create(:dossier, procedure:) } + + before do + create_list(:avis, 2, dossier: dossier_yes, question_answer: true) + create(:avis, dossier: dossier_no, question_answer: true) + create(:avis, dossier: dossier_no, question_answer: false) + end + + it { is_expected.to eq([dossier_no, dossier_yes].map(&:id)) } + end + + context 'for other tables' do + # All other columns and tables work the same so it’s ok to test only one + let(:column) { procedure.find_column(label: 'Code postal') } + let(:order) { 'asc' } # Desc works the same, no extra test required + + let!(:huitieme_dossier) { create(:dossier, procedure:, etablissement: create(:etablissement, code_postal: '75008')) } + let!(:vingtieme_dossier) { create(:dossier, procedure:, etablissement: create(:etablissement, code_postal: '75020')) } + + it { is_expected.to eq([huitieme_dossier, vingtieme_dossier].map(&:id)) } + end + end + + describe '#filtered_ids' do + let(:procedure) { create(:procedure, types_de_champ_public:, types_de_champ_private:) } + let(:types_de_champ_public) { [{}] } + let(:types_de_champ_private) { [{}] } + let(:dossiers) { procedure.dossiers } + let(:filtered_columns) { filters.map { to_filter(_1) } } + let(:filters) { [filter] } + + subject { described_class.send(:filtered_ids, dossiers.joins(:user), filtered_columns) } + + context 'for self table' do + context 'for created_at column' do + let(:filter) { ['Créé le', '18/9/2018'] } + + let!(:kept_dossier) { create(:dossier, procedure:, created_at: Time.zone.local(2018, 9, 18, 14, 28)) } + let!(:discarded_dossier) { create(:dossier, procedure:, created_at: Time.zone.local(2018, 9, 17, 23, 59)) } + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'for en_construction_at column' do + let(:filter) { ['En construction le', '17/10/2018'] } + + let!(:kept_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2018, 10, 17)) } + let!(:discarded_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2013, 1, 1)) } + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'for updated_at column' do + let(:filter) { ['Mis à jour le', '18/9/2018'] } + + let(:kept_dossier) { create(:dossier, procedure:) } + let(:discarded_dossier) { create(:dossier, procedure:) } + + before do + kept_dossier.touch(time: Time.zone.local(2018, 9, 18, 14, 28)) + discarded_dossier.touch(time: Time.zone.local(2018, 9, 17, 23, 59)) + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'for updated_since column' do + let(:filter) { ['Mis à jour depuis', '18/9/2018'] } + + let(:kept_dossier) { create(:dossier, procedure:) } + let(:later_dossier) { create(:dossier, procedure:) } + let(:discarded_dossier) { create(:dossier, procedure:) } + + before do + kept_dossier.touch(time: Time.zone.local(2018, 9, 18, 14, 28)) + later_dossier.touch(time: Time.zone.local(2018, 9, 19, 14, 28)) + discarded_dossier.touch(time: Time.zone.local(2018, 9, 17, 14, 28)) + end + + it { is_expected.to match_array([kept_dossier.id, later_dossier.id]) } + end + + context 'for sva_svr_decision_before column' do + before do + travel_to Time.zone.local(2023, 6, 10, 10) + end + + let(:procedure) { create(:procedure, :published, :sva, types_de_champ_public: [{}], types_de_champ_private: [{}]) } + let(:filter) { ['Date décision SVA avant', '15/06/2023'] } + + let!(:kept_dossier) { create(:dossier, :en_instruction, procedure:, sva_svr_decision_on: Date.current) } + let!(:later_dossier) { create(:dossier, :en_instruction, procedure:, sva_svr_decision_on: Date.current + 2.days) } + let!(:discarded_dossier) { create(:dossier, :en_instruction, procedure:, sva_svr_decision_on: Date.current + 10.days) } + let!(:en_construction_dossier) { create(:dossier, :en_construction, procedure:, sva_svr_decision_on: Date.current + 2.days) } + let!(:accepte_dossier) { create(:dossier, :accepte, procedure:, sva_svr_decision_on: Date.current + 2.days) } + + it { is_expected.to match_array([kept_dossier.id, later_dossier.id, en_construction_dossier.id]) } + end + + context 'ignore time of day' do + let(:filter) { ['En construction le', '17/10/2018 19:30'] } + + let!(:kept_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2018, 10, 17, 15, 56)) } + let!(:discarded_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2018, 10, 18, 5, 42)) } + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'for a malformed date' do + context 'when its a string' do + let(:filter) { ['Mis à jour le', 'malformed date'] } + + it { is_expected.to match([]) } + end + + context 'when its a number' do + let(:filter) { ['Mis à jour le', '177500'] } + + it { is_expected.to match([]) } + end + end + + context 'with multiple search values' do + let(:filters) { [['En construction le', '17/10/2018'], ['En construction le', '19/10/2018']] } + + let!(:kept_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2018, 10, 17)) } + let!(:other_kept_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2018, 10, 19)) } + let!(:discarded_dossier) { create(:dossier, :en_construction, procedure:, en_construction_at: Time.zone.local(2013, 1, 1)) } + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + + context 'with multiple state filters' do + let(:filters) { [['Statut', 'en_construction'], ['Statut', 'en_instruction']] } + + let!(:kept_dossier) { create(:dossier, :en_construction, procedure:) } + let!(:other_kept_dossier) { create(:dossier, :en_instruction, procedure:) } + let!(:discarded_dossier) { create(:dossier, :accepte, procedure:) } + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + + context 'with en_construction state filters' do + let(:filter) { ['Statut', 'en_construction'] } + + let!(:en_construction) { create(:dossier, :en_construction, procedure:) } + let!(:en_construction_with_correction) { create(:dossier, :en_construction, procedure:) } + let!(:correction) { create(:dossier_correction, dossier: en_construction_with_correction) } + it 'excludes dossier en construction with pending correction' do + is_expected.to contain_exactly(en_construction.id) + end + end + end + + context 'for type_de_champ table' do + let(:filter) { [type_de_champ.libelle, 'keep'] } + + let(:kept_dossier) { create(:dossier, procedure:) } + let(:discarded_dossier) { create(:dossier, procedure:) } + let(:type_de_champ) { procedure.active_revision.types_de_champ_public.first } + + context 'with single value' do + before do + kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'keep me') + discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'discard me') + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'with multiple search values' do + let(:filters) { [[type_de_champ.libelle, 'keep'], [type_de_champ.libelle, 'and']] } + let(:other_kept_dossier) { create(:dossier, procedure:) } + + before do + kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'keep me') + discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'discard me') + other_kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'and me too') + end + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + + context 'with yes_no type_de_champ' do + let(:filter) { [type_de_champ.libelle, 'true'] } + let(:types_de_champ_public) { [{ type: :yes_no }] } + + before do + kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'true') + discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'false') + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'with departement type_de_champ' do + let(:filter) { [type_de_champ.libelle, '13'] } + let(:types_de_champ_public) { [{ type: :departements }] } + + before do + kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(external_id: '13') + discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(external_id: '69') + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'with enum type_de_champ' do + let(:filter) { [type_de_champ.libelle, 'Favorable'] } + let(:types_de_champ_public) { [{ type: :drop_down_list, options: ['Favorable', 'Defavorable'] }] } + + before do + kept_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(value: 'Favorable') + discarded_dossier.champs.find_by(stable_id: type_de_champ.stable_id).update(external_id: 'Defavorable') + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + end + + context 'for type_de_champ_private table' do + let(:filter) { [type_de_champ_private.libelle, 'keep'] } + + let(:kept_dossier) { create(:dossier, procedure:) } + let(:discarded_dossier) { create(:dossier, procedure:) } + let(:type_de_champ_private) { procedure.active_revision.types_de_champ_private.first } + + before do + kept_dossier.champs.find_by(stable_id: type_de_champ_private.stable_id).update(value: 'keep me') + discarded_dossier.champs.find_by(stable_id: type_de_champ_private.stable_id).update(value: 'discard me') + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'for type_de_champ using AddressableColumnConcern' do + let(:column) { filtered_columns.first.column } + let(:types_de_champ_public) { [{ type: :rna, stable_id: 1, libelle: 'rna' }] } + let(:type_de_champ) { procedure.active_revision.types_de_champ.first } + let(:kept_dossier) { create(:dossier, procedure:) } + + context "when searching by postal_code (text)" do + let(:value) { "60580" } + let(:filter) { ["rna – code postal (5 chiffres)", value] } + + before do + kept_dossier.project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "postal_code" => value }) + create(:dossier, procedure:).project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "postal_code" => "unknown" }) + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + + it 'describes column' do + expect(column.type).to eq(:text) + expect(column.options_for_select).to eq([]) + end + end + + context "when searching by departement_code (enum)" do + let(:value) { "99" } + let(:filter) { ["rna – département", value] } + + before do + kept_dossier.project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "departement_code" => value }) + create(:dossier, procedure:).project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "departement_code" => "unknown" }) + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + + it 'describes column' do + expect(column.type).to eq(:enum) + expect(column.options_for_select.first).to eq(["99 – Etranger", "99"]) + end + end + + context "when searching by region_name" do + let(:value) { "60" } + let(:filter) { ["rna – region", value] } + + before do + kept_dossier.project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "region_name" => value }) + create(:dossier, procedure:).project_champs_public.find { _1.stable_id == 1 }.update(value_json: { "region_name" => "unknown" }) + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + + it 'describes column' do + expect(column.type).to eq(:enum) + expect(column.options_for_select.first).to eq(["Auvergne-Rhône-Alpes", "Auvergne-Rhône-Alpes"]) + end + end + end + + context 'for etablissement table' do + context 'for entreprise_date_creation column' do + let(:filter) { ['Date de création', '21/6/2018'] } + + let!(:kept_dossier) { create(:dossier, procedure:, etablissement: create(:etablissement, entreprise_date_creation: Time.zone.local(2018, 6, 21))) } + let!(:discarded_dossier) { create(:dossier, procedure:, etablissement: create(:etablissement, entreprise_date_creation: Time.zone.local(2008, 6, 21))) } + + it { is_expected.to contain_exactly(kept_dossier.id) } + + context 'with multiple search values' do + let(:filters) { [['Date de création', '21/6/2016'], ['Date de création', '21/6/2018']] } + + let!(:other_kept_dossier) { create(:dossier, procedure:, etablissement: create(:etablissement, entreprise_date_creation: Time.zone.local(2016, 6, 21))) } + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + end + + context 'for code_postal column' do + # All columns except entreprise_date_creation work exacly the same, just testing one + + let(:filter) { ['Code postal', '75017'] } + + let!(:kept_dossier) { create(:dossier, procedure:, etablissement: create(:etablissement, code_postal: '75017')) } + let!(:discarded_dossier) { create(:dossier, procedure:, etablissement: create(:etablissement, code_postal: '25000')) } + + it { is_expected.to contain_exactly(kept_dossier.id) } + + context 'with multiple search values' do + let(:filters) { [['Code postal', '75017'], ['Code postal', '88100']] } + + let!(:other_kept_dossier) { create(:dossier, procedure:, etablissement: create(:etablissement, code_postal: '88100')) } + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + end + end + + context 'for user table' do + let(:filter) { ['Demandeur', 'keepmail'] } + + let!(:kept_dossier) { create(:dossier, procedure:, user: create(:user, email: 'me@keepmail.com')) } + let!(:discarded_dossier) { create(:dossier, procedure:, user: create(:user, email: 'me@discard.com')) } + + it { is_expected.to contain_exactly(kept_dossier.id) } + + context 'with multiple search values' do + let(:filters) { [['Demandeur', 'keepmail'], ['Demandeur', 'beta.gouv.fr']] } + + let!(:other_kept_dossier) { create(:dossier, procedure:, user: create(:user, email: 'bazinga@beta.gouv.fr')) } + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + end + + context 'for individual table' do + let(:procedure) { create(:procedure, :for_individual) } + let!(:kept_dossier) { create(:dossier, procedure:, individual: build(:individual, gender: 'Mme', prenom: 'Josephine', nom: 'Baker')) } + let!(:discarded_dossier) { create(:dossier, procedure:, individual: build(:individual, gender: 'M', prenom: 'Jean', nom: 'Tremblay')) } + + context 'for gender column' do + let(:filter) { ['Civilité', 'Mme'] } + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'for prenom column' do + let(:filter) { ['Prénom', 'Josephine'] } + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'for nom column' do + let(:filter) { ['Nom', 'Baker'] } + + it { is_expected.to contain_exactly(kept_dossier.id) } + end + + context 'with multiple search values' do + let(:filters) { [['Prénom', 'Josephine'], ['Prénom', 'Romuald']] } + + let!(:other_kept_dossier) { create(:dossier, procedure:, individual: build(:individual, gender: 'M', prenom: 'Romuald', nom: 'Pistis')) } + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + end + + context 'for followers_instructeurs table' do + let(:filter) { ['Email instructeur', 'keepmail'] } + + let!(:kept_dossier) { create(:dossier, procedure:) } + let!(:discarded_dossier) { create(:dossier, procedure:) } + + before do + create(:follow, dossier: kept_dossier, instructeur: create(:instructeur, email: 'me@keepmail.com')) + create(:follow, dossier: discarded_dossier, instructeur: create(:instructeur, email: 'me@discard.com')) + end + + it { is_expected.to contain_exactly(kept_dossier.id) } + + context 'with multiple search values' do + let(:filters) { [['Email instructeur', 'keepmail'], ['Email instructeur', 'beta.gouv.fr']] } + + let(:other_kept_dossier) { create(:dossier, procedure:) } + + before do + create(:follow, dossier: other_kept_dossier, instructeur: create(:instructeur, email: 'bazinga@beta.gouv.fr')) + end + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + end + + context 'for groupe_instructeur table' do + let(:filter) { ['Groupe instructeur', procedure.defaut_groupe_instructeur.id.to_s] } + + let!(:gi_2) { create(:groupe_instructeur, label: 'gi2', procedure:) } + let!(:gi_3) { create(:groupe_instructeur, label: 'gi3', procedure:) } + + let!(:kept_dossier) { create(:dossier, :en_construction, procedure:) } + let!(:discarded_dossier) { create(:dossier, :en_construction, procedure:, groupe_instructeur: gi_2) } + + it { is_expected.to contain_exactly(kept_dossier.id) } + + context 'with multiple search values' do + let(:filters) { [['Groupe instructeur', procedure.defaut_groupe_instructeur.id.to_s], ['Groupe instructeur', gi_3.id.to_s]] } + + let!(:other_kept_dossier) { create(:dossier, procedure:, groupe_instructeur: gi_3) } + + it 'returns every dossier that matches any of the search criteria for a given column' do + is_expected.to contain_exactly(kept_dossier.id, other_kept_dossier.id) + end + end + end + end +end