プロダクトフィードバックループ — 現場の声をロードマップに変える

# db/migrate/20240115_create_feedback_tables.rb
class CreateFeedbackTables < ActiveRecord::Migration[7.1]
  def change
    create_table :feedback_categories do |t|
      t.string :name, null: false
      t.string :slug, null: false
      t.text :description
      t.timestamps
    end
 
    add_index :feedback_categories, :slug, unique: true
 
    create_table :feedbacks do |t|
      t.references :feedback_category, foreign_key: true
      t.references :user, foreign_key: true
      t.string :company_name, null: false
      t.string :plan_tier, null: false
      t.string :title, null: false
      t.text :body, null: false
      t.text :business_context
      t.integer :churn_risk, default: 0
      t.integer :status, default: 0
      t.decimal :rice_score, precision: 8, scale: 2
      t.integer :reach, default: 0
      t.integer :impact, default: 1
      t.decimal :confidence, precision: 3, scale: 2, default: 0.5
      t.integer :effort, default: 1
      t.timestamps
    end
 
    create_table :feedback_votes do |t|
      t.references :feedback, foreign_key: true, null: false
      t.references :user, foreign_key: true, null: false
      t.integer :weight, default: 1
      t.text :comment
      t.timestamps
    end
 
    add_index :feedback_votes, %i[feedback_id user_id], unique: true
  end
end

# app/models/feedback_category.rb
class FeedbackCategory < ApplicationRecord
  has_many :feedbacks, dependent: :restrict_with_error
 
  validates :name, presence: true
  validates :slug, presence: true, uniqueness: true
end
 
# app/models/feedback.rb
class Feedback < ApplicationRecord
  belongs_to :feedback_category
  belongs_to :user
  has_many :feedback_votes, dependent: :destroy
 
  enum :status, {
    submitted: 0,
    under_review: 1,
    planned: 2,
    in_progress: 3,
    shipped: 4,
    declined: 5
  }
 
  enum :churn_risk, {
    none: 0,
    low: 1,
    medium: 2,
    high: 3,
    critical: 4
  }, prefix: :churn
 
  validates :title, presence: true, length: { maximum: 200 }
  validates :body, presence: true
  validates :company_name, presence: true
  validates :plan_tier, presence: true
 
  scope :by_rice_score, -> { order(rice_score: :desc) }
  scope :high_churn_risk, -> { where(churn_risk: %i[high critical]) }
  scope :roadmap_candidates, -> {
    where(status: %i[submitted under_review])
      .where("rice_score >= ?", 10)
      .by_rice_score
  }
 
  def vote_count
    feedback_votes.sum(:weight)
  end
end
 
# app/models/feedback_vote.rb
class FeedbackVote < ApplicationRecord
  belongs_to :feedback, counter_cache: true
  belongs_to :user
 
  validates :weight, inclusion: { in: 1..5 }
  validates :user_id, uniqueness: { scope: :feedback_id }
end

# app/services/feedback_scorer.rb
class FeedbackScorer
  MIN_VOTES_FOR_ROADMAP = 3
  HIGH_RICE_THRESHOLD = 20
 
  def initialize(feedback)
    @feedback = feedback
  end
 
  def calculate_rice_score
    return 0 if @feedback.effort.zero?
 
    score = (reach * impact * confidence) / effort.to_f
    score.round(2)
  end
 
  def update_score!
    new_score = calculate_rice_score
    @feedback.update!(rice_score: new_score)
    auto_promote_if_eligible(new_score)
    new_score
  end
 
  def self.recalculate_all
    Feedback.find_each do |feedback|
      new(feedback).update_score!
    end
  end
 
  private
 
  def reach    = @feedback.reach
  def impact   = @feedback.impact
  def confidence = @feedback.confidence
  def effort   = @feedback.effort
 
  def auto_promote_if_eligible(score)
    return unless @feedback.submitted?
    return unless score >= HIGH_RICE_THRESHOLD
    return unless @feedback.vote_count >= MIN_VOTES_FOR_ROADMAP
 
    @feedback.update!(status: :under_review)
    notify_product_team
  end
 
  def notify_product_team
    FeedbackMailer.roadmap_candidate(@feedback).deliver_later
  end
end

# app/controllers/api/v1/feedbacks_controller.rb
module Api
  module V1
    class FeedbacksController < ApplicationController
      before_action :authenticate_user!
      before_action :set_feedback, only: %i[show update vote]
 
      # GET /api/v1/feedbacks
      def index
        feedbacks = Feedback
          .includes(:feedback_category, :feedback_votes)
          .then { |scope| filter_by_status(scope) }
          .then { |scope| filter_by_category(scope) }
          .by_rice_score
          .page(params[:page])
 
        render json: {
          feedbacks: feedbacks.map { serialize(_1) },
          meta: pagination_meta(feedbacks)
        }
      end
 
      # POST /api/v1/feedbacks
      def create
        feedback = current_user.feedbacks.build(feedback_params)
 
        if feedback.save
          FeedbackScorer.new(feedback).update_score!
          render json: serialize(feedback), status: :created
        else
          render json: { errors: feedback.errors }, status: :unprocessable_entity
        end
      end
 
      # PATCH /api/v1/feedbacks/:id
      def update
        if @feedback.update(feedback_params)
          FeedbackScorer.new(@feedback).update_score!
          render json: serialize(@feedback)
        else
          render json: { errors: @feedback.errors }, status: :unprocessable_entity
        end
      end
 
      # POST /api/v1/feedbacks/:id/vote
      def vote
        existing = @feedback.feedback_votes.find_by(user: current_user)
 
        if existing
          existing.update!(vote_params)
        else
          @feedback.feedback_votes.create!(
            user: current_user,
            **vote_params
          )
        end
 
        FeedbackScorer.new(@feedback).update_score!
        render json: serialize(@feedback.reload)
      end
 
      private
 
      def set_feedback
        @feedback = Feedback.find(params[:id])
      end
 
      def feedback_params
        params.require(:feedback).permit(
          :title, :body, :company_name, :plan_tier,
          :business_context, :churn_risk,
          :feedback_category_id,
          :reach, :impact, :confidence, :effort
        )
      end
 
      def vote_params
        params.permit(:weight, :comment)
      end
 
      def filter_by_status(scope)
        return scope unless params[:status]
 
        scope.where(status: params[:status])
      end
 
      def filter_by_category(scope)
        return scope unless params[:category]
 
        scope.joins(:feedback_category)
             .where(feedback_categories: { slug: params[:category] })
      end
 
      def serialize(feedback)
        {
          id: feedback.id, title: feedback.title, body: feedback.body,
          company_name: feedback.company_name, plan_tier: feedback.plan_tier,
          status: feedback.status, churn_risk: feedback.churn_risk,
          rice_score: feedback.rice_score, vote_count: feedback.vote_count,
          category: feedback.feedback_category&.name,
          created_at: feedback.created_at.iso8601
        }
      end
    end
  end
end

# app/services/feedback_pipeline.rb
class FeedbackPipeline
  SQS_QUEUE_URL = ENV.fetch("FEEDBACK_QUEUE_URL")
 
  def initialize(feedback)
    @feedback = feedback
  end
 
  def enqueue!
    sqs_client.send_message(
      queue_url: SQS_QUEUE_URL,
      message_body: build_message.to_json,
      message_attributes: {
        "feedback_id" => {
          string_value: @feedback.id.to_s,
          data_type: "String"
        },
        "priority" => {
          string_value: priority_level,
          data_type: "String"
        }
      }
    )
  end
 
  private
 
  def sqs_client
    @sqs_client ||= Aws::SQS::Client.new
  end
 
  def build_message
    {
      feedback_id: @feedback.id,
      title: @feedback.title,
      body: @feedback.body,
      company_name: @feedback.company_name,
      plan_tier: @feedback.plan_tier,
      churn_risk: @feedback.churn_risk,
      submitted_at: @feedback.created_at.iso8601
    }
  end
 
  def priority_level
    @feedback.churn_critical? ? "high" : "standard"
  end
end

# lambda/feedback_processor/handler.rb
require "json"
require "aws-sdk-dynamodb"
require "aws-sdk-sns"
 
DYNAMODB = Aws::DynamoDB::Client.new
SNS = Aws::SNS::Client.new
 
TABLE_NAME = ENV.fetch("FEEDBACK_TABLE")
TOPIC_ARN = ENV.fetch("NOTIFICATION_TOPIC_ARN")
HIGH_SCORE_THRESHOLD = 20
 
def handler(event:, context:)
  event["Records"].each do |record|
    process_record(record)
  end
 
  { statusCode: 200, body: "OK" }
rescue StandardError => e
  puts "Error: #{e.message}"
  raise e
end
 
def process_record(record)
  payload = JSON.parse(record["body"])
  feedback_id = payload["feedback_id"]
 
  category = classify_feedback(payload)
  score = calculate_score(payload)
 
  store_result(feedback_id, category, score, payload)
 
  notify_if_high_priority(feedback_id, score, payload)
end
 
def classify_feedback(payload)
  body = payload["body"].downcase
 
  categories = {
    "data_export" => %w[csv export download],
    "integration" => %w[api webhook connect],
    "ui_ux" => %w[dashboard ui design layout],
    "performance" => %w[slow timeout speed]
  }
 
  categories.each do |cat, keywords|
    return cat if keywords.any? { |kw| body.include?(kw) }
  end
 
  "general"
end
 
def calculate_score(payload)
  churn_weight = case payload["churn_risk"]
                 when "critical" then 5
                 when "high"     then 4
                 when "medium"   then 3
                 when "low"      then 2
                 else 1
                 end
 
  plan_weight = case payload["plan_tier"]
                when "enterprise" then 3
                when "business"   then 2
                else 1
                end
 
  (churn_weight * plan_weight).to_f
end
 
def store_result(feedback_id, category, score, payload)
  DYNAMODB.put_item(
    table_name: TABLE_NAME,
    item: {
      "feedback_id" => feedback_id,
      "category" => category,
      "priority_score" => score,
      "company" => payload["company_name"],
      "plan_tier" => payload["plan_tier"],
      "processed_at" => Time.now.iso8601
    }
  )
end
 
def notify_if_high_priority(feedback_id, score, payload)
  return unless score >= HIGH_SCORE_THRESHOLD
 
  SNS.publish(
    topic_arn: TOPIC_ARN,
    subject: "High Priority Feedback ##{feedback_id}",
    message: <<~MSG
      高優先度フィードバックが検出されました。
 
      企業: #{payload["company_name"]}
      プラン: #{payload["plan_tier"]}
      解約リスク: #{payload["churn_risk"]}
      スコア: #{score}
 
      内容: #{payload["title"]}
    MSG
  )
end

# app/controllers/api/v1/feedbacks_controller.rb（create アクションに追加）
def create
  feedback = current_user.feedbacks.build(feedback_params)
 
  if feedback.save
    FeedbackScorer.new(feedback).update_score!
    FeedbackPipeline.new(feedback).enqueue!
    render json: serialize(feedback), status: :created
  else
    render json: { errors: feedback.errors }, status: :unprocessable_entity
  end
end