demarches-normaliennes/app/controllers/stats_controller.rb

class StatsController < ApplicationController
  layout "new_application"

  before_action :authenticate_administration!, only: [:download]

  MEAN_NUMBER_OF_CHAMPS_IN_A_FORM = 24.0

  def index
    procedures = Procedure.publiees_ou_archivees
    dossiers = Dossier.state_not_brouillon

    @procedures_numbers = procedures_numbers(procedures)
    @dossiers_numbers = dossiers_numbers(dossiers)

    @satisfaction_usagers = satisfaction_usagers

    @contact_percentage = contact_percentage
    @contact_percentage_excluded_tags = Helpscout::UserConversationsAdapter::EXCLUDED_TAGS

    @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)

    if administration_signed_in?
      @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

      @avis_usage = avis_usage
      @avis_average_answer_time = avis_average_answer_time
      @avis_answer_percentages = avis_answer_percentages

      @motivation_usage_dossier = motivation_usage_dossier
      @motivation_usage_procedure = motivation_usage_procedure

      @cloned_from_library_procedures_ratio = cloned_from_library_procedures_ratio
    end
  end

  def download
    headers = [
      'ID du dossier',
      'ID de la démarche',
      'Nom de la démarche',
      '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

  private

  def procedures_numbers(procedures)
    total = procedures.count
    last_30_days_count = procedures.where(published_at: 1.month.ago..Time.zone.now).count
    previous_count = procedures.where(published_at: 2.months.ago..1.month.ago).count
    if previous_count != 0
      evolution = (((last_30_days_count.to_f / previous_count) - 1) * 100).round(0)
    else
      evolution = 0
    end
    formatted_evolution = format("%+d", evolution)

    {
      total: total.to_s,
      last_30_days_count: last_30_days_count.to_s,
      evolution: formatted_evolution
    }
  end

  def dossiers_numbers(dossiers)
    total = dossiers.count
    last_30_days_count = dossiers.where(en_construction_at: 1.month.ago..Time.zone.now).count
    previous_count = dossiers.where(en_construction_at: 2.months.ago..1.month.ago).count
    if previous_count != 0
      evolution = (((last_30_days_count.to_f / previous_count) - 1) * 100).round(0)
    else
      evolution = 0
    end
    formatted_evolution = format("%+d", evolution)

    {
      total: total.to_s,
      last_30_days_count: last_30_days_count.to_s,
      evolution: formatted_evolution
    }
  end

  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 = {
      Feedback.ratings.fetch(:happy)    => "Satisfaits",
      Feedback.ratings.fetch(:neutral)  => "Neutres",
      Feedback.ratings.fetch(:unhappy)  => "Mécontents"
    }
    interval = 6.weeks.ago.beginning_of_week..1.week.ago.beginning_of_week

    totals = Feedback
      .where(created_at: interval)
      .group_by_week(:created_at)
      .count

    Feedback.ratings.values.map do |rating|
      data = Feedback
        .where(created_at: interval, rating: rating)
        .group_by_week(:created_at)
        .count
        .map do |week, count|
          total = totals[week]

          if total > 0
            [week, (count.to_f / total * 100).round(2)]
          else
            0
          end
        end.to_h

      {
        name: legend[rating],
        data: data
      }
    end
  end

  def contact_percentage
    from = Date.new(2018, 1)
    to = Date.today.prev_month

    adapter = Helpscout::UserConversationsAdapter.new(from, to)
    if !adapter.can_fetch_reports?
      return nil
    end

    adapter
      .reports
      .map do |monthly_report|
        start_date = monthly_report[:start_date].to_time.localtime
        end_date = monthly_report[:end_date].to_time.localtime
        replies_count = monthly_report[:conversations_count]

        dossiers_count = Dossier.where(en_construction_at: start_date..end_date).count

        monthly_contact_percentage = replies_count.fdiv(dossiers_count || 1) * 100
        [I18n.l(start_date, format: '%b %y'), monthly_contact_percentage.round(1)]
      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.zone.now.to_date
    else
      Time.zone.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})")
      .count
      .to_a
      .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} < ?", max_date)
      .group("DATE_TRUNC('month', #{date_attribute})")
      .count
      .to_a
      .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 démarche' => count_per_administrateur.select { |count| count == 1 }.count,
      'Entre deux et cinq démarches' => count_per_administrateur.select { |count| count.in?(2..5) }.count,
      'Plus de cinq démarches' => count_per_administrateur.select { |count| count > 5 }.count
    }
  end

  def mean(collection)
    (collection.sum.to_f / collection.size).round(2)
  end

  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.zone.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.zone.now.to_date

    processed_dossiers = dossiers
      .where(:processed_at => min_date..max_date)
      .pluck(
        :procedure_id,
        Arel.sql('EXTRACT(EPOCH FROM (en_construction_at - created_at)) / 60 AS processing_time'),
        :processed_at
      )

    # Group dossiers by month
    processed_dossiers_by_month = processed_dossiers
      .group_by do |(*_, processed_at)|
        processed_at.beginning_of_month.to_s
      end

    procedure_id_type_de_champs_count = TypeDeChamp
      .where(private: false)
      .group(:procedure_id)
      .count

    processed_dossiers_by_month.map do |month, dossier_plucks|
      # Group the dossiers for this month by procedure
      dossiers_grouped_by_procedure = dossier_plucks.group_by { |(procedure_id, *_)| procedure_id }

      # Compute the mean time for this procedure
      procedure_processing_times = dossiers_grouped_by_procedure.map do |procedure_id, procedure_dossiers|
        procedure_fields_count = procedure_id_type_de_champs_count[procedure_id]

        if (procedure_fields_count == 0 || procedure_fields_count.nil?)
          next
        end

        procedure_dossiers_processing_time = procedure_dossiers.map { |_, processing_time, _| processing_time }
        procedure_mean = mean(procedure_dossiers_processing_time)

        # We normalize the data for 24 fields
        procedure_mean * (MEAN_NUMBER_OF_CHAMPS_IN_A_FORM / procedure_fields_count)
      end
        .compact

      # 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 avis_usage
    [3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |min_date|
      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
        result = percentage(weekly_dossier_with_avis_count, weekly_dossiers_count)
      end

      [min_date.to_i, result]
    end
  end

  def avis_average_answer_time
    [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
    [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
        result = percentage(answered_weekly_avis_count, weekly_avis_count)

        [min_date.to_i, result]
      end
    end
  end

  def motivation_usage_dossier
    [3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |date|
      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
    [3.weeks.ago, 2.weeks.ago, 1.week.ago].map do |date|
      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
end