Question

User和Organization通过many-to-many建立Relationship关联。 Relationship模型包含几个关于关系的布尔变量，例如moderator（true / false）和member（true / false）。另外，我添加了一个名为default的布尔值来设置默认组织。

我要求验证如果（且仅当）用户是一个或多个组织（member == true）的成员，其中一个（并且恰好是1个）组织必须default == true。

所以基本上这意味着如果用户是多个组织的成员，那么其中一个组织需要成为默认组织，如果用户是多个组织的成员，则必须存在默认组织。

如何编写此验证？我目前的验证在播种时会产生以下错误：

PG::SyntaxError: ERROR:  syntax error at or near "default"
LINE 1: ...ERE (user_id = 1) AND (member = 't' and default = ...
                                                   ^
: SELECT COUNT(*) FROM "relationships" WHERE (user_id = 1) AND (member = 't' and default = 't')

我在Relationship模型中的实现：

validate :default
private
def default
  @relationships = Relationship.where('user_id = ?', self.user_id)
  @members = @relationships.where('member = ?', true)
  @defaults = @members.where('default = ?', true)
  # If more than 1 organization has been set as default for user
  if @defaults.count > 1
    @defaults.drop(0).each do |invalid|
      invalid.update_columns(default: false)
    end
  end
  # If user is member but has no default organization yet
  if !@defaults.any? && @members.any?
    @members.first.update_columns(default: true)
  end
end

更新关于它的外观，我知道我不应该这样建模，而是应该使用has_one belongs_to关系@DavidAldridge在他的建议回答。但我不明白如何建立这种关系（请参阅我在答案下面的评论）。非常感谢任何建议。

Answer 1

@Brad Werth是正确的，你的validate方法可以更好地作为回调。

我建议您在关系模型中使用以下内容：

before_save :set_default

private

  def set_default
    self.default = true unless self.user.relationships.where(member: true, default: true).any?
  end

如果用户的其他关系都不存在，则应强制将用户的关系设置为默认值。

Answer 2

这种困难的原因是您的数据模型不正确。用户的默认组织的标识是用户的属性，而不是关系的属性，因为每个用户只能有一个默认值。如果您有一个主要，二级，三级组织，那么这将是该关系的一个属性。

而不是放置＆＃34;关系是默认的用户＆＃34;关系的属性，放置＆＃34; default_relationship_id＆＃34;用户的属性所以...

belongs_to :default_relationship

......和......

has_one :default_organisation, :through => :default_relationship

这可以保证：

只有一个组织可以成为用户的默认组织
用户与其默认组织之间必须存在关系

您还可以使用：dependent =＆gt; ：对default_relationship的反向关联进行nullify，并根据是否根据以下内容轻松测试单个关系是否为默认值：

self == user.default_relationship.

类似于：

class User << ActiveRecord::Base
    has_many   :relationships, :inverse_of => :user, :dependent => :destroy
    has_many   :organisations, :through    => :relationships, :dependent => :destroy
    belongs_to :default_relationship, :class_name => "Relationship", :foreign_key => :default_relationship_id, :inverse_of => :default_for_user
    has_one    :default_organisation, :through => :default_relationship, :source => :organisation


class Relationship  << ActiveRecord::Base
    belongs_to :user        , :inverse_of => :relationships
    belongs_to :organisation, :inverse_of => :relationships
    has_one    :default_for_user, :class_name => "User", :foreign_key => :default_relationship_id, :inverse_of => :default_relationship, :dependent => :nullify

class Organisation << ActiveRecord::Base
    has_many   :relationships, :inverse_of => :organisation, :dependent => :destroy
    has_many   :users        , :through    => :relationships
    has_many   :default_for_users, :through => :relationships, :source => :default_for_user

因此，你可以做如下这样简单的事情：

@user = User.find(34)
@user.default_organisation

默认组织也很容易加载（不是说它不可能，但不需要范围）。

Answer 3

将default更改为is_default（正如其他用户在评论中指出的那样，default是postgres关键字）。为此创建单独的迁移。（或者你可以在任何地方引用它，如果你愿意让它保持原样。）

然后，有两点。

首先，为什么每次都需要检查单个is_default组织？您只需迁移当前数据集，然后保持一致。

要迁移当前数据集，请创建迁移并在此处编写如下内容：

def self.up
  invalid_defaults = Relationship.
    where(member: true, is_default: true).
    group(:user_id).
    having("COUNT(*) > 1")

  invalid_defaults.each do |relationship|
    this_user_relationships = relationship.user.relationships.where(member: true, is_default: true)
    this_user_relationships.where.not(id: this_user_relationships.first.id).update_all(is_default: false)
  end
end

请确保在非高峰时段运行此迁移，因为可能需要相当长的时间才能完成。或者，您可以从服务器控制台本身运行该代码片段（当然，事先只在开发环境中测试）。

然后，使用回调（由另一位评论者正确建议）在记录更新时设置默认组织

before_save :set_default

private

def set_default
  relationships = Relationship.where(user_id: self.user_id)
  members = relationships.where(member: true)
  defaults = members.where(is_default: true)

  # No need to migrate records in-place

  # Change #any? to #exists?, to check existance via SQL, without actually fetching all the records
  if !defaults.exists? && members.exists?
    # Choosing the earliest record
    members.first.update_columns(is_default: true)
  end
end

要考虑编辑组织的情况，还应添加对组织的回调：

class Organization
  before_save :unset_default
  after_commit :set_default

  private

  # Just quque is_default for update...
  def remember_and_unset_default
    if self.is_default_changed? && self.is_default
      @default_was_set = true
      self.is_default = false
    end
  end

  # And now update it in a multi-thread safe way: let the database handle multiple queries being sent at once,
  # and let only one of them to actually complete, keeping base in always consistent state
  def set_default
    if @default_was_set
      self.class.
        # update this record...
        where(id: self.id).
        # but only if there is still ZERO default organizations for this user
        # (thread-safety will be handled by database)
        where(
          "id IN (SELECT id FROM organizations WHERE member = ?, is_default = ?, user_id = ? GROUP BY user_id HAVING COUNT(*)=0)",
          true, true, self.user_id
        )
    end
  end

如何模拟这个`has_one``instry_to`关系？

3 个答案: