ETQ instructeur, faire une même action sur plusieurs dossiers (passer en instruction, clôturer, demander un avis, ...)

[dzc34]

Résumé

ETQ instructeur, je souhaite faire une même action sur plusieurs dossiers (passer en instruction, clôturer, ...)

voir en commentaire la liste des actions (déjà implémentées, à implémenter ou qui ne seront pas implémentées) :
--------> #7805 (comment)

Cadre de cette contribution

• L'ADULLACT est intéressé pour proposer cette évolution sur son instance DS.
• Notre souhait est d'intégrer cette fonctionnalité sous forme de contribution au code source du logiciel DS.
• Nous avons mandaté le prestataire @synbioz pour développer cette fonctionnalité dans l'optique d'une contribution.
• Si c'est nécessaire, @akarzim et @jobygoude de @synbioz pourront interagir avec l'équipe betagouv sur ce ticket et sur les PRs (répondre aux commentaires, pousser des correctifs, ...).

• Ressource Adullact sur cette fonctionnalité
• réunion de cadrage technique du 29/09/2022 en commentaire de ce ticket.

Demande initiale

via l'ARNIA (août 2022) à l'Adullact

Sur une démarche, les instructeurs reçoivent 30 dossiers par jour, et souhaite clôturer en un coup, les 30 demandes reçues le lundi, puis en un coup les 30 reçues le mardi.

Une mairie traite plusieurs dizaines de demande d’acte de naissance par jour, elle doit se rendre dans chaque démarche pour accepter chaque demande une à une.

Demandes similaires

Suggestion-Votes / Instructeur - passer plusieurs dossiers à la fois en instruction (2021)

Nous pourrions gagner du temps en sélectionnant plusieurs dossiers à la fois, afin de les passer en instruction, acceptation, etc. Aujourd'hui, il faut les sélectionner un par un, ce qui peut être fastidieux.

Suggestion-Votes / Instructeur - Faciliter l'archivage des dossiers (2021)

Il sera plus facile et rapide d'avoir une case à cocher pour définir les dossiers à passer en archivage

Github Milestone - Traitement multiple de dossiers (instructeurs)

Github #5468 - ETQ Instructeur, je peux faire une même action sur des dossiers multiples

Exemples d'actions demandées :

• Accepter ou refuser des dossiers en masse
• Envoyer un même message à plusieurs dossiers

Github #2715 - ETQ Instructeur, j'aimerais passer plusieurs dossiers en archivés en même temps

actions demandée : passer plusieurs dossiers en archivés en même temps

Github #2013 - ETQ accompagnateur je veux demander des avis par batch de dossiers

actions demandée : demander un avis à la même personne pour des dossiers sélectionnés

Github #1617 - ETQ Instructeur je veux effectuer des actions de masse sur les dossiers

Exemples d'actions demandées :

• passage de plusieurs dossiers en "archivés"
• demander un avis à la même personne pour des dossiers sélectionnés

Actuellement

Si l'instructeur doit appliquer la même action sur plusieurs dossiers, il doit ouvrir un par un chaque dossier et appliquer à chaque fois la même action (Passer en instruction, Accepter, Archiver, ...).

Comportement attendu

L'instructeur peut sélectionner plusieurs dossiers
et appliquer en même temps la même action (1) sur les dossiers sélectionnés.

voir en commentaire la liste des actions (déjà implémentées, à implémenter ou qui ne seront pas implémentées) :
--------> #7805 (comment)

---

Cahier des charges

User story

Format : “En tant que” (ETQ), “je souhaite”, “afin de”

ETQ instructeur, 
Je souhaite, sélectionner plusieurs dossiers 
             et appliquer en même temps la même action (1) sur ces dossiers 
Afin de pouvoir traiter rapidement ces dossiers 

User story par type d'action

Suivre plusieurs dossiers

ETQ instructeur, 
Je souhaite, sélectionner plusieurs dossiers dans la liste des dossiers à suivre,
             et les suivre en même temps
Afin de pouvoir traiter rapidement ces dossiers 

---

Ne plus suivre plusieurs dossiers

ETQ instructeur, 
Je souhaite, sélectionner plusieurs dossiers dans la liste des dossiers suivis, 
             et ne plus les suivre en même temps
Afin de pouvoir traiter rapidement ces dossiers 

---

Passer "en instruction" plusieurs dossiers

ETQ instructeur, 
Je souhaite, sélectionner plusieurs dossiers dont le status est "en construction", 
             et les passer "en instruction" en même temps
Afin de pouvoir traiter rapidement ces dossiers 

---

Accepter, refuser ou "classer sans suite" plusieurs dossiers

ETQ instructeur, 
Je souhaite, sélectionner plusieurs dossiers dont le status est "en instruction",
             et rendre une décision identique ("accepter", "refuser" ou "classer sans suite") 
             sur ces dossiers en même temps
Afin de pouvoir traiter rapidement ces dossiers 

---

Archiver plusieurs dossiers :

ETQ instructeur, 
Je souhaite, sélectionner plusieurs dossiers 
             dont le status est "accepté", "refusé" ou "classer sans suite",
             et archiver  sur ces dossiers en même temps
Afin de pouvoir traiter rapidement ces dossiers 

---

Demander un avis à la même personne sur plusieurs dossiers :

ETQ instructeur, 
Je souhaite, sélectionner plusieurs dossiers 
             et demander un avis à la même personne pour ces dossiers sélectionnés
Afin de pouvoir traiter rapidement ces dossiers 

---

Envoyer un message identique aux usagers de plusieurs dossiers :

ETQ instructeur, 
Je souhaite, sélectionner plusieurs dossiers 
             et envoyer en même temps le même message aux usagers des dossiers sélectionnées
Afin de pouvoir traiter rapidement ces dossiers 

...

Tests d'acceptation

TODO : à compléter en fonction des choix UX

Passer "en instruction" plusieurs dossiers

ETQ instructeur
Quand je sélectionne plusieurs dossiers en construction
Alors je peux les passer en instruction en même temps

Accepter, refuser ou "classer sans suite" plusieurs dossiers

ETQ instructeur
Quand je sélectionne plusieurs dossiers en instruction
Alors je peux rendre une décision identique ("accepter", "refuser" ou "classer sans suite") sur ces dossiers

Problématique UX

• Les actions possibles sur un dossier dépendent à la fois de son status ("en instruction", "en construction", "accepté", ...) et de flags associés à ce dossier (suivis par l'instructeur, archivé, supprimé)
• Certains onglets ("à suivre", "suivis", "au total") affichent des dossiers qui peuvent avoir des status différents ("en instruction", "en construction", "accepté", ...) et des actions possibles très différentes.
• ...

TODO : planifier un échange UX

• comment gérer les actions sur des dossiers ayants des status/flags différents ?
• utiliser un système à la Gitlab avec un bouton "Modfier les dossiers" ?
• utiliser une page dédiée au traitement par lot, pour présélectionner le type de dossier à manipuler (dossiers en construction, dossiers en instruction, dossiers suivis, ...)

Status possibles des dossiers en fonction du type liste (onglet) :

Onglet	Status possibles des dossiers	URL
à suivre	en instruction en construction	(2) /procedures/<idProcedure>?statut=a-suivre
suivis	en instruction en construction	(3) /procedures/<idProcedure>?statut=suivis
traité	accepté refusé classé sans suite	(4) /procedures/<idProcedure>?statut=traites
au total	en instruction en construction accepté refusé classer sans suite	(5) /procedures/<idProcedure>?statut=tous
supprimés	accepté refusé classer sans suite	(6) /procedures/<idProcedure>?statut=supprimes_recemment
archivés	accepté refusé classer sans suite	(7) /procedures/<idProcedure>?statut=archives

Actions possibles en fonction du status du dossier et des flags

Status du dossier	Flags	Action possible
en construction	suivis	ne plus suivre envoyer un message demander un avis passer en instruction
en construction	à suivre	suivre envoyer un message demander un avis passer en instruction
en instruction	suivis	ne plus suivre envoyer un message demander un avis re-passer en construction classer sans suite accepté refusé
en instruction	à suivre	suivre envoyer un message demander un avis re-passer en construction classer sans suite accepté refusé
classer sans suite accepté refusé	-	Archiver Supprimer
classer sans suite accepté refusé	archivé	Désarchiver
classer sans suite accepté refusé	supprimé	Restaurer

---

trackingAdullactContrib trackingAdullactARNiaContrib

[dzc34]

@tchak @krichtof ticket complété

[mfo]

@dzc34 ; on commence a se demander si on ouvrirait pas ce sujet de notre coté. je me demande ou vous en êtes :-)

[dzc34]

Avec un peu de retard, le résumé de la réunion de cadrage du 26/09/2022
entre équipe DS (@emsnytech @krichtof @tchak), Synbioz (@akarzim) et l'Adullact (@dzc34).

• L'équipe DS est Ok pour cette fonctionnalité, mais demande une préparation technique
• Problématiques évoquées
  • volumétrie ---> risque de timeout actuellement
  • état final des dossiers en DB à garantir

---

Avec un peu de retard, le résumé de la réunion de cadrage technique du 29/09/2022
entre équipe DS (@krichtof @tchak), Synbioz (@akarzim) et l'Adullact (@dzc34).

1 action sur un dossier, c'est plusieurs traitements

• écriture en base
• envoi un mail
• écrit un audit log ---> qui écrit dans le bucket

1 action sur X dossier

• risque de timeout actuellement
• side effects dans certaines tâches associées à l'action
• état final DB à garantir

Analyse des problématiques

• refacto à faire pour isoler les "side effects"
• jobs des traitements
• pb des erreurs
• pb des erreurs sur les mails

UI en cas du traitement en cours et d'erreur ---> voir avec l'UX de l'équipe DS

• proposition 1 : message "c'est bon" ---> si erreur "non c'est pas possible"
• proposition 2 : ...

Principes

• chaque dossier est vu dans sa propre transaction
• sélection limitée à la page ---> pas les 25 000 dossiers
• 1 job par page (25 dossiers)

Planification

• Planifier un échange avec l'UX de l'équipe DS
• (1) refacto pour séparer les appels DB et side effects
• (2) 1er étape (facile) ---> pas de mail
  • l'archivage / Désarchiver de plusieurs dossiers
  • suivre / ne plus suivre
• (3) 2ème étape ---> mails envoyés dans certains cas
  • suppression (soft) / restaurer
• (4) 3ème étape ---> mails envoyés
  • passer en instruction
  • repasser en construction
  • repasser en instruction
• (5) 4ème étape --> mails envoyés + éventuellement un fichier
  • accepter
  • refuser
  • classé sans suite
• (6) Envoyer un message identique aux usagers de plusieurs dossiers
• (7) Demander un avis aux même expert sur plusieurs dossiers

(7)(6)(5)(4)(3)(2)(1) ----> créer un ticket dédié à chaque fois

Remarques

pour "Envoyer un message identique sur plusieurs dossiers"

• poser une limite (à la page, ou un max) pour éviter l'effet newsletter

pour "Demander un avis aux même expert"

• voir autre US : 1 expert sur touts les dossiers --> TODO @dzc34 à trouver sur Github

[mfo]

@tchak ; l'impression que le préambule a tous ça c'est un refacto pour isoler les appels db/side effects. t'avais une cible la dessous ou pas ?

[dzc34]

remarque de @akarzim sur le refacto

refacto à faire pour isoler les "side effects"

La refacto proposée devrait porter sur plusieurs axes :

• encapsuler les requêtes DB dans des transactions ;
• logguer de façon asynchrone ;
• optimisation de certaines requêtes (?) ;
• extraire la logique dans des services pour soulager le modèle dossier qui fait près de 1300 lignes (?) ;
• consolider les tests.

[dzc34]

notes techniques de @akarzim pour l'étape 1
et 1 question :

• pas de log pour l'action de (ne plus) suivre un dossier ?

---

Opérations possibles sur un dossier par un instructeur

# app/models/dossier_operation_log.rb
enum operation: {                                          
  changer_groupe_instructeur: 'changer_groupe_instructeur', # par l'administrateur uniquement
  passer_en_instruction: 'passer_en_instruction',          
  repasser_en_construction: 'repasser_en_construction',    
  repasser_en_instruction: 'repasser_en_instruction',      
  accepter: 'accepter',                                    
  refuser: 'refuser',                                      
  classer_sans_suite: 'classer_sans_suite',                
  supprimer: 'supprimer',                                  
  restaurer: 'restaurer',                                  
  modifier_annotation: 'modifier_annotation',              
  demander_un_avis: 'demander_un_avis',                    
  archiver: 'archiver',                                    
  desarchiver: 'desarchiver'                               
}                                                          

1ère étape (facile) -> pas de mail

Archivage

# app/controllers/instructeurs/dossiers_controller.rb
def archive                                                              
  dossier.archiver!(current_instructeur)                                 
  redirect_back(fallback_location: instructeur_procedure_path(procedure))
end                                                                      

# app/models/dossier.rb
def archiver!(author)                     
  update!(archived: true)                 
  log_dossier_operation(author, :archiver)
end                                       

# app/controllers/instructeurs/dossiers_controller.rb
def unarchive                                                            
  dossier.desarchiver!(current_instructeur)                              
  redirect_back(fallback_location: instructeur_procedure_path(procedure))
end                                                                      

# app/models/dossier.rb
def desarchiver!(author)                     
  update!(archived: false)                   
  log_dossier_operation(author, :desarchiver)
end                                          

Suivre un dossier

# app/controllers/instructeurs/dossiers_controller.rb
def follow                                                               
  current_instructeur.follow(dossier)                                    
  flash.notice = 'Dossier suivi'                                         
  redirect_back(fallback_location: instructeur_procedure_path(procedure))
end                                                                      

# app/models/instructeur.rb
def follow(dossier)                                                               
  begin                                                                           
    followed_dossiers << dossier                                                  
    # If the user tries to follow a dossier she already follows,                  
    # we just fail silently: it means the goal is already reached.                
  rescue ActiveRecord::RecordNotUnique                                            
    # Database uniqueness constraint                                              
  rescue ActiveRecord::RecordInvalid => e                                         
    # ActiveRecord validation                                                     
    raise unless e.record.errors.details.dig(:instructeur_id, 0, :error) == :taken
  end                                                                             
end                                                                               

# app/controllers/instructeurs/dossiers_controller.rb
def unfollow                                                             
  current_instructeur.unfollow(dossier)                                  
  flash.notice = "Vous ne suivez plus le dossier nº #{dossier.id}"       
                                                                         
  redirect_back(fallback_location: instructeur_procedure_path(procedure))
end                                                                      

# app/models/instructeur.rb
def unfollow(dossier)                     
  f = follows.find_by(dossier: dossier)   
  if f.present?                           
    f.update(unfollowed_at: Time.zone.now)
  end                                     
end                                       

Question : pas de log pour l'action de (ne plus) suivre un dossier ?

[dzc34]

notes techniques de @akarzim pour l'étape 2
et 2 questions / remarques

• Les transactions c'est bien, mais ne devrait-on pas envisager d'en exclure les logs ? Dit autrement, si le log crash, faut-il annuler la mise à jour ?
• Pourquoi n'envoie-t-on pas d'email aux administrateurs quand un dossier est restauré ?

---

2ème étape ---> mails envoyés dans certains cas

Suppression / Restauration

# app/controllers/instructeurs/dossiers_controller.rb
def destroy                                                                
  if dossier.termine?                                                      
    dossier.hide_and_keep_track!(current_instructeur, :instructeur_request)
    flash.notice = t('instructeurs.dossiers.deleted_by_instructeur')       
  else                                                                     
    flash.alert = t('instructeurs.dossiers.impossible_deletion')           
  end                                                                      
  redirect_back(fallback_location: instructeur_procedure_path(procedure))  
end                                                                        

# app/models/dossier.rb
def hide_and_keep_track!(author, reason)                                                                                                  
  transaction do                                                                                                                          
    if author_is_administration(author) && can_be_deleted_by_administration?(reason)                                                      
      update(hidden_by_administration_at: Time.zone.now, hidden_by_reason: reason)                                                        
    elsif author_is_user(author) && can_be_deleted_by_user?                                                                               
      update(hidden_by_user_at: Time.zone.now, dossier_transfer_id: nil, hidden_by_reason: reason)                                        
    else                                                                                                                                  
      raise "Unauthorized dossier hide attempt Dossier##{id} by #{author} for reason #{reason}"                                           
    end                                                                                                                                   
                                                                                                                                          
    log_dossier_operation(author, :supprimer, self)                                                                                       
  end                                                                                                                                     
                                                                                                                                          
  if en_construction? && !hidden_by_administration?                                                                                       
    administration_emails = followers_instructeurs.present? ? followers_instructeurs.map(&:email) : procedure.administrateurs.map(&:email)
    administration_emails.each do |email|                                                                                                 
      DossierMailer.notify_en_construction_deletion_to_administration(self, email).deliver_later                                          
    end                                                                                                                                   
  end                                                                                                                                     
end                                                                                                                                       

# app/controllers/instructeurs/dossiers_controller.rb
def restore                                                                 
  dossier = current_instructeur.dossiers.find(params[:dossier_id])          
  dossier.restore(current_instructeur)                                      
  flash.notice = t('instructeurs.dossiers.restore')                         
                                                                            
  if dossier.termine?                                                       
    redirect_to instructeur_procedure_path(procedure, statut: :traites)     
  else                                                                      
    redirect_back(fallback_location: instructeur_procedure_path(procedure)) 
  end                                                                       
end                                                                         

# app/models/dossier.rb
def restore(author)                                  
  transaction do                                     
    if author_is_administration(author)              
      update(hidden_by_administration_at: nil)       
    elsif author_is_user(author)                     
      update(hidden_by_user_at: nil)                 
    end                                              
                                                     
    if !hidden_by_user? && !hidden_by_administration?
      update(hidden_by_reason: nil)                  
    end                                              
                                                     
    log_dossier_operation(author, :restaurer, self)  
  end                                                
end                                                  

Questions / Remarques :

• Les transactions c'est bien, mais ne devrait-on pas envisager d'en exclure les logs ? Dit autrement, si le log crash, faut-il annuler la mise à jour ?
• Pourquoi n'envoie-t-on pas d'email aux administrateurs quand un dossier est restauré ?

[dzc34]

notes techniques de @akarzim pour l'étape 3

3ème étape ---> mails envoyés

# app/controllers/instructeurs/dossiers_controller.rb
def passer_en_instruction                                             
  begin                                                               
    dossier.passer_en_instruction!(instructeur: current_instructeur)  
    flash.notice = 'Dossier passé en instruction.'                    
  rescue AASM::InvalidTransition => e                                 
    flash.alert = aasm_error_message(e, target_state: :en_instruction)
  end                                                                 
                                                                      
  @dossier = dossier                                                  
  render :change_state                                                
end

# app/models/dossier.rb
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_instruction, after: :after_passer_en_instruction do
    transitions from: :en_construction, to: :en_instruction           
  end                                                                 
end

def after_passer_en_instruction(h)                                         
  instructeur = h[:instructeur]                                            
  disable_notification = h.fetch(:disable_notification, false)             
                                                                           
  instructeur.follow(self)                                                 
                                                                           
  self.en_construction_close_to_expiration_notice_sent_at = nil            
  self.conservation_extension = 0.days                                     
  self.en_instruction_at = self.traitements                                
    .passer_en_instruction(instructeur: instructeur)                       
    .processed_at                                                          
  save!                                                                    
                                                                           
  if !procedure.declarative_accepte? && !disable_notification              
    NotificationMailer.send_en_instruction_notification(self).deliver_later
  end                                                                      
  log_dossier_operation(instructeur, :passer_en_instruction)               
end                                                                        

Remarques :

• Les autres actions sont très similaires ;
• Plus complexe ici, on passe par une machine à états sur le dossier ;
• On touche à plusieurs objets ici (dossier, instructeur, traitements), il faudra penser à encapsuler ça dans une transaction ;
• La notification mail est faite de manière asynchrone ;
• Nous devrions très certainement faire de même pour les logs.

[dzc34]

notes techniques de @akarzim pour l'étape 4

4ème étape --> mails envoyés + éventuellement un fichier

# app/controllers/instructeurs/dossiers_controller.rb
def terminer                                                                                  
  motivation = params[:dossier] && params[:dossier][:motivation]                              
  justificatif = params[:dossier] && params[:dossier][:justificatif_motivation]               
                                                                                              
  h = { instructeur: current_instructeur, motivation: motivation, justificatif: justificatif }
                                                                                              
  begin                                                                                       
    case params[:process_action]                                                              
    when "refuser"                                                                            
      target_state = :refuse                                                                  
      dossier.refuser!(h)                                                                     
      flash.notice = "Dossier considéré comme refusé."                                        
    when "classer_sans_suite"                                                                 
      target_state = :sans_suite                                                              
      dossier.classer_sans_suite!(h)                                                          
      flash.notice = "Dossier considéré comme sans suite."                                    
    when "accepter"                                                                           
      target_state = :accepte                                                                 
      dossier.accepter!(h)                                                                    
      flash.notice = "Dossier traité avec succès."                                            
    end                                                                                       
  rescue AASM::InvalidTransition => e                                                         
    flash.alert = aasm_error_message(e, target_state: target_state)                           
  end                                                                                         
                                                                                              
  @dossier = dossier                                                                          
  render :change_state                                                                        
end

# app/models/dossier.rb
def after_accepter(h)                                               
  instructeur = h[:instructeur]                                     
  motivation = h[:motivation]                                       
  justificatif = h[:justificatif]                                   
  disable_notification = h.fetch(:disable_notification, false)      
                                                                    
  self.processed_at = self.traitements                              
    .accepter(motivation: motivation, instructeur: instructeur)     
    .processed_at                                                   
  save!                                                             
                                                                    
  if justificatif                                                   
    self.justificatif_motivation.attach(justificatif)               
  end                                                               
                                                                    
  if attestation.nil?                                               
    self.attestation = build_attestation                            
  end                                                               
                                                                    
  save!                                                             
  remove_titres_identite!                                           
  if !disable_notification                                          
    NotificationMailer.send_accepte_notification(self).deliver_later
  end                                                               
  send_dossier_decision_to_experts(self)                            
  log_dossier_operation(instructeur, :accepter, self)               
end

Remarques :

• Les autres actions sont très similaires ;
• On passe ici aussi par une machine à états sur le dossier ;
• On attache des fichiers ;
• On envoie des notifications mail en asynchrone ;
• On transmet la décision aux experts, en asynchrone, mais avec des requêtes supplémentaire sur les avis ;
• On nettoie certaines données de manière asynchrone ;
• Ici encore, les logs devraient être fait de manière asynchrone ;
• Et encapsuler le tout (hors async) dans une transaction serait bienvenu.

[mfo]

notes techniques de @akarzim pour l'étape 1

Question : pas de log pour l'action de (ne plus) suivre un dossier ?

@akarzim / @dzc34 : pas de log c'est pas une info importante (au point qu'on penser arreter de logguer sur archive

[mfo]

notes techniques de @akarzim pour l'étape 2

Questions / Remarques :

* Les transactions c'est bien, mais ne devrait-on pas envisager d'en exclure les logs ? Dit autrement, si le log crash, faut-il annuler la mise à jour ?

Pour des raisons de sécurité/traçabilité, il nous faut les logs, il me semble que ca va forcement de pair. @LeSim / @tchak une confirmation serait top

* Pourquoi n'envoie-t-on pas d'email aux administrateurs quand un dossier est restauré ?

Je ne sais pas, p-e que le besoin n'a jamais été remonté

[mfo]

notes techniques de @akarzim pour l'étape 3

Remarques :

• Les autres actions sont très similaires ;
• Plus complexe ici, on passe par une machine à états sur le dossier ;
• On touche à plusieurs objets ici (dossier, instructeur, traitements), il faudra penser à encapsuler ça dans une transaction ;
• La notification mail est faite de manière asynchrone ;
• Nous devrions très certainement faire de même pour les logs.

Remarque sur les logs en asynchrone, de ma comprehension le dossier est serialisé au moment du logs, le passage en asynchrone n'est pas impossible, mais il faudrait serializer l'etat du dossier au moment du passage en async. @LeSim / @tchak, pas enorme visibilité la dessus, possible que vous confirmiez (ou pas?)

[LeSim]

Questions / Remarques :

* Les transactions c'est bien, mais ne devrait-on pas envisager d'en exclure les logs ? Dit autrement, si le log crash, faut-il annuler la mise à jour ?

Pour des raisons de sécurité/traçabilité, il nous faut les logs, il me semble que ca va forcement de pair. @LeSim / @tchak une confirmation serait top

Oui, je confirme, ces logs sont importants. S'ils ne sont pas écrit, on ne veut pas réaliser l'action.

[LeSim]

Remarque sur les logs en asynchrone, de ma comprehension le dossier est serialisé au moment du logs, le passage en asynchrone n'est pas impossible, mais il faudrait serializer l'etat du dossier au moment du passage en async. @LeSim / @tchak, pas enorme visibilité la dessus, possible que vous confirmiez (ou pas?)

je n'ai pas très bien compris le coup de l'asynchrone.

Tout ce que je peux vous dire c'est que le log représente l'état du dossier au moment ou l'action est prise. Si on ne fait pas les 2 en mm temps (passage_en_instruction, log) on ne peut pas prouver que notre log est correct.

[dzc34]

Commentaire pour le suivi Adullact (@cmayran @dzc34)

voir

• Batch / traitement multiple #8076
  • amélioration(instructeur/dossiers): ETQ instructeur je peux archiver en masse des dossiers #8081
  • fix(notifications) : réintégrer les pastilles dans les tableaux avec actions multiples #8216
  • US/po-multiple (fix) Afficher les checkbox uniquement sur les pages des batchs  #8291
  • Us/poc multiple passer en instruction #8268
  • Us/poc multiple - suivre les dossiers #8379
  • Us/poc design - reorganisation filtres + logique des boutons si plus de 3 actions #8394
  • Us/poc multiple accepter #8315
  • feat(batch_operation): enable only available operations #8385
  • fix(dossier): disable buttons when selection is canceled #8408
  • Us/poc multiple - 2 dernières actions de l'onglet suivi #8433
  • [Bug] Affichage des alertes pour les actions multiples #8456
    • [Bug] Affichage des alertes pour les actions multiples #8518
  • ETQ instructeur, je peux demander un avis sur plusieurs dossiers #8517
  • ETQ instructeur je peux sélectionner des dossiers en plus de ceux visibles sur une page pour les actions multiples #8457
    • Sélectionner des dossiers en plus de ceux visibles sur une page pour les actions multiples #8486
  • En tant qu'instructeur, je veux pouvoir classer sans suite ou refuser des dossiers en masse. #9224
    • [Actions multiples] Ajouter la possibilité pour les instructeurs de classer sans suite et refuser  #9274
• ETQ instructeur, je souhaite pouvoir demander un avis d'expert via les actions multiples #9609
• feat: batch action for supprimer #9717
• Feature ouidou/batch action on dossiers restaurer #9764
• Feature ouidou/batch action on dossiers desarchiver #9766
• Feature ouidou/batch action on dossiers passer en instruction depuis a suivre #9768
• Feature ouidou/batch action on dossiers repousser date suppression #9772

---

Actions par lot : ⏳

• Onglet [ à suivre ] ✔️
  • Suivre plusieurs dossiers --> ✔️ PR #8379 par l'équipe DS
  • Passer "en instruction" plusieurs dossiers ----> ✔️ par l'Adullact PR #9768
• Onglet [ suivis ]
  • Ne plus suivre plusieurs dossiers --> ✔️ PR #8433 par l'équipe DS
  • Passer "en instruction" plusieurs dossiers --> ✔️ PR #8268 par l'équipe DS
  • Re-passer "en construction" plusieurs dossiers "en instruction" --> ✔️ PR #8433 par l'équipe DS
  • Accepter plusieurs dossiers --> ✔️ PR #8315 par l'équipe DS
  • Refuser plusieurs dossiers ---> ✔️ PR #9274 par l'équipe DS
  • Classer sans suite plusieurs dossiers ---> ✔️ PR #9274 par l'équipe DS
  • Demander un avis à la même personne sur plusieurs dossiers ---> 🏁 par l’équipe DS Ticket #9609
  • Envoyer un message identique aux usagers de plusieurs dossiers ---> 🛑 ne sera pas implémenté (1)
• Onglet [ traités ] ✔️
  • Archiver plusieurs dossiers "Accepté", "Refusé" ou "classer sans suite" --> ✔️ PR #8081 par l'équipe DS
  • Supprimer plusieurs dossiers "Accepté", "Refusé" ou "classer sans suite" ----> ✔️ par l'Adullact PR #9717
  • Re-passer "en instruction" plusieurs dossiers "Accepté", "Refusé" ou .... ---> 🛑 ne sera pas implémenté (2)
• Onglet [ supprimés ] ✔️
  • Restaurer plusieurs dossiers "Supprimés" ----> ✔️ par l'Adullact PR #9764
• Onglet [ expirants ] ✔️
  • Repousser la date de suppression de plusieurs dossiers ----> ✔️ par l'Adullact PR #9772
• Onglet [ archivés ] ✔️
  • Désarchiver plusieurs dossiers archivés ----> ✔️ par l'Adullact PR #9766

---

⚠️ (1) ---> 🛑 ne sera pas implémenté

• Envoyer un message identique aux usagers de plusieurs dossiers

explication :

• pose des questions d'UX assez complexes et des modifications conséquentes de l'interface.
• éviter l'effet newsletter

---

⚠️ (2) ---> 🛑 ne sera pas implémenté

• Re-passer "en instruction" plusieurs dossiers "Accepté", "Refusé" ou "classer sans suite"

explication :

• compliqué de revenir sur plusieurs dossiers qui ont déjà été traités : pas envie de faciliter cet usage. (dixit équipe DS)