class Dossier < ActiveRecord::Base enum state: { draft: 'draft', initiated: 'initiated', received: 'received', closed: 'closed', refused: 'refused', without_continuation: 'without_continuation' } BROUILLON = %w(draft) NOUVEAUX = %w(initiated) EN_CONSTRUCTION = %w(initiated) EN_INSTRUCTION = %w(received) EN_CONSTRUCTION_OU_INSTRUCTION = EN_CONSTRUCTION + EN_INSTRUCTION TERMINE = %w(closed refused without_continuation) has_one :etablissement, dependent: :destroy has_one :entreprise, dependent: :destroy has_one :individual, dependent: :destroy has_one :attestation has_many :cerfa, dependent: :destroy has_many :pieces_justificatives, dependent: :destroy has_many :champs, class_name: 'ChampPublic', dependent: :destroy has_many :champs_private, class_name: 'ChampPrivate', 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 :invites_user, class_name: 'InviteUser', dependent: :destroy has_many :invites_gestionnaires, class_name: 'InviteGestionnaire', dependent: :destroy has_many :follows has_many :notifications, dependent: :destroy 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: BROUILLON) } scope :state_not_brouillon, -> { where.not(state: BROUILLON) } scope :state_nouveaux, -> { where(state: NOUVEAUX) } scope :state_en_construction, -> { where(state: EN_CONSTRUCTION) } scope :state_en_instruction, -> { where(state: EN_INSTRUCTION) } scope :state_en_construction_ou_instruction, -> { where(state: EN_CONSTRUCTION_OU_INSTRUCTION) } 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 :nouveaux, -> { not_archived.state_nouveaux } scope :en_instruction, -> { not_archived.state_en_instruction } scope :termine, -> { not_archived.state_termine } scope :downloadable, -> { state_not_brouillon.includes(:entreprise, :etablissement, :champs, :champs_private) } scope :en_cours, -> { not_archived.state_en_construction_ou_instruction } scope :without_followers, -> { includes(:follows).where(follows: { id: nil }) } scope :with_unread_notifications, -> { where(notifications: { already_read: false }) } accepts_nested_attributes_for :individual delegate :siren, to: :entreprise delegate :siret, 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? } after_save :build_default_champs, if: Proc.new { procedure_id_changed? } after_save :build_default_individual, if: Proc.new { procedure.for_individual? } after_save :send_dossier_received validates :user, presence: true def unreaded_notifications @unreaded_notif ||= notifications.where(already_read: false) end def first_unread_notification unreaded_notifications.order("created_at ASC").first 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 notifications_summary unread_notifications = notifications.unread { demande: unread_notifications.select(&:demande?).present?, avis: unread_notifications.select(&:avis?).present?, messagerie: unread_notifications.select(&:messagerie?).present?, annotations_privees: unread_notifications.select(&:annotations_privees?).present? } 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.all.each do |type_de_champ| ChampPublic.create(type_de_champ: type_de_champ, dossier: self) end procedure.types_de_champ_private.all.each do |type_de_champ| ChampPrivate.create(type_de_champ: type_de_champ, dossier: self) end end def build_default_individual if Individual.where(dossier_id: self.id).count == 0 Individual.create(dossier: self) end end def ordered_champs # TODO: use the line below when the procedure preview does not leak champ with dossier_id == 0 # champs.joins(:type_de_champ).order('types_de_champ.order_place') champs.joins(', types_de_champ').where("champs.type_de_champ_id = types_de_champ.id AND types_de_champ.procedure_id = #{procedure.id}").order('order_place') end def ordered_champs_private # TODO: use the line below when the procedure preview does not leak champ with dossier_id == 0 # champs_private.includes(:type_de_champ).order('types_de_champ.order_place') champs_private.joins(', types_de_champ').where("champs.type_de_champ_id = types_de_champ.id AND types_de_champ.procedure_id = #{procedure.id}").order('order_place') end def ordered_pieces_justificatives champs.joins(', types_de_piece_justificative').where("pieces_justificatives.type_de_piece_justificative_id = types_de_piece_justificative.id AND types_de_piece_justificative.procedure_id = #{procedure.id}").order('order_place ASC') end def next_step! role, action, motivation = nil unless %w(initiate follow update comment receive refuse without_continuation close).include?(action) fail 'action is not valid' end unless %w(user gestionnaire).include?(role) fail 'role is not valid' end case role when 'user' case action when 'initiate' if draft? initiated! end end when 'gestionnaire' case action when 'close' if received? self.attestation = build_attestation save closed! if motivation self.motivation = motivation save end end when 'refuse' if received? refused! if motivation self.motivation = motivation save end end when 'without_continuation' if received? without_continuation! if motivation self.motivation = motivation save end end end end state end def brouillon? BROUILLON.include?(state) end def en_construction? EN_CONSTRUCTION.include?(state) end def en_instruction? EN_INSTRUCTION.include?(state) end def en_construction_ou_instruction? EN_CONSTRUCTION_OU_INSTRUCTION.include?(state) end def termine? TERMINE.include?(state) end def cerfa_available? procedure.cerfa_flag? && cerfa.size != 0 end def convert_specific_hash_values_to_string(hash_to_convert) hash = {} hash_to_convert.each do |key, value| value = serialize_value_for_export(value) hash.store(key, value) end return hash end def full_data_strings_array data_with_champs.map do |value| serialize_value_for_export(value) end end def export_entreprise_data unless entreprise.nil? etablissement_attr = EtablissementCsvSerializer.new(self.etablissement).attributes.map { |k, v| ["etablissement.#{k}".parameterize.underscore.to_sym, v] }.to_h entreprise_attr = EntrepriseSerializer.new(self.entreprise).attributes.map { |k, v| ["entreprise.#{k}".parameterize.underscore.to_sym, v] }.to_h else etablissement_attr = EtablissementSerializer.new(Etablissement.new).attributes.map { |k, v| ["etablissement.#{k}".parameterize.underscore.to_sym, v] }.to_h entreprise_attr = EntrepriseSerializer.new(Entreprise.new).attributes.map { |k, v| ["entreprise.#{k}".parameterize.underscore.to_sym, v] }.to_h end return convert_specific_hash_values_to_string(etablissement_attr.merge(entreprise_attr)) end def data_with_champs serialized_dossier = DossierTableExportSerializer.new(self) data = serialized_dossier.attributes.values data += self.ordered_champs.map(&:value) data += self.ordered_champs_private.map(&:value) data += self.export_entreprise_data.values return data end def export_headers serialized_dossier = DossierTableExportSerializer.new(self) headers = serialized_dossier.attributes.keys headers += self.procedure.types_de_champ.order(:order_place).map { |types_de_champ| types_de_champ.libelle.parameterize.underscore.to_sym } headers += self.procedure.types_de_champ_private.order(:order_place).map { |types_de_champ| types_de_champ.libelle.parameterize.underscore.to_sym } headers += self.export_entreprise_data.keys return headers end def followers_gestionnaires follows.includes(:gestionnaire).map(&:gestionnaire) end def reset! etablissement.destroy entreprise.destroy update_attributes(autorisation_donnees: false) end def total_follow follows.size end def read_only? received? || closed? || refused? || without_continuation? end def owner? email user.email == email end def invite_by_user? email (invites_user.pluck :email).include? email end def can_be_initiated? !(procedure.archivee? && draft?) end def text_summary if brouillon? parts = [ "Dossier en brouillon répondant à la procédure ", procedure.libelle, " gérée par l'organisme ", procedure.organisation ] else parts = [ "Dossier déposé le ", initiated_at.localtime.strftime("%d/%m/%Y"), " sur la procédure ", 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 get_value(table, column) case table when 'self' self.send(column) when 'user' self.user.send(column) when 'france_connect_information' self.user.france_connect_information&.send(column) when 'entreprise' self.entreprise&.send(column) when 'etablissement' self.etablissement&.send(column) when 'type_de_champ' self.champs.find {|c| c.type_de_champ_id == column.to_i }.value when 'type_de_champ_private' self.champs_private.find {|c| c.type_de_champ_id == column.to_i }.value end end def self.sanitize_for_order(order) sanitize_sql_for_order(order) end private def build_attestation if procedure.attestation_template.present? && procedure.attestation_template.activated? procedure.attestation_template.attestation_for(self) end end def update_state_dates if initiated? && !self.initiated_at self.initiated_at = DateTime.now elsif received? && !self.received_at self.received_at = DateTime.now elsif TERMINE.include?(state) self.processed_at = DateTime.now end end def serialize_value_for_export(value) value.nil? || value.kind_of?(Time) ? value : value.to_s end def send_dossier_received if state_changed? && EN_INSTRUCTION.include?(state) NotificationMailer.send_dossier_received(id).deliver_later end end end