demarches-normaliennes/app/models/dossier.rb

518 lines
16 KiB
Ruby
Raw Normal View History

2018-03-06 13:44:29 +01:00
class Dossier < ApplicationRecord
include DossierFilteringConcern
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
2015-09-24 11:45:00 +02:00
has_one :etablissement, dependent: :destroy
2016-08-30 11:18:43 +02:00
has_one :individual, dependent: :destroy
has_one :attestation, dependent: :destroy
has_many :pieces_justificatives, inverse_of: :dossier, dependent: :destroy
has_one_attached :justificatif_motivation
has_many :champs, -> { root.public_only.ordered }, inverse_of: :dossier, dependent: :destroy
has_many :champs_private, -> { root.private_only.ordered }, class_name: 'Champ', inverse_of: :dossier, dependent: :destroy
has_many :commentaires, inverse_of: :dossier, dependent: :destroy
has_many :invites, dependent: :destroy
has_many :follows, -> { active }, inverse_of: :dossier
has_many :previous_follows, -> { inactive }, class_name: 'Follow', inverse_of: :dossier
has_many :followers_gestionnaires, through: :follows, source: :gestionnaire
has_many :previous_followers_gestionnaires, -> { distinct }, through: :previous_follows, source: :gestionnaire
has_many :avis, inverse_of: :dossier, dependent: :destroy
has_many :dossier_operation_logs, dependent: :destroy
2018-11-23 21:02:18 +01:00
belongs_to :procedure
2015-09-23 12:16:21 +02:00
belongs_to :user
2017-08-02 14:56:08 +02:00
accepts_nested_attributes_for :champs
2017-08-02 15:33:23 +02:00
accepts_nested_attributes_for :champs_private
2017-08-02 14:56:08 +02:00
2019-07-02 15:38:23 +02:00
include AASM
aasm whiny_persistence: true, column: :state, enum: true do
state :brouillon, initial: true
state :en_construction
state :en_instruction
state :accepte
state :refuse
state :sans_suite
event :passer_en_construction, after: :after_passer_en_construction do
transitions from: :brouillon, to: :en_construction
end
event :passer_en_instruction, after: :after_passer_en_instruction do
transitions from: :en_construction, to: :en_instruction
end
event :passer_automatiquement_en_instruction, after: :after_passer_automatiquement_en_instruction do
transitions from: :en_construction, to: :en_instruction
end
event :repasser_en_construction, after: :after_repasser_en_construction do
transitions from: :en_instruction, to: :en_construction
end
event :accepter, after: :after_accepter do
transitions from: :en_instruction, to: :accepte
end
event :accepter_automatiquement, after: :after_accepter_automatiquement do
transitions from: :en_construction, to: :accepte
end
event :refuser, after: :after_refuser do
transitions from: :en_instruction, to: :refuse
end
event :classer_sans_suite, after: :after_classer_sans_suite do
transitions from: :en_instruction, to: :sans_suite
end
event :repasser_en_instruction, after: :after_repasser_en_instruction do
transitions from: :refuse, to: :en_instruction
transitions from: :sans_suite, to: :en_instruction
end
end
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)) }
2017-07-11 16:09:03 +02:00
scope :state_en_construction_ou_instruction, -> { where(state: EN_CONSTRUCTION_OU_INSTRUCTION) }
scope :state_instruction_commencee, -> { where(state: INSTRUCTION_COMMENCEE) }
2017-07-11 16:09:03 +02:00
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 :order_for_api, -> (order = :asc) { order(en_construction_at: order, created_at: order, id: 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 }
2019-04-03 14:29:30 +02:00
scope :downloadable_sorted, -> { state_not_brouillon.includes(:etablissement, :user, :individual, :followers_gestionnaires, :avis, champs: { etablissement: [:champ], type_de_champ: :drop_down_list }, champs_private: { etablissement: [:champ], type_de_champ: :drop_down_list }).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 }) }
2018-01-15 21:49:52 +01:00
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 :since, -> (since) { where('dossiers.en_construction_at >= ?', since) }
2018-11-01 14:04:32 +01:00
scope :for_api, -> {
includes(commentaires: { piece_jointe_attachment: :blob },
2018-11-01 14:04:32 +01:00
champs: [
:geo_areas,
:etablissement,
piece_justificative_file_attachment: :blob
],
champs_private: [
:geo_areas,
:etablissement,
piece_justificative_file_attachment: :blob
],
pieces_justificatives: [],
2019-06-27 14:38:57 +02:00
avis: [],
2018-11-01 14:04:32 +01:00
etablissement: [],
individual: [],
user: [])
}
2016-08-30 11:18:43 +02:00
accepts_nested_attributes_for :individual
delegate :siret, :siren, to: :etablissement, allow_nil: true
delegate :types_de_piece_justificative, to: :procedure
2015-11-05 11:21:44 +01:00
delegate :types_de_champ, to: :procedure
delegate :france_connect_information, to: :user
2017-03-01 09:51:55 +01:00
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
2017-03-01 09:51:55 +01:00
after_save :send_dossier_received
2018-03-01 17:04:05 +01:00
after_save :send_web_hook
after_create :send_draft_notification_email
validates :user, presence: true
2015-08-21 11:37:13 +02:00
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
2016-03-17 14:50:10 +01:00
def retrieve_last_piece_justificative_by_type(type)
pieces_justificatives.where(type_de_piece_justificative_id: type).last
end
2016-03-17 14:50:10 +01:00
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
2019-02-07 10:44:15 +01:00
procedure.build_champs.each do |champ|
2019-01-30 16:14:15 +01:00
champs << champ
end
2019-02-07 10:44:15 +01:00
procedure.build_champs_private.each do |champ|
champs_private << champ
end
end
2016-08-30 11:18:43 +02:00
def build_default_individual
if Individual.where(dossier_id: self.id).count == 0
build_individual
end
2016-08-30 11:18:43 +02:00
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 reset!
etablissement.destroy
2018-02-08 17:13:15 +01:00
update_columns(autorisation_donnees: false)
end
2016-09-13 12:17:56 +02:00
def read_only?
en_instruction? || accepte? || refuse? || sans_suite?
2016-09-13 12:17:56 +02:00
end
def can_transition_to_en_construction?
!procedure.archivee? && brouillon?
end
2019-02-06 18:20:35 +01:00
def can_be_updated_by_user?
brouillon? || en_construction?
end
def can_be_deleted_by_user?
brouillon? || en_construction?
end
def messagerie_available?
!brouillon? && !archived
end
def retention_end_date
if instruction_commencee?
en_instruction_at + procedure.duree_conservation_dossiers_dans_ds.months
end
end
def retention_expired?
2018-10-25 15:07:15 +02:00
instruction_commencee? && retention_end_date <= Time.zone.now
end
2017-04-18 17:31:01 +02:00
def text_summary
if brouillon?
parts = [
2018-09-05 14:48:42 +02:00
"Dossier en brouillon répondant à la démarche ",
2017-04-18 17:31:01 +02:00
procedure.libelle,
" gérée par l'organisme ",
procedure.organisation_name
2017-04-18 17:31:01 +02:00
]
else
parts = [
"Dossier déposé le ",
en_construction_at.strftime("%d/%m/%Y"),
2018-09-05 14:48:42 +02:00
" sur la démarche ",
2017-04-18 17:31:01 +02:00
procedure.libelle,
" gérée par l'organisme ",
procedure.organisation_name
2017-04-18 17:31:01 +02:00
]
end
parts.join
end
2017-09-08 11:52:20 +02:00
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
2017-11-17 23:40:51 +01:00
def owner_name
if etablissement.present?
etablissement.entreprise_raison_sociale
2017-11-17 23:40:51 +01:00
elsif individual.present?
"#{individual.nom} #{individual.prenom}"
end
end
2018-10-31 13:28:39 +01:00
def expose_legacy_carto_api?
procedure.expose_legacy_carto_api?
end
2018-10-10 19:58:51 +02:00
def geo_position
if etablissement.present?
2018-10-15 21:48:17 +02:00
point = ApiAdresse::PointAdapter.new(etablissement.geo_adresse).geocode
2018-10-10 19:58:51 +02:00
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(author)
deleted_dossier = DeletedDossier.create_from_dossier(self)
update(hidden_at: deleted_dossier.deleted_at)
if en_construction?
administration_emails = followers_gestionnaires.present? ? followers_gestionnaires.pluck(:email) : procedure.administrateurs.pluck(:email)
administration_emails.each do |email|
DossierMailer.notify_deletion_to_administration(deleted_dossier, email).deliver_later
end
end
2018-06-13 13:59:02 +02:00
DossierMailer.notify_deletion_to_user(deleted_dossier, user.email).deliver_later
log_dossier_operation(author, :supprimer, self)
end
2019-07-02 15:38:23 +02:00
def after_passer_en_instruction(gestionnaire)
gestionnaire.follow(self)
2018-11-26 21:29:06 +01:00
log_dossier_operation(gestionnaire, :passer_en_instruction)
end
2019-07-02 15:38:23 +02:00
def after_passer_automatiquement_en_instruction
log_automatic_dossier_operation(:passer_en_instruction)
end
2019-07-02 15:38:23 +02:00
def after_repasser_en_construction(gestionnaire)
self.en_instruction_at = nil
2018-11-26 21:29:06 +01:00
2019-07-02 15:38:23 +02:00
save!
2018-11-26 21:29:06 +01:00
log_dossier_operation(gestionnaire, :repasser_en_construction)
end
2019-07-02 15:38:23 +02:00
def after_repasser_en_instruction(gestionnaire)
self.processed_at = nil
self.motivation = nil
attestation&.destroy
2019-07-02 15:38:23 +02:00
save!
DossierMailer.notify_revert_to_instruction(self).deliver_later
log_dossier_operation(gestionnaire, :repasser_en_instruction)
end
2019-07-02 15:38:23 +02:00
def after_accepter(gestionnaire, motivation, justificatif = nil)
self.motivation = motivation
2019-07-02 15:38:23 +02:00
if justificatif
self.justificatif_motivation.attach(justificatif)
end
if attestation.nil?
2019-07-02 15:38:23 +02:00
self.attestation = build_attestation
end
2019-07-02 15:38:23 +02:00
save!
NotificationMailer.send_closed_notification(self).deliver_later
log_dossier_operation(gestionnaire, :accepter, self)
end
2019-07-02 15:38:23 +02:00
def after_accepter_automatiquement
2019-01-16 11:00:25 +01:00
self.en_instruction_at ||= Time.zone.now
if attestation.nil?
2019-07-02 15:38:23 +02:00
self.attestation = build_attestation
2019-01-16 11:00:25 +01:00
end
2019-07-02 15:38:23 +02:00
save!
2019-01-16 11:00:25 +01:00
NotificationMailer.send_closed_notification(self).deliver_later
log_automatic_dossier_operation(:accepter, self)
2019-01-16 11:00:25 +01:00
end
2019-07-02 15:38:23 +02:00
def after_refuser(gestionnaire, motivation, justificatif = nil)
self.motivation = motivation
2019-07-02 15:38:23 +02:00
if justificatif
self.justificatif_motivation.attach(justificatif)
end
2019-07-02 15:38:23 +02:00
save!
NotificationMailer.send_refused_notification(self).deliver_later
log_dossier_operation(gestionnaire, :refuser, self)
end
2019-07-02 15:38:23 +02:00
def after_classer_sans_suite(gestionnaire, motivation, justificatif = nil)
self.motivation = motivation
2019-07-02 15:38:23 +02:00
if justificatif
self.justificatif_motivation.attach(justificatif)
end
2019-07-02 15:38:23 +02:00
save!
NotificationMailer.send_without_continuation_notification(self).deliver_later
log_dossier_operation(gestionnaire, :classer_sans_suite, self)
end
2019-01-30 16:14:15 +01:00
def check_mandatory_champs
(champs + champs.select(&:repetition?).flat_map(&:champs))
.select(&:mandatory_and_blank?)
.map do |champ|
"Le champ #{champ.libelle.truncate(200)} doit être rempli."
end
end
def modifier_annotations!(gestionnaire)
champs_private.select(&:value_previously_changed?).each do |champ|
log_dossier_operation(gestionnaire, :modifier_annotation, champ)
end
end
2019-05-02 16:24:24 +02:00
def demander_un_avis!(avis)
log_dossier_operation(avis.claimant, :demander_un_avis, avis)
end
2019-04-03 14:29:30 +02:00
def spreadsheet_columns
[
['ID', id.to_s],
['Email', user.email],
['Civilité', individual&.gender],
['Nom', individual&.nom],
['Prénom', individual&.prenom],
['Date de naissance', individual&.birthdate],
['Archivé', :archived],
['État du dossier', I18n.t(state, scope: [:activerecord, :attributes, :dossier, :state])],
['Dernière mise à jour le', :updated_at],
2019-07-04 15:02:25 +02:00
['Passé en construction le', :en_construction_at],
['Passé en instruction le', :en_instruction_at],
2019-04-03 14:29:30 +02:00
['Traité le', :processed_at],
['Motivation de la décision', :motivation],
['Instructeurs', followers_gestionnaires.map(&:email).join(' ')]
] + champs_for_export + annotations_for_export
end
def champs_for_export
champs.reject(&:exclude_from_export?).map do |champ|
[champ.libelle, champ.for_export]
end
end
def annotations_for_export
champs_private.reject(&:exclude_from_export?).map do |champ|
[champ.libelle, champ.for_export]
end
end
def attachments_downloadable?
!PiecesJustificativesService.liste_pieces_justificatives(self).empty? && PiecesJustificativesService.pieces_justificatives_total_size(self) < 50.megabytes
end
2017-12-05 17:43:32 +01:00
private
def log_dossier_operation(author, operation, subject = nil)
DossierOperationLog.create_and_serialize(
dossier: self,
operation: DossierOperationLog.operations.fetch(operation),
author: author,
subject: subject
2018-11-26 21:29:06 +01:00
)
end
def log_automatic_dossier_operation(operation, subject = nil)
DossierOperationLog.create_and_serialize(
dossier: self,
operation: DossierOperationLog.operations.fetch(operation),
automatic_operation: true,
subject: subject
)
end
2017-03-01 09:51:55 +01:00
def update_state_dates
if en_construction? && !self.en_construction_at
2018-10-25 15:07:15 +02:00
self.en_construction_at = Time.zone.now
elsif en_instruction? && !self.en_instruction_at
2018-10-25 15:07:15 +02:00
self.en_instruction_at = Time.zone.now
2017-03-01 09:51:55 +01:00
elsif TERMINE.include?(state)
2018-10-25 15:07:15 +02:00
self.processed_at = Time.zone.now
2017-03-01 09:51:55 +01:00
end
end
def send_dossier_received
if saved_change_to_state? && en_instruction? && !procedure.declarative_accepte?
NotificationMailer.send_dossier_received(self).deliver_later
end
end
def send_draft_notification_email
if brouillon? && !procedure.declarative?
DossierMailer.notify_new_draft(self).deliver_later
end
end
2018-03-01 17:04:05 +01:00
def send_web_hook
if saved_change_to_state? && !brouillon? && procedure.web_hook_url
WebHookJob.perform_later(
procedure,
self
)
end
end
2015-08-10 11:05:06 +02:00
end