467 lines
16 KiB
Ruby
467 lines
16 KiB
Ruby
# == Schema Information
|
|
#
|
|
# Table name: procedure_revisions
|
|
#
|
|
# id :bigint not null, primary key
|
|
# published_at :datetime
|
|
# created_at :datetime not null
|
|
# updated_at :datetime not null
|
|
# attestation_template_id :bigint
|
|
# dossier_submitted_message_id :bigint
|
|
# procedure_id :bigint not null
|
|
#
|
|
class ProcedureRevision < ApplicationRecord
|
|
self.implicit_order_column = :created_at
|
|
belongs_to :procedure, -> { with_discarded }, inverse_of: :revisions, optional: false
|
|
belongs_to :attestation_template, inverse_of: :revisions, optional: true, dependent: :destroy
|
|
belongs_to :dossier_submitted_message, inverse_of: :revisions, optional: true, dependent: :destroy
|
|
|
|
has_many :dossiers, inverse_of: :revision, foreign_key: :revision_id
|
|
|
|
has_many :revision_types_de_champ, class_name: 'ProcedureRevisionTypeDeChamp', foreign_key: :revision_id, dependent: :destroy, inverse_of: :revision
|
|
has_many :revision_types_de_champ_public, -> { root.public_only.ordered }, class_name: 'ProcedureRevisionTypeDeChamp', foreign_key: :revision_id, dependent: :destroy, inverse_of: :revision
|
|
has_many :revision_types_de_champ_private, -> { root.private_only.ordered }, class_name: 'ProcedureRevisionTypeDeChamp', foreign_key: :revision_id, dependent: :destroy, inverse_of: :revision
|
|
has_many :types_de_champ, through: :revision_types_de_champ, source: :type_de_champ
|
|
has_many :types_de_champ_public, through: :revision_types_de_champ_public, source: :type_de_champ
|
|
has_many :types_de_champ_private, through: :revision_types_de_champ_private, source: :type_de_champ
|
|
|
|
has_one :draft_procedure, -> { with_discarded }, class_name: 'Procedure', foreign_key: :draft_revision_id, dependent: :nullify, inverse_of: :draft_revision
|
|
has_one :published_procedure, -> { with_discarded }, class_name: 'Procedure', foreign_key: :published_revision_id, dependent: :nullify, inverse_of: :published_revision
|
|
|
|
scope :ordered, -> { order(:created_at) }
|
|
|
|
def build_champs
|
|
types_de_champ_public.map { |tdc| tdc.build_champ(revision: self) }
|
|
end
|
|
|
|
def build_champs_private
|
|
types_de_champ_private.map { |tdc| tdc.build_champ(revision: self) }
|
|
end
|
|
|
|
def add_type_de_champ(params)
|
|
parent_stable_id = params[:parent_id]
|
|
|
|
coordinate = {}
|
|
|
|
if parent_stable_id.present?
|
|
# Ensure that if this is a child, it's parent is cloned to the new revision
|
|
clone_parent_to_draft_revision(parent_stable_id)
|
|
|
|
parent_coordinate, parent = coordinate_and_tdc(parent_stable_id)
|
|
|
|
coordinate[:parent_id] = parent_coordinate.id
|
|
coordinate[:position] = children_of(parent).count
|
|
|
|
# old system
|
|
params[:order_place] = coordinate[:position]
|
|
params[:parent_id] = parent.id
|
|
elsif params[:private]
|
|
coordinate[:position] = revision_types_de_champ_private.count
|
|
else
|
|
coordinate[:position] = revision_types_de_champ_public.count
|
|
end
|
|
|
|
tdc = TypeDeChamp.new(params)
|
|
if tdc.save
|
|
coordinate[:type_de_champ] = tdc
|
|
revision_types_de_champ.create!(coordinate)
|
|
end
|
|
|
|
tdc
|
|
rescue => e
|
|
TypeDeChamp.new.tap { |tdc| tdc.errors.add(:base, e.message) }
|
|
end
|
|
|
|
# Only called by by controller update
|
|
def find_or_clone_type_de_champ(stable_id)
|
|
# Ensure that if this is a child, it's parent is cloned to the new revision
|
|
clone_parent_to_draft_revision(stable_id)
|
|
|
|
coordinate, tdc = coordinate_and_tdc(stable_id)
|
|
|
|
if tdc.only_present_on_draft?
|
|
tdc
|
|
else
|
|
replace_tdc_and_children_by_clones(coordinate)
|
|
end
|
|
end
|
|
|
|
def move_type_de_champ(stable_id, position)
|
|
# Ensure that if this is a child, it's parent is cloned to the new revision
|
|
# Needed because the order could be based on the ancient system
|
|
clone_parent_to_draft_revision(stable_id)
|
|
|
|
coordinate, _ = coordinate_and_tdc(stable_id)
|
|
|
|
siblings = coordinate.siblings.to_a
|
|
|
|
siblings.insert(position, siblings.delete_at(siblings.index(coordinate)))
|
|
|
|
reorder(siblings)
|
|
end
|
|
|
|
def remove_type_de_champ(stable_id)
|
|
# Ensure that if this is a child, it's parent is cloned to the new revision
|
|
# Needed because the order could be based on the ancient system
|
|
clone_parent_to_draft_revision(stable_id)
|
|
|
|
coordinate, tdc = coordinate_and_tdc(stable_id)
|
|
|
|
coordinate.destroy
|
|
|
|
if tdc.revision_types_de_champ.empty?
|
|
tdc.destroy
|
|
end
|
|
|
|
reorder(coordinate.siblings)
|
|
end
|
|
|
|
def draft?
|
|
procedure.draft_revision == self
|
|
end
|
|
|
|
def locked?
|
|
!draft?
|
|
end
|
|
|
|
def different_from?(revision)
|
|
types_de_champ != revision.types_de_champ ||
|
|
attestation_template != revision.attestation_template
|
|
end
|
|
|
|
def compare(revision)
|
|
changes = []
|
|
changes += compare_types_de_champ(types_de_champ_public, revision.types_de_champ_public)
|
|
changes += compare_types_de_champ(types_de_champ_private, revision.types_de_champ_private)
|
|
changes += compare_attestation_template(attestation_template, revision.attestation_template)
|
|
changes
|
|
end
|
|
|
|
def new_dossier
|
|
Dossier.new(
|
|
revision: self,
|
|
champs: build_champs,
|
|
champs_private: build_champs_private,
|
|
groupe_instructeur: procedure.defaut_groupe_instructeur
|
|
)
|
|
end
|
|
|
|
def dossier_for_preview(user)
|
|
dossier = Dossier
|
|
.create_with(groupe_instructeur: procedure.defaut_groupe_instructeur_for_new_dossier)
|
|
.find_or_initialize_by(revision: self, user: user, for_procedure_preview: true, state: Dossier.states.fetch(:brouillon))
|
|
|
|
if dossier.new_record?
|
|
dossier.build_default_individual
|
|
dossier.save!
|
|
end
|
|
|
|
dossier
|
|
end
|
|
|
|
def children_of(tdc)
|
|
parent_coordinate_id = revision_types_de_champ.where(type_de_champ: tdc).select(:id)
|
|
|
|
types_de_champ
|
|
.where(procedure_revision_types_de_champ: { parent_id: parent_coordinate_id })
|
|
.order("procedure_revision_types_de_champ.position")
|
|
end
|
|
|
|
def types_de_champ_public_as_json
|
|
types_de_champ = types_de_champ_public.includes(piece_justificative_template_attachment: :blob)
|
|
tdcs_as_json = types_de_champ.map(&:as_json_for_editor)
|
|
children_types_de_champ_as_json(tdcs_as_json, types_de_champ.filter(&:repetition?))
|
|
tdcs_as_json
|
|
end
|
|
|
|
def types_de_champ_private_as_json
|
|
types_de_champ = types_de_champ_private.includes(piece_justificative_template_attachment: :blob)
|
|
tdcs_as_json = types_de_champ.map(&:as_json_for_editor)
|
|
children_types_de_champ_as_json(tdcs_as_json, types_de_champ.filter(&:repetition?))
|
|
tdcs_as_json
|
|
end
|
|
|
|
private
|
|
|
|
def children_types_de_champ_as_json(tdcs_as_json, parent_tdcs)
|
|
parent_tdcs.each do |parent_tdc|
|
|
tdc_as_json = tdcs_as_json.find { |json| json["id"] == parent_tdc.stable_id }
|
|
tdc_as_json&.merge!(types_de_champ: children_of(parent_tdc).includes(piece_justificative_template_attachment: :blob).map(&:as_json_for_editor))
|
|
end
|
|
end
|
|
|
|
def coordinate_and_tdc(stable_id)
|
|
coordinate = revision_types_de_champ
|
|
.joins(:type_de_champ)
|
|
.find_by(type_de_champ: { stable_id: stable_id })
|
|
|
|
[coordinate, coordinate.type_de_champ]
|
|
end
|
|
|
|
def reorder(siblings)
|
|
siblings.to_a.compact.each.with_index do |sibling, position|
|
|
sibling.update(position: position)
|
|
|
|
# FIXME: to remove when order_place is no longer used
|
|
if sibling.parent_id.present?
|
|
sibling.type_de_champ.update!(order_place: position)
|
|
end
|
|
end
|
|
end
|
|
|
|
def compare_attestation_template(from_at, to_at)
|
|
changes = []
|
|
if from_at.nil? && to_at.present?
|
|
changes << {
|
|
model: :attestation_template,
|
|
op: :add
|
|
}
|
|
elsif to_at.present?
|
|
if from_at.title != to_at.title
|
|
changes << {
|
|
model: :attestation_template,
|
|
op: :update,
|
|
attribute: :title,
|
|
from: from_at.title,
|
|
to: to_at.title
|
|
}
|
|
end
|
|
if from_at.body != to_at.body
|
|
changes << {
|
|
model: :attestation_template,
|
|
op: :update,
|
|
attribute: :body,
|
|
from: from_at.body,
|
|
to: to_at.body
|
|
}
|
|
end
|
|
if from_at.footer != to_at.footer
|
|
changes << {
|
|
model: :attestation_template,
|
|
op: :update,
|
|
attribute: :footer,
|
|
from: from_at.footer,
|
|
to: to_at.footer
|
|
}
|
|
end
|
|
if from_at.logo_checksum != to_at.logo_checksum
|
|
changes << {
|
|
model: :attestation_template,
|
|
op: :update,
|
|
attribute: :logo,
|
|
from: from_at.logo_filename,
|
|
to: to_at.logo_filename
|
|
}
|
|
end
|
|
if from_at.signature_checksum != to_at.signature_checksum
|
|
changes << {
|
|
model: :attestation_template,
|
|
op: :update,
|
|
attribute: :signature,
|
|
from: from_at.signature_filename,
|
|
to: to_at.signature_filename
|
|
}
|
|
end
|
|
end
|
|
changes
|
|
end
|
|
|
|
def compare_types_de_champ(from_tdc, to_tdc)
|
|
if from_tdc == to_tdc
|
|
[]
|
|
else
|
|
from_h = from_tdc.index_by(&:stable_id)
|
|
to_h = to_tdc.index_by(&:stable_id)
|
|
|
|
from_sids = from_h.keys
|
|
to_sids = to_h.keys
|
|
|
|
removed = (from_sids - to_sids).map do |sid|
|
|
{ model: :type_de_champ, op: :remove, label: from_h[sid].libelle, private: from_h[sid].private?, position: from_sids.index(sid), stable_id: sid }
|
|
end
|
|
|
|
added = (to_sids - from_sids).map do |sid|
|
|
{ model: :type_de_champ, op: :add, label: to_h[sid].libelle, private: to_h[sid].private?, position: to_sids.index(sid), stable_id: sid }
|
|
end
|
|
|
|
kept = from_sids.intersection(to_sids)
|
|
|
|
moved = kept
|
|
.map { |sid| [sid, from_sids.index(sid), to_sids.index(sid)] }
|
|
.filter { |_, from_index, to_index| from_index != to_index }
|
|
.map do |sid, from_index, to_index|
|
|
{ model: :type_de_champ, op: :move, label: from_h[sid].libelle, private: from_h[sid].private?, from: from_index, to: to_index, position: to_index, stable_id: sid }
|
|
end
|
|
|
|
changed = kept
|
|
.map { |sid| [sid, from_h[sid], to_h[sid]] }
|
|
.flat_map do |sid, from, to|
|
|
compare_type_de_champ(from, to)
|
|
.each { |h| h[:position] = to_sids.index(sid) }
|
|
end
|
|
|
|
(removed + added + moved + changed)
|
|
.sort_by { |h| h[:position] }
|
|
.each { |h| h.delete(:position) }
|
|
end
|
|
end
|
|
|
|
def compare_type_de_champ(from_type_de_champ, to_type_de_champ)
|
|
changes = []
|
|
if from_type_de_champ.type_champ != to_type_de_champ.type_champ
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :type_champ,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.type_champ,
|
|
to: to_type_de_champ.type_champ,
|
|
stable_id: from_type_de_champ.stable_id
|
|
}
|
|
end
|
|
if from_type_de_champ.libelle != to_type_de_champ.libelle
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :libelle,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.libelle,
|
|
to: to_type_de_champ.libelle,
|
|
stable_id: from_type_de_champ.stable_id
|
|
}
|
|
end
|
|
if from_type_de_champ.description != to_type_de_champ.description
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :description,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.description,
|
|
to: to_type_de_champ.description,
|
|
stable_id: from_type_de_champ.stable_id
|
|
}
|
|
end
|
|
if from_type_de_champ.mandatory? != to_type_de_champ.mandatory?
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :mandatory,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.mandatory?,
|
|
to: to_type_de_champ.mandatory?,
|
|
stable_id: from_type_de_champ.stable_id
|
|
}
|
|
end
|
|
if to_type_de_champ.drop_down_list?
|
|
if from_type_de_champ.drop_down_list_options != to_type_de_champ.drop_down_list_options
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :drop_down_options,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.drop_down_list_options,
|
|
to: to_type_de_champ.drop_down_list_options,
|
|
stable_id: from_type_de_champ.stable_id
|
|
}
|
|
end
|
|
if to_type_de_champ.linked_drop_down_list?
|
|
if from_type_de_champ.drop_down_secondary_libelle != to_type_de_champ.drop_down_secondary_libelle
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :drop_down_secondary_libelle,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.drop_down_secondary_libelle,
|
|
to: to_type_de_champ.drop_down_secondary_libelle
|
|
}
|
|
end
|
|
if from_type_de_champ.drop_down_secondary_description != to_type_de_champ.drop_down_secondary_description
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :drop_down_secondary_description,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.drop_down_secondary_description,
|
|
to: to_type_de_champ.drop_down_secondary_description
|
|
}
|
|
end
|
|
end
|
|
if from_type_de_champ.drop_down_other != to_type_de_champ.drop_down_other
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :drop_down_other,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.drop_down_other,
|
|
to: to_type_de_champ.drop_down_other,
|
|
stable_id: from_type_de_champ.stable_id
|
|
}
|
|
end
|
|
elsif to_type_de_champ.carte?
|
|
if from_type_de_champ.carte_optional_layers != to_type_de_champ.carte_optional_layers
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :carte_layers,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.carte_optional_layers,
|
|
to: to_type_de_champ.carte_optional_layers,
|
|
stable_id: from_type_de_champ.stable_id
|
|
}
|
|
end
|
|
elsif to_type_de_champ.piece_justificative?
|
|
if from_type_de_champ.piece_justificative_template_checksum != to_type_de_champ.piece_justificative_template_checksum
|
|
changes << {
|
|
model: :type_de_champ,
|
|
op: :update,
|
|
attribute: :piece_justificative_template,
|
|
label: from_type_de_champ.libelle,
|
|
private: from_type_de_champ.private?,
|
|
from: from_type_de_champ.piece_justificative_template_filename,
|
|
to: to_type_de_champ.piece_justificative_template_filename,
|
|
stable_id: from_type_de_champ.stable_id
|
|
}
|
|
end
|
|
elsif to_type_de_champ.repetition?
|
|
if from_type_de_champ.types_de_champ != to_type_de_champ.types_de_champ
|
|
changes += compare_types_de_champ(from_type_de_champ.types_de_champ, to_type_de_champ.types_de_champ)
|
|
end
|
|
end
|
|
changes
|
|
end
|
|
|
|
def replace_tdc_and_children_by_clones(coordinate)
|
|
cloned_type_de_champ = coordinate.type_de_champ.deep_clone(include: [:types_de_champ]) do |original, kopy|
|
|
PiecesJustificativesService.clone_attachments(original, kopy)
|
|
end
|
|
cloned_child_types_de_champ = cloned_type_de_champ.types_de_champ
|
|
coordinate.update!(type_de_champ: cloned_type_de_champ)
|
|
|
|
# sync old and new system
|
|
children_coordinates = revision_types_de_champ.where(parent: coordinate)
|
|
|
|
children_coordinates.find_each do |child_coordinate|
|
|
cloned_child_type_de_champ = cloned_child_types_de_champ.find { |tdc| tdc.stable_id == child_coordinate.type_de_champ.stable_id }
|
|
child_coordinate.update!(type_de_champ: cloned_child_type_de_champ)
|
|
end
|
|
|
|
cloned_type_de_champ
|
|
end
|
|
|
|
def clone_parent_to_draft_revision(stable_id)
|
|
coordinate, tdc = coordinate_and_tdc(stable_id)
|
|
|
|
if coordinate.child? && !tdc.only_present_on_draft?
|
|
replace_tdc_and_children_by_clones(coordinate.parent)
|
|
end
|
|
end
|
|
end
|