demarches-normaliennes/app/controllers/instructeurs/procedures_controller.rb

352 lines
11 KiB
Ruby
Raw Normal View History

module Instructeurs
class ProceduresController < InstructeurController
before_action :ensure_ownership!, except: [:index]
before_action :redirect_to_avis_if_needed, only: [:index]
ITEMS_PER_PAGE = 25
2017-09-27 15:16:07 +02:00
def index
2019-09-16 14:04:18 +02:00
@procedures = current_instructeur
.procedures
.kept
2019-09-17 11:11:08 +02:00
.with_attached_logo
.includes(:defaut_groupe_instructeur)
2019-12-18 13:28:29 +01:00
.order(closed_at: :desc, unpublished_at: :desc, published_at: :desc, created_at: :desc)
dossiers = current_instructeur.dossiers.joins(:groupe_instructeur)
@dossiers_count_per_procedure = dossiers.all_state.group('groupe_instructeurs.procedure_id').reorder(nil).count
@dossiers_a_suivre_count_per_procedure = dossiers.without_followers.en_cours.group('groupe_instructeurs.procedure_id').reorder(nil).count
@dossiers_archived_count_per_procedure = dossiers.archived.group('groupe_instructeurs.procedure_id').count
@dossiers_termines_count_per_procedure = dossiers.termine.group('groupe_instructeurs.procedure_id').reorder(nil).count
2019-08-26 15:35:40 +02:00
groupe_ids = current_instructeur.groupe_instructeurs.pluck(:id)
@followed_dossiers_count_per_procedure = current_instructeur
.followed_dossiers
.joins(:groupe_instructeur)
.en_cours
.where(groupe_instructeur_id: groupe_ids)
.group('groupe_instructeurs.procedure_id')
.reorder(nil)
.count
2020-09-10 12:10:38 +02:00
@all_dossiers_counts = {
'à suivre' => @dossiers_a_suivre_count_per_procedure.sum { |_, v| v },
'suivis' => @followed_dossiers_count_per_procedure.sum { |_, v| v },
'traités' => @dossiers_termines_count_per_procedure.sum { |_, v| v },
'dossiers' => @dossiers_count_per_procedure.sum { |_, v| v },
'archivés' => @dossiers_archived_count_per_procedure.sum { |_, v| v }
}
@procedure_ids_en_cours_with_notifications = current_instructeur.procedure_ids_with_notifications(:en_cours)
@procedure_ids_termines_with_notifications = current_instructeur.procedure_ids_with_notifications(:termine)
end
2017-07-11 16:09:03 +02:00
def show
@procedure = procedure
2017-09-28 11:04:18 +02:00
@current_filters = current_filters
@available_fields_to_filters = available_fields_to_filters
# Technically, procedure_presentation already sets the attribute.
# Setting it here to make clear that it is used by the view
@procedure_presentation = procedure_presentation
@displayed_fields_values = displayed_fields_values
@a_suivre_dossiers = current_instructeur
2017-07-11 16:09:03 +02:00
.dossiers
.for_procedure(procedure)
2017-07-11 16:09:03 +02:00
.without_followers
.en_cours
@followed_dossiers = current_instructeur
2017-07-11 16:09:03 +02:00
.followed_dossiers
.where(groupe_instructeur: current_instructeur.groupe_instructeurs)
.for_procedure(procedure)
2017-07-11 16:09:03 +02:00
.en_cours
@followed_dossiers_id = current_instructeur
.followed_dossiers
.where(groupe_instructeur: current_instructeur.groupe_instructeurs)
.for_procedure(procedure)
.pluck(:id)
@termines_dossiers = current_instructeur
.dossiers
.for_procedure(procedure)
.termine
2017-07-11 16:09:03 +02:00
@all_state_dossiers = current_instructeur
.dossiers
.for_procedure(procedure)
.all_state
2017-07-11 16:09:03 +02:00
@archived_dossiers = current_instructeur
.dossiers
.for_procedure(procedure)
.archived
2017-09-28 19:07:18 +02:00
@dossiers = case statut
when 'a-suivre'
@a_suivre_dossiers
when 'suivis'
@followed_dossiers
when 'traites'
@termines_dossiers
when 'tous'
@all_state_dossiers
when 'archives'
@archived_dossiers
end
2017-09-21 16:47:43 +02:00
@has_en_cours_notifications = current_instructeur.notifications_for_procedure(@procedure, :en_cours).exists?
@has_termine_notifications = current_instructeur.notifications_for_procedure(@procedure, :termine).exists?
2020-09-14 13:52:28 +02:00
@not_archived_notifications_dossier_ids = current_instructeur.notifications_for_procedure(@procedure, :not_archived).pluck(:id)
sorted_ids = procedure_presentation.sorted_ids(@dossiers, current_instructeur)
2017-09-27 15:16:07 +02:00
2017-09-28 11:04:18 +02:00
if @current_filters.count > 0
filtered_ids = procedure_presentation.filtered_ids(@dossiers, statut)
2019-09-12 11:26:22 +02:00
filtered_sorted_ids = sorted_ids.filter { |id| filtered_ids.include?(id) }
2017-09-28 11:04:18 +02:00
else
filtered_sorted_ids = sorted_ids
end
2018-03-06 13:44:29 +01:00
page = params[:page].presence || 1
2017-09-27 15:16:07 +02:00
2017-09-28 11:04:18 +02:00
filtered_sorted_paginated_ids = Kaminari
.paginate_array(filtered_sorted_ids)
2017-09-27 15:16:07 +02:00
.page(page)
.per(ITEMS_PER_PAGE)
2017-09-28 11:04:18 +02:00
@dossiers = @dossiers.where(id: filtered_sorted_paginated_ids)
2017-09-27 15:16:07 +02:00
@dossiers = procedure_presentation.eager_load_displayed_fields(@dossiers)
2017-09-28 11:04:18 +02:00
@dossiers = @dossiers.sort_by { |d| filtered_sorted_paginated_ids.index(d.id) }
2017-09-27 15:16:07 +02:00
2017-09-28 11:04:18 +02:00
kaminarize(page, filtered_sorted_ids.count)
2019-12-11 17:42:44 +01:00
assign_exports
2017-07-11 16:09:03 +02:00
end
def deleted_dossiers
@procedure = procedure
2020-03-24 13:53:15 +01:00
@deleted_dossiers = @procedure
2020-03-31 14:33:30 +02:00
.deleted_dossiers
2020-03-24 13:53:15 +01:00
.order(:dossier_id)
.page params[:page]
end
def update_displayed_fields
values = params[:values]
if values.nil?
values = []
end
fields = values.map do |value|
2019-02-13 18:24:41 +01:00
find_field(*value.split('/'))
end
procedure_presentation.update(displayed_fields: fields)
2017-09-27 15:16:07 +02:00
current_sort = procedure_presentation.sort
2019-02-13 17:50:33 +01:00
if !values.include?(field_id(current_sort))
procedure_presentation.update(sort: Procedure.default_sort)
2017-09-27 15:16:07 +02:00
end
redirect_back(fallback_location: instructeur_procedure_url(procedure))
2017-09-27 15:16:07 +02:00
end
def update_sort
current_sort = procedure_presentation.sort
table = params[:table]
column = params[:column]
if table == current_sort['table'] && column == current_sort['column']
order = current_sort['order'] == 'asc' ? 'desc' : 'asc'
else
order = 'asc'
end
sort = {
'table' => table,
'column' => column,
'order' => order
2018-09-20 17:02:28 +02:00
}
2017-09-27 15:16:07 +02:00
procedure_presentation.update(sort: sort)
2017-09-27 15:16:07 +02:00
redirect_back(fallback_location: instructeur_procedure_url(procedure))
end
2017-09-28 11:04:18 +02:00
def add_filter
2017-12-06 17:26:23 +01:00
if params[:value].present?
procedure_presentation.add_filter(statut, params[:field], params[:value])
2017-12-06 17:26:23 +01:00
end
2017-09-28 11:04:18 +02:00
redirect_back(fallback_location: instructeur_procedure_url(procedure))
2017-09-28 11:04:18 +02:00
end
def remove_filter
filters = procedure_presentation.filters
to_remove = params.values_at(:table, :column, :value)
filters[statut].reject! { |filter| filter.values_at('table', 'column', 'value') == to_remove }
2017-09-28 11:04:18 +02:00
procedure_presentation.update(filters: filters)
2017-09-28 11:04:18 +02:00
redirect_back(fallback_location: instructeur_procedure_url(procedure))
2017-09-28 11:04:18 +02:00
end
def download_export
2020-01-29 12:16:38 +01:00
export_format = params[:export_format]
2019-12-11 17:43:24 +01:00
groupe_instructeurs = current_instructeur
.groupe_instructeurs
.where(procedure: procedure)
2019-09-30 11:57:21 +02:00
2020-01-29 12:16:38 +01:00
export = Export.find_or_create_export(export_format, groupe_instructeurs)
2019-12-11 17:43:24 +01:00
if export.ready?
2020-01-29 12:16:38 +01:00
respond_to do |format|
format.js do
@procedure = procedure
assign_exports
flash.notice = "Lexport au format \"#{export_format}\" est prêt. Vous pouvez le <a href=\"#{export.file.service_url}\">télécharger</a>"
2020-01-29 12:16:38 +01:00
end
format.html do
redirect_to export.file.service_url
end
end
2019-12-11 17:43:24 +01:00
else
2019-10-16 11:40:19 +02:00
respond_to do |format|
2019-12-11 17:43:24 +01:00
notice_message = "Nous générons cet export. Veuillez revenir dans quelques minutes pour le télécharger."
2020-01-29 12:16:38 +01:00
2019-10-16 11:40:19 +02:00
format.js do
@procedure = procedure
2019-12-11 17:43:24 +01:00
assign_exports
2020-01-29 12:16:38 +01:00
if !params[:no_progress_notification]
flash.notice = notice_message
end
2019-12-11 17:43:24 +01:00
end
format.html do
redirect_to instructeur_procedure_url(procedure), notice: notice_message
2019-10-16 11:40:19 +02:00
end
end
end
end
2019-03-13 17:37:07 +01:00
def email_notifications
@procedure = procedure
@assign_to = assign_to
end
def update_email_notifications
assign_to.update!(assign_to_params)
2019-03-13 17:37:07 +01:00
flash.notice = 'Vos notifications sont enregistrées.'
redirect_to instructeur_procedure_path(procedure)
2019-03-13 17:37:07 +01:00
end
def stats
@procedure = procedure
@usual_traitement_time = @procedure.stats_usual_traitement_time
@dossiers_funnel = @procedure.stats_dossiers_funnel
@termines_states = @procedure.stats_termines_states
end
private
def assign_to_params
params.require(:assign_to)
.permit(:instant_email_dossier_notifications_enabled, :instant_email_message_notifications_enabled, :daily_email_notifications_enabled, :weekly_email_notifications_enabled)
end
2019-12-11 17:42:44 +01:00
def assign_exports
groupe_instructeurs_for_procedure = current_instructeur.groupe_instructeurs.where(procedure: procedure)
@xlsx_export = Export.find_for_format_and_groupe_instructeurs(:xlsx, groupe_instructeurs_for_procedure)
@csv_export = Export.find_for_format_and_groupe_instructeurs(:csv, groupe_instructeurs_for_procedure)
@ods_export = Export.find_for_format_and_groupe_instructeurs(:ods, groupe_instructeurs_for_procedure)
end
2019-02-13 18:24:41 +01:00
def find_field(table, column)
procedure_presentation.fields.find { |c| c['table'] == table && c['column'] == column }
end
2019-02-13 17:50:33 +01:00
def field_id(field)
2019-02-13 17:53:41 +01:00
field.values_at('table', 'column').join('/')
2019-02-13 17:50:33 +01:00
end
2019-03-13 17:37:07 +01:00
def assign_to
current_instructeur.assign_to.joins(:groupe_instructeur).find_by(groupe_instructeurs: { procedure: procedure })
2019-03-13 17:37:07 +01:00
end
2017-09-28 19:07:18 +02:00
def statut
2018-03-06 13:44:29 +01:00
@statut ||= (params[:statut].presence || 'a-suivre')
2017-09-28 19:07:18 +02:00
end
def procedure
Procedure.find(params[:procedure_id])
end
def ensure_ownership!
if !current_instructeur.procedures.include?(procedure)
2020-01-29 12:16:38 +01:00
flash[:alert] = "Vous navez pas accès à cette démarche"
redirect_to root_path
end
end
def redirect_to_avis_if_needed
if current_instructeur.procedures.count == 0 && current_instructeur.avis.count > 0
redirect_to instructeur_all_avis_path
end
end
def procedure_presentation
@procedure_presentation ||= get_procedure_presentation
end
def get_procedure_presentation
procedure_presentation, errors = current_instructeur.procedure_presentation_and_errors_for_procedure_id(params[:procedure_id])
if errors.present?
flash[:alert] = "Votre affichage a dû être réinitialisé en raison du problème suivant : " + errors.full_messages.join(', ')
end
procedure_presentation
end
def displayed_fields_values
2019-02-13 17:50:33 +01:00
procedure_presentation.displayed_fields.map { |field| field_id(field) }
end
2017-09-28 11:04:18 +02:00
def current_filters
@current_filters ||= procedure_presentation.filters[statut]
end
def available_fields_to_filters
procedure_presentation.fields_for_select
2017-09-28 11:04:18 +02:00
end
2017-09-27 15:16:07 +02:00
def kaminarize(current_page, total)
@dossiers.instance_eval <<-EVAL
def current_page
#{current_page}
end
2017-09-27 15:16:07 +02:00
def total_pages
(#{total} / #{ITEMS_PER_PAGE}.to_f).ceil
end
def limit_value
2017-09-27 15:16:07 +02:00
#{ITEMS_PER_PAGE}
end
def first_page?
current_page == 1
end
def last_page?
current_page == total_pages
end
EVAL
end
end
end