テクニカルデモの技法 — 「Wow」を設計する

# db/migrate/20260601000001_create_demo_environments.rb
class CreateDemoEnvironments < ActiveRecord::Migration[7.2]
  def change
    create_table :demo_environments do |t|
      t.string :company_name, null: false
      t.string :industry, null: false
      t.string :subdomain, null: false, index: { unique: true }
      t.jsonb :branding, default: {}
      t.jsonb :terminology, default: {}
      t.datetime :expires_at, null: false
      t.string :status, default: "active"
      t.timestamps
    end
 
    create_table :feature_flags do |t|
      t.references :demo_environment, null: false, foreign_key: true
      t.string :key, null: false
      t.boolean :enabled, default: false
      t.string :description
      t.timestamps
    end
    add_index :feature_flags, [:demo_environment_id, :key], unique: true
 
    create_table :demo_scenarios do |t|
      t.references :demo_environment, null: false, foreign_key: true
      t.string :name, null: false
      t.text :description
      t.jsonb :seed_data_config, default: {}
      t.integer :position, default: 0
      t.timestamps
    end
  end
end

# app/models/demo_environment.rb
class DemoEnvironment < ApplicationRecord
  has_many :feature_flags, dependent: :destroy
  has_many :demo_scenarios, dependent: :destroy
 
  validates :company_name, :industry, :subdomain, presence: true
  validates :subdomain, uniqueness: true, format: { with: /\A[a-z0-9-]+\z/ }
 
  scope :active, -> { where(status: "active").where("expires_at > ?", Time.current) }
 
  def feature_enabled?(key)
    feature_flags.find_by(key: key)&.enabled || false
  end
 
  def terminology_for(standard_term)
    terminology.fetch(standard_term, standard_term)
  end
end

# app/models/feature_flag.rb
class FeatureFlag < ApplicationRecord
  belongs_to :demo_environment
 
  validates :key, presence: true,
            uniqueness: { scope: :demo_environment_id }
 
  AVAILABLE_FLAGS = %w[
    ai_analytics
    custom_reports
    sso_integration
    api_access
    bulk_import
    real_time_dashboard
    predictive_alerts
    multi_warehouse
  ].freeze
 
  validates :key, inclusion: { in: AVAILABLE_FLAGS }
end

# app/models/demo_scenario.rb
class DemoScenario < ApplicationRecord
  belongs_to :demo_environment
 
  validates :name, presence: true
end

# app/services/demo_setup_service.rb
class DemoSetupService
  INDUSTRY_TEMPLATES = {
    "logistics" => {
      terminology: {
        "project" => "配送案件", "task" => "配送タスク",
        "user" => "ドライバー", "report" => "配送レポート"
      },
      features: %w[ai_analytics real_time_dashboard predictive_alerts multi_warehouse],
      scenarios: [
        { name: "月次配送分析", description: "30日間のデータからAIが最適ルートを提案",
          seed_config: { records: 5000, days: 30 } },
        { name: "リアルタイム追跡", description: "100台の車両をリアルタイム表示",
          seed_config: { vehicles: 100, active: true } }
      ]
    },
    "finance" => {
      terminology: {
        "project" => "案件", "task" => "審査タスク",
        "user" => "審査担当者", "report" => "コンプライアンスレポート"
      },
      features: %w[ai_analytics custom_reports sso_integration api_access],
      scenarios: [
        { name: "不正検知デモ", description: "取引データからAIが異常パターンを検出",
          seed_config: { transactions: 10_000, anomalies: 50 } }
      ]
    }
  }.freeze
 
  def initialize(company_name:, industry:, subdomain:, expires_in: 14.days)
    @company_name = company_name
    @industry = industry
    @subdomain = subdomain
    @expires_in = expires_in
  end
 
  def call
    ActiveRecord::Base.transaction do
      demo_env = create_environment
      setup_feature_flags(demo_env)
      setup_scenarios(demo_env)
      generate_seed_data(demo_env)
 
      demo_env
    end
  end
 
  private
 
  def create_environment
    template = INDUSTRY_TEMPLATES.fetch(@industry, {})
 
    DemoEnvironment.create!(
      company_name: @company_name,
      industry: @industry,
      subdomain: @subdomain,
      branding: default_branding,
      terminology: template.fetch(:terminology, {}),
      expires_at: @expires_in.from_now
    )
  end
 
  def setup_feature_flags(demo_env)
    template = INDUSTRY_TEMPLATES.fetch(@industry, {})
    enabled_features = template.fetch(:features, [])
 
    FeatureFlag::AVAILABLE_FLAGS.each do |flag_key|
      demo_env.feature_flags.create!(
        key: flag_key,
        enabled: enabled_features.include?(flag_key),
        description: flag_description(flag_key)
      )
    end
  end
 
  def setup_scenarios(demo_env)
    template = INDUSTRY_TEMPLATES.fetch(@industry, {})
 
    template.fetch(:scenarios, []).each_with_index do |scenario, index|
      demo_env.demo_scenarios.create!(
        name: scenario[:name],
        description: scenario[:description],
        seed_data_config: scenario[:seed_config],
        position: index
      )
    end
  end
 
  def generate_seed_data(demo_env)
    demo_env.demo_scenarios.each do |scenario|
      DemoSeedDataJob.perform_later(
        demo_environment_id: demo_env.id,
        scenario_id: scenario.id
      )
    end
  end
 
  def default_branding
    { primary_color: "#1a1a2e", accent_color: "#e94560" }
  end
 
  def flag_description(key)
    { "ai_analytics" => "AI分析", "custom_reports" => "カスタムレポート",
      "sso_integration" => "SSO連携", "api_access" => "API連携",
      "bulk_import" => "一括インポート", "real_time_dashboard" => "リアルタイム表示",
      "predictive_alerts" => "予測アラート", "multi_warehouse" => "複数拠点管理"
    }.fetch(key, key.humanize)
  end
end

# app/controllers/api/v1/feature_flags_controller.rb
module Api
  module V1
    class FeatureFlagsController < ApplicationController
      before_action :set_demo_environment
 
      def index
        flags = @demo_env.feature_flags.order(:key)
        render json: flags.map { |f|
          { key: f.key, enabled: f.enabled, description: f.description }
        }
      end
 
      def update
        flag = @demo_env.feature_flags.find_by!(key: params[:key])
        flag.update!(enabled: params[:enabled])
 
        render json: {
          key: flag.key,
          enabled: flag.enabled,
          message: "Feature '#{flag.key}' #{flag.enabled ? 'enabled' : 'disabled'}"
        }
      end
 
      private
 
      def set_demo_environment
        @demo_env = DemoEnvironment.active.find_by!(
          subdomain: request.subdomain
        )
      end
    end
  end
end

# デモ前日に実行したセットアップ
service = DemoSetupService.new(
  company_name: "ヤマトロジスティクス",
  industry: "logistics",
  subdomain: "yamato-demo",
  expires_in: 7.days
)
demo_env = service.call
 
# フィーチャーフラグの最終確認
demo_env.feature_flags.each do |flag|
  puts "#{flag.key}: #{flag.enabled ? '✓' : '✗'}"
end

# modules/demo_environment/main.tf
resource "aws_ecs_task_definition" "demo_app" {
  family                   = "demo-${var.customer_slug}"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = 512
  memory                   = 1024
 
  container_definitions = jsonencode([{
    name  = "demo-app"
    image = "${var.ecr_repository_url}:${var.app_version}"
    environment = [
      { name = "DEMO_SUBDOMAIN", value = var.customer_slug },
      { name = "DATABASE_SCHEMA", value = "demo_${var.customer_slug}" },
      { name = "RAILS_ENV", value = "demo" }
    ]
    portMappings = [{ containerPort = 3000, protocol = "tcp" }]
  }])
}
 
resource "aws_cloudfront_distribution" "demo" {
  origin {
    domain_name = aws_lb.demo_alb.dns_name
    origin_id   = "demo-${var.customer_slug}"
    custom_origin_config {
      http_port              = 80
      https_port             = 443
      origin_protocol_policy = "https-only"
      origin_ssl_protocols   = ["TLSv1.2"]
    }
  }
 
  enabled = true
  aliases = ["${var.customer_slug}-demo.technova.app"]
 
  default_cache_behavior {
    allowed_methods        = ["GET", "HEAD", "OPTIONS", "PUT", "POST", "PATCH", "DELETE"]
    cached_methods         = ["GET", "HEAD"]
    target_origin_id       = "demo-${var.customer_slug}"
    viewer_protocol_policy = "redirect-to-https"
    forwarded_values {
      query_string = true
      cookies { forward = "all" }
    }
  }
 
  restrictions { geo_restriction { restriction_type = "none" } }
  viewer_certificate {
    acm_certificate_arn = var.acm_certificate_arn
    ssl_support_method  = "sni-only"
  }
}

# app/services/demo_infrastructure_service.rb
class DemoInfrastructureService
  def initialize(demo_environment)
    @demo_env = demo_environment
  end
 
  def provision
    system("terraform", "apply",
           "-var", "customer_slug=#{@demo_env.subdomain}",
           "-var", "app_version=#{ENV.fetch('APP_VERSION', 'latest')}",
           "-auto-approve",
           chdir: Rails.root.join("terraform/modules/demo_environment"))
 
    @demo_env.update!(
      status: "provisioned",
      branding: @demo_env.branding.merge(
        url: "https://#{@demo_env.subdomain}-demo.technova.app"
      )
    )
  end
 
  def teardown
    system("terraform", "destroy",
           "-var", "customer_slug=#{@demo_env.subdomain}",
           "-auto-approve",
           chdir: Rails.root.join("terraform/modules/demo_environment"))
    @demo_env.update!(status: "deprovisioned")
  end
end