バトルカードと競合分析 — 技術で勝つ戦略を組み立てる

# 技術評価基準の構造化
class EvaluationCriteria
  CATEGORIES = {
    performance: { label: '推論性能', weight: 25,
      items: %w[リアルタイム推論速度 バッチスループット CPU/GPU両対応 エッジ動作] },
    integration: { label: '統合容易性', weight: 20,
      items: %w[REST_API対応 既存システム連携 オンプレ/クラウド選択 パイプライン構築] },
    reliability: { label: '信頼性', weight: 20,
      items: %w[SLA保証 フェイルオーバー モデル監視 ロールバック] },
    support: { label: '導入支援', weight: 20,
      items: %w[PoC期間 専任技術者 トレーニング ドキュメント] },
    cost: { label: 'コスト', weight: 15,
      items: %w[初期費用 ランニングコスト スケーリング費用 隠れコスト] }
  }.freeze
end

# app/models/competitor.rb
class Competitor < ApplicationRecord
  has_many :battle_cards, dependent: :destroy
  has_many :win_loss_records, dependent: :destroy
 
  validates :name, presence: true, uniqueness: true
  enum :threat_level, { low: 0, medium: 1, high: 2, critical: 3 }
 
  scope :active, -> { where(active: true) }
  scope :by_threat, -> { order(threat_level: :desc) }
 
  def win_rate
    total = win_loss_records.decided.count
    return 0 if total.zero?
 
    (win_loss_records.won.count.to_f / total * 100).round(1)
  end
end
 
# app/models/battle_card.rb
class BattleCard < ApplicationRecord
  belongs_to :competitor
  belongs_to :author, class_name: 'User'
  has_many :sections, class_name: 'BattleCardSection',
           dependent: :destroy
 
  validates :title, presence: true
  validates :version, presence: true
 
  enum :status, { draft: 0, review: 1, approved: 2, archived: 3 }
  scope :current, -> { approved.order(version: :desc).limit(1) }
 
  def complete?
    BattleCardSection::TYPES.all? { |t| sections.exists?(section_type: t) }
  end
end
 
# app/models/battle_card_section.rb
class BattleCardSection < ApplicationRecord
  belongs_to :battle_card
 
  TYPES = %w[
    overview win_lose_reasons feature_comparison
    objection_handling trap_questions quick_dismiss
    pricing_intel attack_defense_tactics
  ].freeze
 
  validates :section_type, presence: true, inclusion: { in: TYPES }
  validates :content, presence: true
end
 
# app/models/win_loss_record.rb
class WinLossRecord < ApplicationRecord
  belongs_to :competitor
  belongs_to :account_executive, class_name: 'User'
  belongs_to :fde, class_name: 'User', optional: true
 
  validates :deal_name, presence: true
  validates :deal_size, numericality: { greater_than: 0 }
 
  enum :outcome, { won: 0, lost: 1, no_decision: 2 }
  enum :loss_reason, {
    price: 0, features: 1, integration: 2,
    relationship: 3, brand: 4, technical: 5
  }, prefix: true
 
  scope :decided, -> { where(outcome: %i[won lost]) }
end

# app/services/win_loss_analyzer.rb
class WinLossAnalyzer
  def initialize(competitor:, period: 12.months)
    @competitor = competitor
    @period = period
  end
 
  def analyze
    records = WinLossRecord.where(competitor: @competitor)
                           .where('closed_at > ?', @period.ago).decided
    return {} if records.empty?
 
    {
      total: records.count,
      win_rate: (records.won.count.to_f / records.count * 100).round(1),
      top_loss_reason: top_reason(records.lost),
      trend: monthly_trend(records),
      recommendation: recommend(records)
    }
  end
 
  private
 
  def top_reason(losses)
    return nil if losses.empty?
 
    losses.group(:loss_reason).count.max_by { |_, v| v }&.first
  end
 
  def monthly_trend(records)
    records.group_by { |r| r.closed_at.beginning_of_month }
           .sort_by(&:first)
           .last(6)
           .map { |m, rs| { month: m.strftime('%Y-%m'), deals: rs.size } }
  end
 
  def recommend(records)
    win_rate = records.won.count.to_f / records.count * 100
    return 'バトルカードの全面見直しが必要' if win_rate < 40
 
    top = top_reason(records.lost)
    top ? "#{top} への対策を強化せよ" : '現状維持'
  end
end

# app/controllers/battle_cards_controller.rb
class BattleCardsController < ApplicationController
  before_action :authenticate_user!
  before_action :set_competitor
 
  def show
    @battle_card = @competitor.battle_cards.current.first!
    @sections = @battle_card.sections.order(:position)
    @analysis = WinLossAnalyzer.new(competitor: @competitor).analyze
  end
 
  def create
    @battle_card = @competitor.battle_cards.build(battle_card_params)
    @battle_card.author = current_user
 
    if @battle_card.save
      redirect_to competitor_battle_card_path(@competitor, @battle_card),
                  notice: 'バトルカードを作成しました'
    else
      render :new, status: :unprocessable_entity
    end
  end
 
  def search
    @results = BattleCard.approved
                         .joins(:sections)
                         .where('battle_card_sections.content LIKE ?', "%#{params[:q]}%")
                         .distinct
  end
 
  private
 
  def set_competitor = Competitor.find(params[:competitor_id])
 
  def battle_card_params
    params.require(:battle_card).permit(:title, :version, :status, :notes)
  end
end

# lib/aws/dynamo_battle_card.rb
require 'aws-sdk-dynamodb'
 
class DynamoBattleCard
  TABLE_NAME = 'battle_cards'
 
  def initialize
    @client = Aws::DynamoDB::Client.new(
      region: ENV.fetch('AWS_REGION', 'ap-northeast-1')
    )
  end
 
  def put_card(competitor_id:, version:, sections:, author:)
    @client.put_item(
      table_name: TABLE_NAME,
      item: {
        'pk' => "COMPETITOR##{competitor_id}",
        'sk' => "CARD##{version}",
        'gsi1pk' => 'CARD',
        'gsi1sk' => "#{competitor_id}##{version}",
        'sections' => sections,
        'author' => author,
        'updated_at' => Time.current.iso8601
      }
    )
  end
 
  def cards_for_competitor(competitor_id)
    @client.query(
      table_name: TABLE_NAME,
      key_condition_expression: 'pk = :pk AND begins_with(sk, :prefix)',
      expression_attribute_values: {
        ':pk' => "COMPETITOR##{competitor_id}",
        ':prefix' => 'CARD#'
      },
      scan_index_forward: false
    ).items
  end
end

# lib/aws/battle_card_stream_handler.rb
require 'aws-sdk-sns'
 
class BattleCardStreamHandler
  def self.process(event:, context:)
    sns = Aws::SNS::Client.new
    topic_arn = ENV.fetch('BATTLE_CARD_TOPIC_ARN')
 
    event['Records'].each do |record|
      next unless record['eventName'] == 'MODIFY'
 
      new_image = record['dynamodb']['NewImage']
      competitor = new_image.dig('pk', 'S')&.delete_prefix('COMPETITOR#')
 
      sns.publish(
        topic_arn: topic_arn,
        subject: "バトルカード更新: #{competitor}",
        message: "#{new_image.dig('author', 'S')} がバトルカードを更新しました。"
      )
    end
  end
end