テクニカルディスカバリー — 顧客の本当の課題を掘り当てる

# db/migrate/20250101000001_create_discovery_sessions.rb
class CreateDiscoverySessions < ActiveRecord::Migration[8.0]
  def change
    create_table :discovery_sessions do |t|
      t.references :account, null: false, foreign_key: true
      t.references :fde, null: false, foreign_key: { to_table: :users }
      t.string :title, null: false
      t.datetime :scheduled_at, null: false
      t.integer :duration_minutes, default: 30
      t.decimal :talk_ratio_prospect, precision: 5, scale: 2
      t.decimal :talk_ratio_fde, precision: 5, scale: 2
      t.text :summary
      t.string :status, default: "scheduled"
      t.timestamps
    end
 
    add_index :discovery_sessions, :status
    add_index :discovery_sessions, :scheduled_at
  end
end
 
# db/migrate/20250101000002_create_discovery_questions.rb
class CreateDiscoveryQuestions < ActiveRecord::Migration[8.0]
  def change
    create_table :discovery_questions do |t|
      t.references :discovery_session, null: false, foreign_key: true
      t.string :spin_type, null: false  # situation, problem, implication, need_payoff
      t.text :question, null: false
      t.text :response
      t.text :follow_up_notes
      t.integer :order_position
      t.boolean :was_asked, default: false
      t.timestamps
    end
 
    add_index :discovery_questions, :spin_type
  end
end
 
# db/migrate/20250101000003_create_stakeholders.rb
class CreateStakeholders < ActiveRecord::Migration[8.0]
  def change
    create_table :stakeholders do |t|
      t.references :account, null: false, foreign_key: true
      t.string :name, null: false
      t.string :title
      t.string :email
      t.string :role_type, null: false  # champion, economic_buyer, technical_evaluator, end_user
      t.text :priorities
      t.text :concerns
      t.integer :influence_level, default: 5
      t.timestamps
    end
 
    add_index :stakeholders, :role_type
  end
end

# app/models/discovery_session.rb
class DiscoverySession < ApplicationRecord
  belongs_to :account
  belongs_to :fde, class_name: "User"
  has_many :discovery_questions, dependent: :destroy
 
  enum :status, {
    scheduled: "scheduled",
    in_progress: "in_progress",
    completed: "completed",
    cancelled: "cancelled"
  }
 
  validates :title, presence: true
  validates :scheduled_at, presence: true
  validates :talk_ratio_prospect,
            numericality: { greater_than: 0, less_than_or_equal_to: 100 },
            allow_nil: true
 
  scope :upcoming, -> { where(status: :scheduled).where("scheduled_at > ?", Time.current) }
  scope :completed_this_month, -> { completed.where(scheduled_at: Time.current.beginning_of_month..) }
 
  def spin_breakdown
    discovery_questions.where(was_asked: true).group(:spin_type).count
  end
 
  def total_questions_asked
    discovery_questions.where(was_asked: true).count
  end
 
  def meets_gong_benchmark?
    count = total_questions_asked
    count >= 11 && count <= 14
  end
end
 
# app/models/discovery_question.rb
class DiscoveryQuestion < ApplicationRecord
  belongs_to :discovery_session
 
  enum :spin_type, {
    situation: "situation",
    problem: "problem",
    implication: "implication",
    need_payoff: "need_payoff"
  }
 
  validates :question, presence: true
  validates :spin_type, presence: true
 
  scope :asked, -> { where(was_asked: true) }
  scope :with_responses, -> { where.not(response: nil) }
  scope :needing_follow_up, -> { where.not(follow_up_notes: nil) }
end
 
# app/models/stakeholder.rb
class Stakeholder < ApplicationRecord
  belongs_to :account
 
  enum :role_type, {
    champion: "champion",
    economic_buyer: "economic_buyer",
    technical_evaluator: "technical_evaluator",
    end_user: "end_user"
  }
 
  validates :name, presence: true
  validates :role_type, presence: true
  validates :influence_level, inclusion: { in: 1..10 }
end

# app/services/discovery_analyzer.rb
class DiscoveryAnalyzer
  BENCHMARKS = {
    talk_ratio_prospect: { min: 50.0, max: 65.0, ideal: 57.0 },
    question_count: { min: 11, max: 14, ideal: 12 },
    follow_up_ratio: { min: 0.3, ideal: 0.5 }
  }.freeze
 
  def initialize(session)
    @session = session
  end
 
  def analyze
    {
      talk_ratio: analyze_talk_ratio,
      question_count: analyze_question_count,
      spin_balance: analyze_spin_balance,
      follow_up_quality: analyze_follow_up_quality,
      overall_score: calculate_overall_score
    }
  end
 
  private
 
  def analyze_talk_ratio
    ratio = @session.talk_ratio_prospect
    return { status: :no_data } if ratio.nil?
 
    benchmark = BENCHMARKS[:talk_ratio_prospect]
    status = if ratio.between?(benchmark[:min], benchmark[:max])
               :on_target
             elsif ratio < benchmark[:min]
               :fde_talking_too_much
             else
               :prospect_monologue
             end
 
    { value: ratio, ideal: benchmark[:ideal], status: status }
  end
 
  def analyze_question_count
    count = @session.total_questions_asked
    benchmark = BENCHMARKS[:question_count]
    status = if count.between?(benchmark[:min], benchmark[:max])
               :on_target
             elsif count < benchmark[:min]
               :too_few
             else
               :too_many
             end
 
    { value: count, ideal: benchmark[:ideal], status: status }
  end
 
  def analyze_spin_balance
    breakdown = @session.spin_breakdown
    total = breakdown.values.sum.to_f
    return { status: :no_data } if total.zero?
 
    percentages = breakdown.transform_values { |v| (v / total * 100).round(1) }
 
    {
      percentages: percentages,
      situation_heavy: percentages.fetch("situation", 0) > 30,
      implication_light: percentages.fetch("implication", 0) < 15
    }
  end
 
  def analyze_follow_up_quality
    asked = @session.discovery_questions.asked
    with_follow_up = asked.needing_follow_up.count
    ratio = asked.count.zero? ? 0 : with_follow_up.to_f / asked.count
 
    {
      ratio: ratio.round(2),
      ideal: BENCHMARKS[:follow_up_ratio][:ideal],
      status: ratio >= BENCHMARKS[:follow_up_ratio][:min] ? :good : :needs_improvement
    }
  end
 
  def calculate_overall_score
    scores = []
    scores << (analyze_talk_ratio[:status] == :on_target ? 25 : 10)
    scores << (analyze_question_count[:status] == :on_target ? 25 : 10)
    scores << (analyze_spin_balance[:implication_light] == false ? 25 : 10)
    scores << (analyze_follow_up_quality[:status] == :good ? 25 : 10)
    scores.sum
  end
end

# app/services/discovery_recorder.rb
class DiscoveryRecorder
  def initialize(session)
    @session = session
  end
 
  def record_question(spin_type:, question:, response: nil, follow_up: nil)
    next_position = @session.discovery_questions.maximum(:order_position).to_i + 1
 
    @session.discovery_questions.create!(
      spin_type: spin_type,
      question: question,
      response: response,
      follow_up_notes: follow_up,
      order_position: next_position,
      was_asked: true
    )
  end
 
  def record_stakeholder(account:, name:, title:, role_type:, priorities: nil, concerns: nil, influence: 5)
    Stakeholder.find_or_initialize_by(account: account, name: name).tap do |s|
      s.update!(
        title: title,
        role_type: role_type,
        priorities: priorities,
        concerns: concerns,
        influence_level: influence
      )
    end
  end
 
  def complete_session!(talk_ratio_prospect:, talk_ratio_fde:, summary:)
    @session.update!(
      status: :completed,
      talk_ratio_prospect: talk_ratio_prospect,
      talk_ratio_fde: talk_ratio_fde,
      summary: summary
    )
 
    analysis = DiscoveryAnalyzer.new(@session).analyze
    notify_fde_with_feedback(analysis)
    analysis
  end
 
  private
 
  def notify_fde_with_feedback(analysis)
    return unless analysis[:overall_score] < 70
 
    ActionMailer::Base.mail(
      to: @session.fde.email,
      subject: "Discovery Feedback: #{@session.title}",
      body: format_feedback(analysis)
    ).deliver_later
  end
 
  def format_feedback(analysis)
    feedback = []
    feedback << "トークレシオ: #{analysis[:talk_ratio][:status]}" if analysis[:talk_ratio][:status] != :on_target
    feedback << "質問数: #{analysis[:question_count][:status]}" if analysis[:question_count][:status] != :on_target
    feedback << "Situation質問が多すぎます" if analysis.dig(:spin_balance, :situation_heavy)
    feedback << "Implication質問を増やしましょう" if analysis.dig(:spin_balance, :implication_light)
    feedback.join("\n")
  end
end

# app/services/pre_discovery_data_loader.rb
class PreDiscoveryDataLoader
  def initialize(account)
    @account = account
    @s3_client = Aws::S3::Client.new(region: "ap-northeast-1")
    @athena_client = Aws::Athena::Client.new(region: "ap-northeast-1")
  end
 
  def prepare_dashboard
    upload_public_data_to_s3
    run_athena_analysis
  end
 
  private
 
  def upload_public_data_to_s3
    @s3_client.put_object(
      bucket: "arclight-discovery-data",
      key: "accounts/#{@account.id}/public_data.json",
      body: fetch_public_data.to_json,
      content_type: "application/json"
    )
  end
 
  def run_athena_analysis
    query = <<~SQL
      SELECT
        category,
        COUNT(*) as product_count,
        AVG(recommendation_overlap_ratio) as avg_overlap
      FROM discovery_data
      WHERE account_id = '#{@account.id}'
      GROUP BY category
      ORDER BY product_count DESC
      LIMIT 20
    SQL
 
    @athena_client.start_query_execution(
      query_string: query,
      query_execution_context: { database: "discovery_db" },
      result_configuration: {
        output_location: "s3://arclight-discovery-data/athena-results/"
      }
    )
  end
 
  def fetch_public_data
    { account_id: @account.id, collected_at: Time.current.iso8601, data_points: [] }
  end
end