demarches-normaliennes/app/controllers/stats_controller.rb

370 lines
11 KiB
Ruby
Raw Normal View History

2017-03-24 18:04:37 +01:00
class StatsController < ApplicationController
layout "new_application"
2017-03-24 18:04:37 +01:00
before_action :authenticate_administration!, only: [:download]
MEAN_NUMBER_OF_CHAMPS_IN_A_FORM = 24.0
2017-03-24 18:04:37 +01:00
def index
procedures = Procedure.publiees_ou_archivees
2017-12-04 16:17:15 +01:00
dossiers = Dossier.where.not(:state => :brouillon)
@procedures_count = procedures.count
@dossiers_count = dossiers.count
@satisfaction_usagers = satisfaction_usagers
@dossiers_states = dossiers_states
@procedures_cumulative = cumulative_hash(procedures, :published_at)
@procedures_in_the_last_4_months = last_four_months_hash(procedures, :published_at)
@dossiers_cumulative = cumulative_hash(dossiers, :en_construction_at)
@dossiers_in_the_last_4_months = last_four_months_hash(dossiers, :en_construction_at)
@procedures_count_per_administrateur = procedures_count_per_administrateur(procedures)
2017-06-01 09:44:22 +02:00
@dossier_instruction_mean_time = Rails.cache.fetch("dossier_instruction_mean_time", expires_in: 1.day) do
dossier_instruction_mean_time(dossiers)
end
@dossier_filling_mean_time = Rails.cache.fetch("dossier_filling_mean_time", expires_in: 1.day) do
dossier_filling_mean_time(dossiers)
end
2017-05-09 17:09:35 +02:00
@avis_usage = avis_usage
@avis_average_answer_time = avis_average_answer_time
@avis_answer_percentages = avis_answer_percentages
2017-06-15 14:42:48 +02:00
@motivation_usage_dossier = motivation_usage_dossier
@motivation_usage_procedure = motivation_usage_procedure
@cloned_from_library_procedures_ratio = cloned_from_library_procedures_ratio
2017-03-24 18:04:37 +01:00
end
def download
headers = [
'ID du dossier',
'ID de la procédure',
'Nom de la procédure',
'ID utilisateur',
'Etat du fichier',
'Durée en brouillon',
'Durée en construction',
'Durée en instruction'
]
data = Dossier
.includes(:procedure, :user)
.in_batches
.flat_map do |dossiers|
dossiers
.pluck(
"dossiers.id",
"procedures.id",
"procedures.libelle",
"users.id",
"dossiers.state",
"dossiers.en_construction_at - dossiers.created_at",
"dossiers.en_instruction_at - dossiers.en_construction_at",
"dossiers.processed_at - dossiers.en_instruction_at"
)
end
respond_to do |format|
format.csv { send_data(SpreadsheetArchitect.to_xlsx(headers: headers, data: data), filename: "statistiques.csv") }
end
end
2017-03-24 18:04:37 +01:00
private
def dossiers_states
{
'Brouilllon' => Dossier.state_brouillon.count,
'En construction' => Dossier.state_en_construction.count,
'En instruction' => Dossier.state_en_instruction.count,
'Terminé' => Dossier.state_termine.count
}
end
def satisfaction_usagers
legend = {
"0" => "Mécontents",
"1" => "Neutres",
"2" => "Satisfaits"
}
totals = Feedback.where(created_at: 5.weeks.ago..Time.now).group_by_week(:created_at).count
(0..2).map do |mark|
data = Feedback
.where(created_at: 5.weeks.ago..Time.now, mark: mark)
.group_by_week(:created_at)
.count
.map do |week, count|
total = totals[week]
if total > 0
[week, (count.to_f / total).round(2)]
else
0
end
end.to_h
{
name: legend[mark.to_s],
data: data
}
end
end
def cloned_from_library_procedures_ratio
[3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |date|
min_date = date.beginning_of_week
max_date = min_date.end_of_week
all_procedures = Procedure.created_during(min_date..max_date)
cloned_from_library_procedures = all_procedures.cloned_from_library
denominator = [1, all_procedures.count].max
ratio = percentage(cloned_from_library_procedures.count, denominator)
[l(max_date, format: '%d/%m/%Y'), ratio]
end
end
def max_date
if administration_signed_in?
Time.now.to_date
else
Time.now.beginning_of_month - 1.second
end
end
def last_four_months_hash(association, date_attribute)
min_date = 3.months.ago.beginning_of_month.to_date
association
.where(date_attribute => min_date..max_date)
.group("DATE_TRUNC('month', #{date_attribute.to_s})")
.count
.to_a
2017-11-20 18:55:59 +01:00
.sort_by { |a| a[0] }
.map { |e| [I18n.l(e.first, format: "%B %Y"), e.last] }
end
def cumulative_hash(association, date_attribute)
sum = 0
association
.where("#{date_attribute.to_s} < ?", max_date)
.group("DATE_TRUNC('month', #{date_attribute.to_s})")
.count
.to_a
2017-11-20 18:55:59 +01:00
.sort_by { |a| a[0] }
.map { |x, y| { x => (sum += y) } }
.reduce({}, :merge)
end
def procedures_count_per_administrateur(procedures)
count_per_administrateur = procedures.group(:administrateur_id).count.values
{
'Une procédure' => count_per_administrateur.select { |count| count == 1 }.count,
2017-06-12 16:12:03 +02:00
'Entre deux et cinq procédures' => count_per_administrateur.select { |count| 2 <= count && count <= 5 }.count,
'Plus de cinq procédures' => count_per_administrateur.select { |count| 5 < count }.count
}
end
def mean(collection)
(collection.sum.to_f / collection.size).round(2)
end
2017-06-19 17:29:20 +02:00
def percentage(numerator, denominator)
((numerator.to_f / denominator) * 100).round(2)
end
def dossier_instruction_mean_time(dossiers)
# In the 12 last months, we compute for each month
# the average time it took to instruct a dossier
# We compute monthly averages by first making an average per procedure
# and then computing the average for all the procedures
min_date = 11.months.ago
max_date = Time.now.to_date
processed_dossiers = dossiers
.where(:processed_at => min_date..max_date)
.pluck(:procedure_id, :en_construction_at, :processed_at)
# Group dossiers by month
processed_dossiers_by_month = processed_dossiers
.group_by do |dossier|
dossier[2].beginning_of_month.to_s
end
processed_dossiers_by_month.map do |month, value|
# Group the dossiers for this month by procedure
dossiers_grouped_by_procedure = value.group_by { |dossier| dossier[0] }
# Compute the mean time for this procedure
procedure_processing_times = dossiers_grouped_by_procedure.map do |procedure_id, procedure_dossiers|
procedure_dossiers_processing_time = procedure_dossiers.map do |dossier|
(dossier[2] - dossier[1]).to_f / (3600 * 24)
end
mean(procedure_dossiers_processing_time)
end
# Compute the average mean time for all the procedures of this month
month_average = mean(procedure_processing_times)
[month, month_average]
end.to_h
end
def dossier_filling_mean_time(dossiers)
# In the 12 last months, we compute for each month
# the average time it took to fill a dossier
# We compute monthly averages by first making an average per procedure
# and then computing the average for all the procedures
# For each procedure, we normalize the data: the time is calculated
# for a 24 champs form (the current form mean length)
min_date = 11.months.ago
max_date = Time.now.to_date
processed_dossiers = dossiers
.where(:processed_at => min_date..max_date)
.pluck(:procedure_id, :created_at, :en_construction_at, :processed_at)
# Group dossiers by month
processed_dossiers_by_month = processed_dossiers
.group_by do |e|
e[3].beginning_of_month.to_s
end
processed_dossiers_by_month.map do |month, value|
# Group the dossiers for this month by procedure
dossiers_grouped_by_procedure = value.group_by { |dossier| dossier[0] }
# Compute the mean time for this procedure
procedure_processing_times = dossiers_grouped_by_procedure.map do |procedure_id, procedure_dossiers|
procedure_dossiers_processing_time = procedure_dossiers.map do |dossier|
(dossier[2] - dossier[1]).to_f / 60
end
procedure_mean = mean(procedure_dossiers_processing_time)
# We normalize the data for 24 fields
procedure_fields_count = Procedure.find(procedure_id).types_de_champ.count
procedure_mean * (MEAN_NUMBER_OF_CHAMPS_IN_A_FORM / procedure_fields_count)
end
# Compute the average mean time for all the procedures of this month
month_average = mean(procedure_processing_times)
[month, month_average]
end.to_h
end
2017-05-09 17:09:35 +02:00
def avis_usage
2018-03-06 13:44:29 +01:00
[3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |min_date|
2017-05-09 17:09:35 +02:00
max_date = min_date + 1.week
weekly_dossiers = Dossier.includes(:avis).where(created_at: min_date..max_date).to_a
weekly_dossiers_count = weekly_dossiers.count
if weekly_dossiers_count == 0
result = 0
else
weekly_dossier_with_avis_count = weekly_dossiers.select { |dossier| dossier.avis.present? }.count
2017-06-19 17:29:20 +02:00
result = percentage(weekly_dossier_with_avis_count, weekly_dossiers_count)
2017-05-09 17:09:35 +02:00
end
[min_date.to_i, result]
end
end
def avis_average_answer_time
2018-03-06 13:44:29 +01:00
[3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |min_date|
max_date = min_date + 1.week
average = Avis.with_answer
.where(created_at: min_date..max_date)
.average("EXTRACT(EPOCH FROM avis.updated_at - avis.created_at) / 86400")
result = average ? average.to_f.round(2) : 0
[min_date.to_i, result]
end
end
def avis_answer_percentages
2018-03-06 13:44:29 +01:00
[3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |min_date|
max_date = min_date + 1.week
weekly_avis = Avis.where(created_at: min_date..max_date)
weekly_avis_count = weekly_avis.count
if weekly_avis_count == 0
[min_date.to_i, 0]
else
answered_weekly_avis_count = weekly_avis.with_answer.count
2017-06-19 17:29:20 +02:00
result = percentage(answered_weekly_avis_count, weekly_avis_count)
[min_date.to_i, result]
end
end
end
2017-06-15 14:42:48 +02:00
def motivation_usage_dossier
2018-03-06 13:44:29 +01:00
[3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |date|
2017-06-15 14:42:48 +02:00
min_date = date.beginning_of_week
max_date = date.end_of_week
weekly_termine_dossiers = Dossier.where(processed_at: min_date..max_date)
weekly_termine_dossiers_count = weekly_termine_dossiers.count
weekly_termine_dossiers_with_motivation_count = weekly_termine_dossiers.where.not(motivation: nil).count
if weekly_termine_dossiers_count == 0
result = 0
else
result = percentage(weekly_termine_dossiers_with_motivation_count, weekly_termine_dossiers_count)
end
[l(max_date, format: '%d/%m/%Y'), result]
end
end
def motivation_usage_procedure
2018-03-06 13:44:29 +01:00
[3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |date|
2017-06-15 14:42:48 +02:00
min_date = date.beginning_of_week
max_date = date.end_of_week
procedures_with_dossier_processed_this_week = Procedure
.joins(:dossiers)
.where(dossiers: { processed_at: min_date..max_date })
procedures_with_dossier_processed_this_week_count = procedures_with_dossier_processed_this_week
.uniq
.count
procedures_with_dossier_processed_this_week_and_with_motivation_count = procedures_with_dossier_processed_this_week
.where
.not(dossiers: { motivation: nil })
.uniq
.count
if procedures_with_dossier_processed_this_week_count == 0
result = 0
else
result = percentage(procedures_with_dossier_processed_this_week_and_with_motivation_count, procedures_with_dossier_processed_this_week_count)
end
[l(max_date, format: '%d/%m/%Y'), result]
end
end
2017-03-24 18:04:37 +01:00
end