Rails 5.1如何使用nested_attributes_for更新连接表属性？

Hey there! Let’s walk through how to use accepts_nested_attributes_for to manage your Ownership join table updates when syncing user game data. I’ll tailor this to your existing setup with User, Game, and Ownership models:

1. Update Your Model Associations & Enable Nested Attributes #

First, make sure your User model explicitly accepts nested attributes for the Ownership join table, and double-check your associations (especially if your Ownership table has extra attributes like purchase dates or platforms):

# app/models/user.rb
class User < ApplicationRecord
  has_many :ownerships, dependent: :destroy
  has_many :games, through: :ownerships

  # Enable nested attributes for ownerships; use allow_destroy if you need to remove associations later
  accepts_nested_attributes_for :ownerships, allow_destroy: true

  # Your existing method to update game count
  def update_game_count
    self.game_count = games.count
    save
  end
end

# app/models/ownership.rb
class Ownership < ApplicationRecord
  belongs_to :user
  belongs_to :game

  # Add any custom attributes your join table has here
  # attribute :purchase_date, :date
  # attribute :platform, :string
end

# app/models/game.rb
class Game < ApplicationRecord
  has_many :ownerships, dependent: :destroy
  has_many :users, through: :ownerships
end

2. Use Nested Attributes in Your Sync Service #

When you fetch game data from the remote API, structure the response into ownerships_attributes to pass directly to the User’s update method. This will create or update the join table records alongside your user data:

# app/services/user_game_sync_service.rb
class UserGameSyncService
  def initialize(user)
    @user = user
  end

  def sync
    # Fetch your remote game data (adjust this to match your API's response structure)
    remote_game_data = fetch_remote_owned_games

    # Build nested attributes for ownerships
    ownerships_attributes = remote_game_data.map do |remote_entry|
      # First, find or create the Game record using the remote ID/data
      game = Game.find_or_create_by(external_id: remote_entry[:game_id]) do |g|
        g.name = remote_entry[:game_name]
        # Populate other game attributes from the remote API as needed
      end

      # Build the ownership attributes: link to the game, include any join table fields
      { game_id: game.id, platform: remote_entry[:platform], purchase_date: remote_entry[:purchase_date] }
    end

    # Update the user with the nested ownership data
    @user.update(ownerships_attributes: ownerships_attributes)

    # Refresh the user's game count (or use callbacks to automate this, see below)
    @user.update_game_count
  end

  private

  def fetch_remote_owned_games
    # Your existing code to call the remote API and return game data
  end
end

3. Prevent Duplicate Ownership Records #

To avoid creating duplicate User-Game associations, add a unique database constraint (critical for data integrity) and adjust your service to update existing ownerships instead of creating new ones:

Add a Unique Constraint

Run a migration to enforce one ownership per user-game pair:

# db/migrate/[timestamp]_add_unique_index_to_ownerships.rb
class AddUniqueIndexToOwnerships < ActiveRecord::Migration[7.0]
  def change
    add_index :ownerships, [:user_id, :game_id], unique: true
  end
end

Update Existing Ownerships in the Service

Modify your attribute mapping to check for existing ownerships and update their attributes if needed:

ownerships_attributes = remote_game_data.map do |remote_entry|
  game = Game.find_or_create_by(external_id: remote_entry[:game_id])
  existing_ownership = @user.ownerships.find_by(game_id: game.id)

  if existing_ownership
    # Update existing ownership attributes (include the ID so Rails knows to update instead of create)
    { id: existing_ownership.id, platform: remote_entry[:platform], purchase_date: remote_entry[:purchase_date] }
  else
    # Create a new ownership
    { game_id: game.id, platform: remote_entry[:platform], purchase_date: remote_entry[:purchase_date] }
  end
end

4. Bonus: Automate Game Count Updates #

Instead of manually calling update_game_count after syncing, use callbacks on the Ownership model to keep the count in sync automatically:

# app/models/ownership.rb
class Ownership < ApplicationRecord
  belongs_to :user
  belongs_to :game

  after_save :refresh_user_game_count
  after_destroy :refresh_user_game_count

  private

  def refresh_user_game_count
    user.update_game_count
  end
end

This way, any time an ownership is created, updated, or deleted, the user’s game_count will automatically update without extra service code.

内容的提问来源于stack exchange，提问作者Matej M