412 lines
12 KiB
Ruby
412 lines
12 KiB
Ruby
class Dossier < ApplicationRecord
|
|
enum state: {
|
|
brouillon: 'brouillon',
|
|
en_construction: 'en_construction',
|
|
en_instruction: 'en_instruction',
|
|
accepte: 'accepte',
|
|
refuse: 'refuse',
|
|
sans_suite: 'sans_suite'
|
|
}
|
|
|
|
EN_CONSTRUCTION_OU_INSTRUCTION = [states.fetch(:en_construction), states.fetch(:en_instruction)]
|
|
TERMINE = [states.fetch(:accepte), states.fetch(:refuse), states.fetch(:sans_suite)]
|
|
INSTRUCTION_COMMENCEE = TERMINE + [states.fetch(:en_instruction)]
|
|
SOUMIS = EN_CONSTRUCTION_OU_INSTRUCTION + TERMINE
|
|
|
|
has_one :etablissement, dependent: :destroy
|
|
has_one :individual, dependent: :destroy
|
|
has_one :attestation
|
|
|
|
has_many :pieces_justificatives, dependent: :destroy
|
|
has_many :champs, -> { public_only.ordered }, dependent: :destroy
|
|
has_many :champs_private, -> { private_only.ordered }, class_name: 'Champ', dependent: :destroy
|
|
has_many :quartier_prioritaires, dependent: :destroy
|
|
has_many :cadastres, dependent: :destroy
|
|
has_many :commentaires, dependent: :destroy
|
|
has_many :invites, dependent: :destroy
|
|
has_many :follows
|
|
has_many :followers_gestionnaires, through: :follows, source: :gestionnaire
|
|
has_many :avis, dependent: :destroy
|
|
|
|
belongs_to :procedure
|
|
belongs_to :user
|
|
|
|
accepts_nested_attributes_for :champs
|
|
accepts_nested_attributes_for :champs_private
|
|
|
|
default_scope { where(hidden_at: nil) }
|
|
scope :state_brouillon, -> { where(state: states.fetch(:brouillon)) }
|
|
scope :state_not_brouillon, -> { where.not(state: states.fetch(:brouillon)) }
|
|
scope :state_en_construction, -> { where(state: states.fetch(:en_construction)) }
|
|
scope :state_en_instruction, -> { where(state: states.fetch(:en_instruction)) }
|
|
scope :state_en_construction_ou_instruction, -> { where(state: EN_CONSTRUCTION_OU_INSTRUCTION) }
|
|
scope :state_instruction_commencee, -> { where(state: INSTRUCTION_COMMENCEE) }
|
|
scope :state_termine, -> { where(state: TERMINE) }
|
|
|
|
scope :archived, -> { where(archived: true) }
|
|
scope :not_archived, -> { where(archived: false) }
|
|
|
|
scope :order_by_updated_at, -> (order = :desc) { order(updated_at: order) }
|
|
|
|
scope :all_state, -> { not_archived.state_not_brouillon }
|
|
scope :en_construction, -> { not_archived.state_en_construction }
|
|
scope :en_instruction, -> { not_archived.state_en_instruction }
|
|
scope :termine, -> { not_archived.state_termine }
|
|
scope :downloadable_sorted, -> { state_not_brouillon.includes(:etablissement, :champs, :champs_private, :user, :individual, :followers_gestionnaires).order(en_construction_at: 'asc') }
|
|
scope :en_cours, -> { not_archived.state_en_construction_ou_instruction }
|
|
scope :without_followers, -> { left_outer_joins(:follows).where(follows: { id: nil }) }
|
|
scope :followed_by, -> (gestionnaire) { joins(:follows).where(follows: { gestionnaire: gestionnaire }) }
|
|
scope :with_champs, -> { includes(champs: :type_de_champ) }
|
|
scope :nearing_end_of_retention, -> (duration = '1 month') { joins(:procedure).where("en_instruction_at + (duree_conservation_dossiers_dans_ds * interval '1 month') - now() < interval ?", duration) }
|
|
|
|
scope :for_api, -> {
|
|
includes(commentaires: [],
|
|
champs: [
|
|
:geo_areas,
|
|
:etablissement,
|
|
piece_justificative_file_attachment: :blob
|
|
],
|
|
champs_private: [
|
|
:geo_areas,
|
|
:etablissement,
|
|
piece_justificative_file_attachment: :blob
|
|
],
|
|
pieces_justificatives: [],
|
|
quartier_prioritaires: [],
|
|
cadastres: [],
|
|
etablissement: [],
|
|
individual: [],
|
|
user: [])
|
|
}
|
|
|
|
accepts_nested_attributes_for :individual
|
|
|
|
delegate :siret, :siren, to: :etablissement, allow_nil: true
|
|
delegate :types_de_piece_justificative, to: :procedure
|
|
delegate :types_de_champ, to: :procedure
|
|
delegate :france_connect_information, to: :user
|
|
|
|
before_validation :update_state_dates, if: -> { state_changed? }
|
|
|
|
before_save :build_default_champs, if: Proc.new { procedure_id_changed? }
|
|
before_save :build_default_individual, if: Proc.new { procedure.for_individual? }
|
|
before_save :update_search_terms
|
|
|
|
after_save :send_dossier_received
|
|
after_save :send_web_hook
|
|
after_create :send_draft_notification_email
|
|
|
|
validates :user, presence: true
|
|
|
|
def update_search_terms
|
|
self.search_terms = [
|
|
user&.email,
|
|
*champs.flat_map(&:search_terms),
|
|
*etablissement&.search_terms,
|
|
individual&.nom,
|
|
individual&.prenom
|
|
].compact.join(' ')
|
|
self.private_search_terms = champs_private.flat_map(&:search_terms).compact.join(' ')
|
|
end
|
|
|
|
def was_piece_justificative_uploaded_for_type_id?(type_id)
|
|
pieces_justificatives.where(type_de_piece_justificative_id: type_id).count > 0
|
|
end
|
|
|
|
def retrieve_last_piece_justificative_by_type(type)
|
|
pieces_justificatives.where(type_de_piece_justificative_id: type).last
|
|
end
|
|
|
|
def retrieve_all_piece_justificative_by_type(type)
|
|
pieces_justificatives.where(type_de_piece_justificative_id: type).order(created_at: :DESC)
|
|
end
|
|
|
|
def build_default_champs
|
|
procedure.types_de_champ.each do |type_de_champ|
|
|
champs << type_de_champ.champ.build
|
|
end
|
|
procedure.types_de_champ_private.each do |type_de_champ|
|
|
champs_private << type_de_champ.champ.build
|
|
end
|
|
end
|
|
|
|
def build_default_individual
|
|
if Individual.where(dossier_id: self.id).count == 0
|
|
build_individual
|
|
end
|
|
end
|
|
|
|
def en_construction_ou_instruction?
|
|
EN_CONSTRUCTION_OU_INSTRUCTION.include?(state)
|
|
end
|
|
|
|
def termine?
|
|
TERMINE.include?(state)
|
|
end
|
|
|
|
def instruction_commencee?
|
|
INSTRUCTION_COMMENCEE.include?(state)
|
|
end
|
|
|
|
def export_headers
|
|
serialized_dossier = DossierTableExportSerializer.new(self)
|
|
headers = serialized_dossier.attributes.keys
|
|
headers += procedure.types_de_champ.order(:order_place).map { |types_de_champ| types_de_champ.libelle.parameterize.underscore.to_sym }
|
|
headers += procedure.types_de_champ_private.order(:order_place).map { |types_de_champ| types_de_champ.libelle.parameterize.underscore.to_sym }
|
|
headers += export_etablissement_data.keys
|
|
headers
|
|
end
|
|
|
|
def export_values
|
|
sorted_values.map do |value|
|
|
serialize_value_for_export(value)
|
|
end
|
|
end
|
|
|
|
def reset!
|
|
etablissement.destroy
|
|
|
|
update_columns(autorisation_donnees: false)
|
|
end
|
|
|
|
def total_follow
|
|
follows.size
|
|
end
|
|
|
|
def read_only?
|
|
en_instruction? || accepte? || refuse? || sans_suite?
|
|
end
|
|
|
|
def invite_for_user(user)
|
|
invites.find_by(user_id: user.id)
|
|
end
|
|
|
|
def can_be_en_construction?
|
|
!(procedure.archivee? && brouillon?)
|
|
end
|
|
|
|
def can_transition_to_en_construction?
|
|
!procedure.archivee? && brouillon?
|
|
end
|
|
|
|
def can_be_updated_by_the_user?
|
|
brouillon? || en_construction?
|
|
end
|
|
|
|
def retention_end_date
|
|
if instruction_commencee?
|
|
en_instruction_at + procedure.duree_conservation_dossiers_dans_ds.months
|
|
end
|
|
end
|
|
|
|
def retention_expired?
|
|
instruction_commencee? && retention_end_date <= Time.zone.now
|
|
end
|
|
|
|
def text_summary
|
|
if brouillon?
|
|
parts = [
|
|
"Dossier en brouillon répondant à la démarche ",
|
|
procedure.libelle,
|
|
" gérée par l'organisme ",
|
|
procedure.organisation
|
|
]
|
|
else
|
|
parts = [
|
|
"Dossier déposé le ",
|
|
en_construction_at.strftime("%d/%m/%Y"),
|
|
" sur la démarche ",
|
|
procedure.libelle,
|
|
" gérée par l'organisme ",
|
|
procedure.organisation
|
|
]
|
|
end
|
|
|
|
parts.join
|
|
end
|
|
|
|
def avis_for(gestionnaire)
|
|
if gestionnaire.dossiers.include?(self)
|
|
avis.order(created_at: :asc)
|
|
else
|
|
avis
|
|
.where(confidentiel: false)
|
|
.or(avis.where(claimant: gestionnaire))
|
|
.or(avis.where(gestionnaire: gestionnaire))
|
|
.order(created_at: :asc)
|
|
end
|
|
end
|
|
|
|
def owner_name
|
|
if etablissement.present?
|
|
etablissement.entreprise_raison_sociale
|
|
elsif individual.present?
|
|
"#{individual.nom} #{individual.prenom}"
|
|
end
|
|
end
|
|
|
|
def use_legacy_carto?
|
|
procedure.use_legacy_carto?
|
|
end
|
|
|
|
def expose_legacy_carto_api?
|
|
procedure.expose_legacy_carto_api?
|
|
end
|
|
|
|
def user_geometry
|
|
if json_latlngs.present?
|
|
UserGeometry.new(json_latlngs)
|
|
end
|
|
end
|
|
|
|
def geo_position
|
|
if etablissement.present?
|
|
point = ApiAdresse::PointAdapter.new(etablissement.geo_adresse).geocode
|
|
end
|
|
|
|
lon = "2.428462"
|
|
lat = "46.538192"
|
|
zoom = "13"
|
|
|
|
if point.present?
|
|
lon = point.x.to_s
|
|
lat = point.y.to_s
|
|
end
|
|
|
|
{ lon: lon, lat: lat, zoom: zoom }
|
|
end
|
|
|
|
def unspecified_attestation_champs
|
|
attestation_template = procedure.attestation_template
|
|
|
|
if attestation_template&.activated?
|
|
attestation_template.unspecified_champs_for_dossier(self)
|
|
else
|
|
[]
|
|
end
|
|
end
|
|
|
|
def build_attestation
|
|
if procedure.attestation_template&.activated?
|
|
procedure.attestation_template.attestation_for(self)
|
|
end
|
|
end
|
|
|
|
def delete_and_keep_track
|
|
now = Time.zone.now
|
|
deleted_dossier = DeletedDossier.create!(dossier_id: id, procedure: procedure, state: state, deleted_at: now)
|
|
update(hidden_at: now)
|
|
|
|
if en_construction?
|
|
administration_emails = followers_gestionnaires.present? ? followers_gestionnaires.pluck(:email) : [procedure.administrateur.email]
|
|
administration_emails.each do |email|
|
|
DossierMailer.notify_deletion_to_administration(deleted_dossier, email).deliver_later
|
|
end
|
|
end
|
|
DossierMailer.notify_deletion_to_user(deleted_dossier, user.email).deliver_later
|
|
end
|
|
|
|
def passer_en_instruction!(gestionnaire)
|
|
en_instruction!
|
|
gestionnaire.follow(self)
|
|
end
|
|
|
|
def repasser_en_construction!
|
|
self.en_instruction_at = nil
|
|
en_construction!
|
|
end
|
|
|
|
def accepter!(motivation)
|
|
self.motivation = motivation
|
|
self.en_instruction_at ||= Time.zone.now
|
|
|
|
accepte!
|
|
|
|
if attestation.nil?
|
|
update(attestation: build_attestation)
|
|
end
|
|
|
|
NotificationMailer.send_closed_notification(self).deliver_later
|
|
end
|
|
|
|
def refuser!(motivation)
|
|
self.motivation = motivation
|
|
self.en_instruction_at ||= Time.zone.now
|
|
|
|
refuse!
|
|
|
|
NotificationMailer.send_refused_notification(self).deliver_later
|
|
end
|
|
|
|
def classer_sans_suite!(motivation)
|
|
self.motivation = motivation
|
|
self.en_instruction_at ||= Time.zone.now
|
|
|
|
sans_suite!
|
|
|
|
NotificationMailer.send_without_continuation_notification(self).deliver_later
|
|
end
|
|
|
|
private
|
|
|
|
def update_state_dates
|
|
if en_construction? && !self.en_construction_at
|
|
self.en_construction_at = Time.zone.now
|
|
elsif en_instruction? && !self.en_instruction_at
|
|
self.en_instruction_at = Time.zone.now
|
|
elsif TERMINE.include?(state)
|
|
self.processed_at = Time.zone.now
|
|
end
|
|
end
|
|
|
|
def serialize_value_for_export(value)
|
|
value.nil? || value.kind_of?(Time) ? value : value.to_s
|
|
end
|
|
|
|
def convert_specific_hash_values_to_string(hash_to_convert)
|
|
hash_to_convert.transform_values do |value|
|
|
serialize_value_for_export(value)
|
|
end
|
|
end
|
|
|
|
def export_etablissement_data
|
|
if etablissement.present?
|
|
etablissement_attr = EtablissementCsvSerializer.new(etablissement).attributes.transform_keys { |k| "etablissement.#{k}".parameterize.underscore.to_sym }
|
|
entreprise_attr = EntrepriseSerializer.new(etablissement.entreprise).attributes.transform_keys { |k| "entreprise.#{k}".parameterize.underscore.to_sym }
|
|
else
|
|
etablissement_attr = EtablissementSerializer.new(Etablissement.new).attributes.transform_keys { |k| "etablissement.#{k}".parameterize.underscore.to_sym }
|
|
entreprise_attr = EntrepriseSerializer.new(Entreprise.new).attributes.transform_keys { |k| "entreprise.#{k}".parameterize.underscore.to_sym }
|
|
end
|
|
convert_specific_hash_values_to_string(etablissement_attr.merge(entreprise_attr))
|
|
end
|
|
|
|
def sorted_values
|
|
serialized_dossier = DossierTableExportSerializer.new(self)
|
|
values = serialized_dossier.attributes.values
|
|
values += champs.map(&:for_export)
|
|
values += champs_private.map(&:for_export)
|
|
values += export_etablissement_data.values
|
|
values
|
|
end
|
|
|
|
def send_dossier_received
|
|
if saved_change_to_state? && en_instruction?
|
|
NotificationMailer.send_dossier_received(self).deliver_later
|
|
end
|
|
end
|
|
|
|
def send_draft_notification_email
|
|
if brouillon?
|
|
DossierMailer.notify_new_draft(self).deliver_later
|
|
end
|
|
end
|
|
|
|
def send_web_hook
|
|
if saved_change_to_state? && !brouillon? && procedure.web_hook_url
|
|
WebHookJob.perform_later(
|
|
procedure,
|
|
self
|
|
)
|
|
end
|
|
end
|
|
end
|