データモデリング - 要求分析駆動設計

# 取引サブジェクト
module DealSubject
  module BuyerActor
    # 取引履歴閲覧のユースケース
    class BrowseDealHistoryUseCase
      attr_accessor :actor
      def initialize(actor)
        self.actor = actor
      end

      # 配送状況確認
      # 配送状況に関する情報を集約して返す
      def track_delivery_state(deal_id)
        # Deal#to_bought_items_featureを呼び出している
        deal = actor.deals.find(deal_id).to_bought_items_feature
        { deal: deal.raw, estimated_arrival_date: deal.estimated_arrival_date }
      end
    end
  end
end

class User < ApplicationRecord
  # ActiveRecordのインスタンスを論理データモデルにマッピングするメソッド
  # to_マッピング先のfeature名にする
  # マッピング先のfeature内に対応するクラスが複数ある場合も考えられる
  # メソッド名を適宜考えて分けるか、STIのようにデータに応じてインスタンス化するクラスを振り分ける方法がある
  # 引数のないメソッドしか例示していないが、引数を受け取ってはならないという制限はない
  def to_bought_items_feature
    BoughtItemsFeature::Seller.new(self)
  end

  has_many :deals
end

class Item < ApplicationRecord
  # 複数のActiveRecordのインスタンスを1つの論理データモデルクラスにまとめることもできる
  def to_bought_items_feature
    BoughtItemsFeature::Item.new(self, raw_seller: user)
  end

  belongs_to :user
end

class Deal < ApplicationRecord
  # DDDでいうところのAggregateは再起的にマッパーを呼び出すことで実現させる
  def to_bought_items_feature
    BoughtItemsFeature::Deal.new(self,
                                 item: item.to_bought_items_feature,
                                 buyer: user.to_bought_items_feature)
  end

  belongs_to :item
  belongs_to :user
end

module BoughtItemsFeature
  class Deal
    # ActiveRecordのインスタンスを保持する変数はrawをつけて区別する
    attr_accessor :raw, :item, :buyer

    # ActiveRecordのインスタンスは直接使わずにdelegateでカラムの値を参照する
    delegate :created_at, to: :raw
    # データソースが変わってrawの実体がActiveRecordのインスタンスからHashに変わったとしても、
    # def created_at
    #   raw[:created_at]
    # end
    # というメソッドを定義するだけで済む
    # 上記の理由から、後述する永続化の場合を除いて
    # 独自に定義したメソッドも含めActiveRecordのメソッドは呼び出してはならない

    def initialize(raw, item:, buyer:)
      self.raw = raw
      self.item = item
      self.buyer = buyer
    end

    # 到着予定日 Rangeを返す
    # DeliveryTimeCalcRuleにまとめてしまっても良いメソッド
    def estimated_arrival_date
      value_object = deal_date_value_object        # 取引確定日
      value_object += delivery_time_calc_rule.calc #  + 都道府県間の輸送日数
      value_object += item.shipment_time           #  + 商品の出荷時期
      value_object.to_range                        #  = XX/XX/XXからYY/YY/YYの間
    end

    private

    # 到着予定日の計算基点日
    # DateRangeValueObjectは日付期間計算のために独自に用意するValueObject
    # ((Date.today)..(Date.tomorrow)) + 1.day
    # ((Date.today)..(Date.tomorrow)) + (1.day..3.day)
    # のような計算が可能になるように実装されている
    # 後述のデータディクショナリの計算可能なValueObjectで実装例を記載しているので、そちらを参照
    def deal_date_value_object
      @deal_date_value_object ||= DateRangeValueObject.new(created_at)
    end

    # 配達日数に関するビジネスルール
    # 配達元都道府県から配達先都道府県までの輸送日数を計算する
    def delivery_time_calc_rule
      @delivery_time_calc_rule ||= DeliveryTimeCalcRule.new(
        from_prefecture: item.prefecture,
        to_prefecture: buyer.prefecture
      )
    end
  end
end

module BoughtItemsFeature
  class Item
    attr_accessor :raw, :raw_seller
    # 複数のActiveRecordのインスタンスを持つ場合は、カラム名が衝突する可能性があるので、
    # prefix: trueをつける
    delegate :prefecture, :shipment_time_from, :shipment_time_to, to: :raw, prefix: true
    delegate :prefecture, to: :raw_seller, prefix: true

    def initialize(raw, raw_seller:)
      self.raw = raw
      self.raw_seller = raw_seller
    end

    # 商品のある都道府県。商品に都道府県がなけれればSellerの都道府県とみなす
    def prefecture
      raw_prefecture.presence || raw_seller_prefecture
    end

    def shipment_time
      (raw_shipment_time_from.days)..(raw_shipment_time_to.days)
    end
  end
end

# 取引サブジェクト
module DealSubject
  module BuyerActor
    # 取引成立後のやりとりのユースケース
    class ConversationUseCase
      attr_accessor :actor
      def initialize(actor)
        self.actor = actor
      end

      # Sellerにメッセージを送信する
      # paramsはPOSTされたデータをpermitしたもの
      def send_message(params)
        result = false
        deal = actor.deals.find_by(params[:deal_id])
        return { result: false, error_type: :deal_is_not_found } if deal.blank?

        message = Message.new(params.merge(user_id: actor.id)).to_bought_items_message_feature
        ApplicationRecord.transaction do
          return { result: result, data: message.raw } unless message.valid?

          message.save!
          # メール通知を行うならここでActionMailerを呼び出す
          result = true
        end

        { result: result, data: message.raw }
      rescue StandardError
        { result: false, data: message.raw }
      end
    end
  end
end

class Message < ApplicationRecord
  def to_bought_items_message_feature
    BoughtItemsFeature::MessageFeature::MutableMessage.new(self, raw_deal: deal)
  end

  belongs_to :deal
  belongs_to :user # 送信者
end

module BoughtItemsFeature
  module MessageFeature
    # Mutableという名前のつくEntityは永続化のための役割を担う
    # 永続化の処理（バリデーションなど）と参照系の処理はお互いに交わることがほとんどないため、
    # 参照用のEntityと永続化用のEntityを分ける方針をとる
    class MutableMessage
      # ActiveRecord（Rails）のインスタンスであるrawは
      # attr_accessorしか持たないPOROないしActiveModel::Modelをincludeしたクラスとみなす
      # rawは保存対象データのコンテナであり、Entityの内部処理でrawのデータを変更したいケースは、
      # delegate :status=, to: :raw
      # のように代入メソッドをdelegateする
      attr_accessor :raw, :raw_deal

      def initialize(raw, raw_deal)
        self.raw = raw
        self.raw_deal = raw_deal
      end

      # ActiveRecordのバリデーション以外に実行したいバリデーションがあればここに記述する
      # 例えばメッセージを下書き保存できる機能が必要な場合、
      # ActiveRecordのMessageには最大公約数的なバリデーションを定義、
      # BoughtItemsFeature::MessageFeature::MutableMessageと
      # BoughtItemsFeature::MessageFeature::MutableDraftMessageを作成し、
      # 各々の機能に適したバリデーションをvalid?メソッドに記述することができる
      #
      # raw.valid?、raw.errorsはActiveRecordのメソッドである
      # こうすることで、Viewではいつも通りの形でバリデーションエラー表示を実装できる
      def valid?
        raw.valid?
        raw.errors.add(:base, 'メッセージを送れません') unless sending_rule.sendable?

        # raw.valid?にするとerrorsがリセットされて'メッセージを送れません'が消えてしまう
        raw.errors.present?
      end

      # 「1ヶ月以上前の取引にメッセージは送れない」といったビジネスルールを実装しているとする
      # ビジネスルールがActiveRecordのインスタンスを利用することの是非は後述する
      def sending_rule
        @sending_rule ||= SendingRule.new(raw_deal)
      end
    end
  end
end

# relation = ActiveRecordRelation.new(blog.entries)
# のような形でRailsのActiveRecord_Relationのインスタンスを渡す
# relation.deleted_list.map(&:destroy)
# relation.active_list.map(&:save)
# のように増減を反映させる
# Entityのコンストラクタでインスタンス化し、
# Entity内でdeleteメソッドや<<メソッドを呼ぶ。
# UseCase内で
# deleted_list.map(&:destroy)
# などをする
class ActiveRecordRelation
  attr_accessor :deleted_list, :active_list, :relation

  def initialize(relation)
    self.relation = relation
    self.deleted_list = []
    self.active_list = relation.to_a
  end

  def delete(target)
    target = target.id if target.is_a?(ApplicationRecord)
    target = target.id if target.is_a?(ActiveModel::Model)
    target = active_list.find { |x| x.id == target }
    return nil if target.blank?

    self.active_list = active_list - [target]
    deleted_list << target

    target
  end

  def <<(target_hash)
    relation.build(target_hash).tap do |built|
      active_list << built
    end
  end

  def update(target_hash, find_key = :id)
    target = active_list.find { |x| x.send(find_key) == target_hash[find_key] }
    return nil if target.blank?

    target.attributes = target_hash
    target
  end

  def update_or_build(target_hash, find_key = :id)
    result = update(target_hash, find_key)
    return result if result.present?

    self << target_hash
  end
end