部門横断コラボレーション — エンジニアリング、セールス、プロダクトの交差点

# app/services/demo_poc_builder.rb
class DemoPocBuilder
  def initialize(prospect_profile)
    @profile = prospect_profile
    @client = ArclightAi::Client.new
  end
 
  def build_recommendation_demo
    # 先方の業種に近いサンプルデータで推薦エンジンを構築
    sample_data = generate_industry_sample(@profile.industry)
    
    model = @client.train_recommendation_model(
      data: sample_data,
      config: {
        algorithm: "collaborative_filtering",
        features: @profile.priority_features
      }
    )
 
    {
      model_id: model.id,
      sample_predictions: model.predict(sample_data.test_set),
      estimated_ctr_improvement: model.estimated_lift,
      integration_steps: build_integration_guide
    }
  end
 
  private
 
  def generate_industry_sample(industry)
    # 業種に応じたリアルなサンプルデータを生成
    ArclightAi::SampleGenerator.create(
      industry: industry,
      record_count: 10_000,
      features: %w[user_history item_attributes context]
    )
  end
 
  def build_integration_guide
    # 先方のスタックに合わせた導入ガイドを自動生成
    ArclightAi::IntegrationGuide.generate(
      stack: @profile.tech_stack,
      deployment: @profile.deployment_type
    )
  end
end

# FDE が提出するバグレポートの構造化テンプレート
class FdeBugReport
  TEMPLATE = {
    customer_context: {
      company: "A社（エンタープライズ、ARR ¥24M）",
      plan: "Enterprise",
      usage_pattern: "日次バッチで10万件処理"
    },
    reproduction: {
      environment: "本番環境（us-east-1）",
      steps: [
        "売上分析タブを開く",
        "日付範囲を180日に設定",
        "集計ボタンをクリック"
      ],
      expected: "3秒以内に結果表示",
      actual: "8秒後にタイムアウトエラー"
    },
    business_impact: {
      affected_customers: 4,
      churn_risk: "中（更新3ヶ月前）",
      revenue_at_risk: "¥72M（4社合計ARR）"
    },
    technical_analysis: {
      root_cause_hypothesis: "N+1クエリ（売上テーブルのJOIN）",
      suggested_fix: "日次集計テーブルの導入",
      estimated_effort: "2-3日"
    }
  }.freeze
end

# app/models/cross_team_request.rb
class CrossTeamRequest < ApplicationRecord
  belongs_to :requester, class_name: "User"
  belongs_to :assigned_team, class_name: "Team", optional: true
  has_many :team_handoffs, dependent: :destroy
  has_many :stakeholder_updates, dependent: :destroy
 
  enum :status, {
    open: 0,
    triaged: 1,
    in_progress: 2,
    blocked: 3,
    resolved: 4
  }
 
  enum :priority, {
    low: 0,
    medium: 1,
    high: 2,
    critical: 3
  }
 
  enum :category, {
    feature_request: 0,
    bug_report: 1,
    poc_request: 2,
    rfp_response: 3,
    onboarding: 4,
    escalation: 5
  }
 
  validates :title, presence: true
  validates :business_impact, presence: true
  validates :affected_arr, numericality: { greater_than_or_equal_to: 0 }
 
  scope :actionable, -> { where(status: %i[open triaged in_progress]) }
  scope :high_impact, -> { where(priority: %i[high critical]) }
end
 
# app/models/team_handoff.rb
class TeamHandoff < ApplicationRecord
  belongs_to :cross_team_request
  belongs_to :from_team, class_name: "Team"
  belongs_to :to_team, class_name: "Team"
  belongs_to :handed_off_by, class_name: "User"
 
  validates :reason, presence: true
  validates :context_summary, presence: true
 
  after_create :notify_receiving_team
 
  private
 
  def notify_receiving_team
    CrossTeamNotifier.handoff_received(self).deliver_later
  end
end
 
# app/models/stakeholder_update.rb
class StakeholderUpdate < ApplicationRecord
  belongs_to :cross_team_request
  belongs_to :author, class_name: "User"
 
  enum :audience, {
    internal: 0,
    customer_facing: 1,
    executive: 2
  }
 
  validates :content, presence: true
 
  scope :latest_first, -> { order(created_at: :desc) }
end

# app/services/request_router.rb
class RequestRouter
  ROUTING_RULES = {
    feature_request: :product,
    bug_report: :engineering,
    poc_request: :fde,
    rfp_response: :fde,
    onboarding: :customer_success,
    escalation: :determine_by_context
  }.freeze
 
  def initialize(request)
    @request = request
  end
 
  def route!
    team_key = ROUTING_RULES[@request.category.to_sym]
 
    if team_key == :determine_by_context
      team_key = analyze_escalation_context
    end
 
    target_team = Team.find_by!(slug: team_key)
    assign_and_notify(target_team)
  end
 
  private
 
  def analyze_escalation_context
    if @request.affected_arr >= 10_000_000
      :engineering # 高ARR顧客はエンジニアリング直結
    elsif @request.business_impact.include?("churn")
      :customer_success
    else
      :fde # デフォルトはFDEがトリアージ
    end
  end
 
  def assign_and_notify(team)
    @request.update!(
      assigned_team: team,
      status: :triaged
    )
 
    CrossTeamNotifier.new_assignment(@request, team).deliver_later
 
    create_handoff_record(team) if @request.team_handoffs.any?
  end
 
  def create_handoff_record(team)
    previous_team = @request.assigned_team_was || Team.find_by!(slug: :fde)
 
    @request.team_handoffs.create!(
      from_team: previous_team,
      to_team: team,
      handed_off_by: Current.user,
      reason: "ルーティングルールによる自動振り分け",
      context_summary: build_context_summary
    )
  end
 
  def build_context_summary
    <<~SUMMARY
      リクエスト: #{@request.title}
      カテゴリ: #{@request.category}
      影響ARR: ¥#{@request.affected_arr.to_fs(:delimited)}
      顧客コンテキスト: #{@request.business_impact}
    SUMMARY
  end
end

# app/controllers/cross_team_dashboard_controller.rb
class CrossTeamDashboardController < ApplicationController
  before_action :authorize_fde_access!
 
  def index
    @stats = {
      open_requests: CrossTeamRequest.actionable.count,
      critical_items: CrossTeamRequest.high_impact.actionable.count,
      avg_resolution_hours: average_resolution_time,
      requests_by_category: requests_by_category
    }
    @recent_requests = CrossTeamRequest
      .actionable
      .includes(:requester, :assigned_team)
      .order(priority: :desc, created_at: :asc)
      .limit(20)
  end
 
  def team_view
    @team = Team.find_by!(slug: params[:team_slug])
    @requests = CrossTeamRequest
      .where(assigned_team: @team)
      .actionable
      .includes(:stakeholder_updates)
      .order(priority: :desc)
  end
 
  def create_update
    @request = CrossTeamRequest.find(params[:request_id])
    @update = @request.stakeholder_updates.build(
      update_params.merge(author: Current.user)
    )
 
    if @update.save
      broadcast_update(@update)
      redirect_to cross_team_dashboard_path,
                  notice: "更新を投稿しました"
    else
      render :index, status: :unprocessable_entity
    end
  end
 
  private
 
  def average_resolution_time
    resolved = CrossTeamRequest.where(status: :resolved)
      .where("resolved_at > ?", 30.days.ago)
    return 0 if resolved.empty?
 
    total_hours = resolved.sum do |r|
      (r.resolved_at - r.created_at) / 1.hour
    end
    (total_hours / resolved.count).round(1)
  end
 
  def requests_by_category
    CrossTeamRequest.actionable
      .group(:category)
      .count
      .transform_keys(&:titleize)
  end
 
  def broadcast_update(update)
    ActionCable.server.broadcast(
      "cross_team_#{update.cross_team_request_id}",
      { type: "new_update", content: update.content }
    )
  end
 
  def update_params
    params.require(:stakeholder_update)
      .permit(:content, :audience)
  end
 
  def authorize_fde_access!
    unless Current.user.fde? || Current.user.admin?
      redirect_to root_path, alert: "アクセス権限がありません"
    end
  end
end

# app/services/event_bridge_publisher.rb
class EventBridgePublisher
  def initialize
    @client = Aws::EventBridge::Client.new(
      region: ENV.fetch("AWS_REGION", "ap-northeast-1")
    )
  end
 
  def publish_cross_team_event(request, event_type)
    @client.put_events(
      entries: [
        {
          source: "technova.cross-team-hub",
          detail_type: event_type,
          detail: build_event_detail(request).to_json,
          event_bus_name: "cross-team-events"
        }
      ]
    )
  end
 
  private
 
  def build_event_detail(request)
    {
      request_id: request.id,
      title: request.title,
      category: request.category,
      priority: request.priority,
      affected_arr: request.affected_arr,
      assigned_team: request.assigned_team&.slug,
      requester: request.requester.name,
      business_impact: request.business_impact,
      timestamp: Time.current.iso8601
    }
  end
end
 
# app/services/event_bridge_rule_setup.rb
class EventBridgeRuleSetup
  def initialize
    @client = Aws::EventBridge::Client.new(
      region: ENV.fetch("AWS_REGION", "ap-northeast-1")
    )
  end
 
  def setup_routing_rules!
    create_critical_escalation_rule
  end
 
  private
 
  def create_critical_escalation_rule
    @client.put_rule(
      name: "critical-cross-team-escalation",
      event_bus_name: "cross-team-events",
      event_pattern: {
        source: ["technova.cross-team-hub"],
        "detail-type": ["request.created", "request.escalated"],
        detail: {
          priority: ["critical"],
          affected_arr: [{ numeric: [">=", 10_000_000] }]
        }
      }.to_json,
      state: "ENABLED",
      description: "高ARR顧客の重大リクエストを即時通知"
    )
 
    @client.put_targets(
      rule: "critical-cross-team-escalation",
      event_bus_name: "cross-team-events",
      targets: [
        {
          id: "slack-alert",
          arn: ENV.fetch("SLACK_ALERT_LAMBDA_ARN"),
          input_transformer: {
            input_paths_map: {
              "title" => "$.detail.title",
              "arr" => "$.detail.affected_arr",
              "team" => "$.detail.assigned_team"
            },
            input_template: '"重大リクエスト: <title> (ARR: ¥<arr>) → <team>"'
          }
        }
      ]
    )
  end
end