demarches-normaliennes/app/models/champ.rb

280 lines
6.9 KiB
Ruby
Raw Normal View History

2018-03-06 13:44:29 +01:00
class Champ < ApplicationRecord
include ChampConditionalConcern
belongs_to :dossier, inverse_of: false, touch: true, optional: false
belongs_to :type_de_champ, inverse_of: :champ, optional: false
belongs_to :parent, class_name: 'Champ', optional: true
has_many_attached :piece_justificative_file
2019-07-11 10:28:44 +02:00
# We declare champ specific relationships (Champs::CarteChamp, Champs::SiretChamp and Champs::RepetitionChamp)
2018-11-08 14:36:53 +01:00
# here because otherwise we can't easily use includes in our queries.
2021-05-25 16:10:01 +02:00
has_many :geo_areas, -> { order(:created_at) }, dependent: :destroy, inverse_of: :champ
belongs_to :etablissement, optional: true, dependent: :destroy
has_many :champs, -> { ordered }, foreign_key: :parent_id, inverse_of: :parent
2018-11-08 14:36:53 +01:00
delegate :procedure, to: :dossier
2020-06-18 13:27:55 +02:00
delegate :libelle,
:type_champ,
:description,
:drop_down_list_options,
:drop_down_other?,
2020-06-18 13:27:55 +02:00
:drop_down_list_options?,
:drop_down_list_disabled_options,
:drop_down_list_enabled_non_empty_options,
:drop_down_secondary_libelle,
:drop_down_secondary_description,
:collapsible_explanation_enabled?,
:collapsible_explanation_text,
:header_section_level_value,
:current_section_level,
2020-06-18 13:27:55 +02:00
:exclude_from_export?,
:exclude_from_view?,
:repetition?,
:block?,
2020-06-18 13:27:55 +02:00
:dossier_link?,
:departement?,
:region?,
2023-05-05 09:13:05 +02:00
:textarea?,
:titre_identite?,
:header_section?,
:checkbox?,
:simple_drop_down_list?,
:linked_drop_down_list?,
:non_fillable?,
:fillable?,
:cnaf?,
:dgfip?,
:pole_emploi?,
:mesri?,
2022-09-21 15:18:08 +02:00
:rna?,
:siret?,
2022-11-16 11:50:19 +01:00
:carte?,
:datetime?,
2022-05-23 11:22:37 +02:00
:stable_id,
:mandatory?,
:prefillable?,
:refresh_after_update?,
:character_limit?,
:character_limit,
2020-06-18 13:27:55 +02:00
to: :type_de_champ
2023-02-22 19:32:25 +01:00
delegate :to_typed_id, :to_typed_id_for_query, to: :type_de_champ, prefix: true
2023-02-15 12:15:34 +01:00
2023-01-26 17:57:57 +01:00
delegate :revision, to: :dossier, prefix: true
scope :updated_since?, -> (date) { where('champs.updated_at > ?', date) }
2018-02-14 11:46:38 +01:00
scope :public_only, -> { where(private: false) }
scope :private_only, -> { where(private: true) }
scope :ordered, -> do
includes(:type_de_champ)
.joins(dossier: { revision: :revision_types_de_champ })
.where('procedure_revision_types_de_champ.type_de_champ_id = champs.type_de_champ_id')
.order(:row_id, :position)
2020-09-03 18:28:49 +02:00
end
scope :public_ordered, -> { public_only.ordered }
scope :private_ordered, -> { private_only.ordered }
scope :root, -> { where(parent_id: nil) }
2022-12-01 12:00:21 +01:00
scope :prefilled, -> { where(prefilled: true) }
2020-09-30 15:56:06 +02:00
before_create :set_dossier_id, if: :needs_dossier_id?
before_validation :set_dossier_id, if: :needs_dossier_id?
2022-10-11 15:11:51 +02:00
before_save :cleanup_if_empty
before_save :normalize
2022-10-11 11:52:59 +02:00
after_update_commit :fetch_external_data_later
2018-02-09 17:38:30 +01:00
def public?
!private?
end
def child?
parent_id.present?
end
def stable_id_with_row
[row_id, stable_id].compact
end
def sections
@sections ||= dossier.sections_for(self)
end
# used for the `required` html attribute
# check visibility to avoid hidden required input
# which prevent the form from being sent.
def required?
type_de_champ.mandatory? && visible?
end
def mandatory_blank?
mandatory? && blank?
2019-02-19 12:38:33 +01:00
end
def blank?
2021-07-21 10:45:59 +02:00
value.blank?
2017-03-29 13:37:07 +02:00
end
def search_terms
[to_s]
end
def to_s
2018-12-28 15:44:54 +01:00
value.present? ? value.to_s : ''
end
def for_export
2018-12-28 15:44:54 +01:00
value.presence
end
2018-12-28 17:59:14 +01:00
def for_api
value
end
def for_api_v2
to_s
end
def for_tag
value.present? ? value.to_s : ''
end
def main_value_name
:value
end
def to_typed_id
if row_id.present?
GraphQL::Schema::UniqueWithinType.encode('Champ', "#{stable_id}|#{row_id}")
else
type_de_champ.to_typed_id
end
end
def self.decode_typed_id(typed_id)
_, stable_id_with_maybe_row = GraphQL::Schema::UniqueWithinType.decode(typed_id)
stable_id_with_maybe_row.split('|')
end
def html_label?
true
end
def input_group_id
"champ-#{html_id}"
end
def input_id
"#{html_id}-input"
end
# A predictable string to use when generating an input name for this champ.
#
# Rail's FormBuilder can auto-generate input names, using the form "dossier[champs_public_attributes][5]",
# where [5] is the index of the field in the form.
# However the field index makes it difficult to render a single field, independent from the ordering of the others.
#
# Luckily, this is only used to make the name unique, but the actual value is ignored when Rails parses nested
# attributes. So instead of the field index, this method uses the champ id; which gives us an independent and
# predictable input name.
def input_name
if private?
"dossier[champs_private_attributes][#{id}]"
else
"dossier[champs_public_attributes][#{id}]"
end
end
def labelledby_id
"#{html_id}-label"
end
def describedby_id
"#{html_id}-description" if description.present?
end
def log_fetch_external_data_exception(exception)
exceptions = self.fetch_external_data_exceptions ||= []
exceptions << exception.inspect
update_column(:fetch_external_data_exceptions, exceptions)
end
2021-02-09 12:35:23 +01:00
def fetch_external_data?
false
end
2023-05-30 11:39:53 +02:00
def poll_external_data?
false
end
def fetch_external_data_pending?
# We don't have a good mechanism right now to know if the last fetch has errored. So, in order
# to ensure we don't poll to infinity, we stop after 5 minutes no matter what.
fetch_external_data? && poll_external_data? && external_id.present? && data.nil? && updated_at > 5.minutes.ago
end
2021-02-09 12:35:23 +01:00
def fetch_external_data
raise NotImplemented.new(:fetch_external_data)
end
def update_with_external_data!(data:)
update!(data: data)
end
def clone(fork = false)
champ_attributes = [:parent_id, :private, :row_id, :type, :type_de_champ_id]
value_attributes = fork || !private? ? [:value, :value_json, :data, :external_id] : []
relationships = fork || !private? ? [:etablissement, :geo_areas] : []
deep_clone(only: champ_attributes + value_attributes, include: relationships, validate: !fork) do |original, kopy|
PiecesJustificativesService.clone_attachments(original, kopy)
end
end
def focusable_input_id
input_id
end
def forked_with_changes?
public? && dossier.champ_forked_with_changes?(self)
end
private
def html_id
"champ-#{stable_id}-#{id}"
end
def needs_dossier_id?
!dossier_id && parent_id
end
def set_dossier_id
self.dossier_id = parent.dossier_id
end
2021-02-09 12:35:23 +01:00
def cleanup_if_empty
if persisted? && external_id_changed?
2021-02-09 12:35:23 +01:00
self.data = nil
end
end
def fetch_external_data_later
if fetch_external_data? && external_id.present? && data.nil?
ChampFetchExternalDataJob.perform_later(self, external_id)
2021-02-09 12:35:23 +01:00
end
end
def normalize
return if value.nil?
return if value.present? && !value.include?("\u0000")
self.value = value.delete("\u0000")
end
2021-02-09 12:35:23 +01:00
class NotImplemented < ::StandardError
def initialize(method)
super(":#{method} not implemented")
end
end
2015-11-03 10:48:40 +01:00
end