Ruby on rails Rails-使用顺序对模型进行排序

我有一个问题模型，我从（@rejected）中选择了一些项目。然后，我想为每个项目计算一个：approval_rating属性，并根据该属性对集合进行排序。我正试图通过以下方式做到这一点：

def index
  ...
  @rejected = @questions.where("ques_num=? AND rejected=?", params[:ques_num], true) 
    if @rejected   
      @rejected = @rejected.map do |q|
        upvotes = q.get_upvotes.size
        downvotes = q.get_downvotes.size
        total_votes = Float(upvotes + downvotes)
        q.approval_rating = (upvotes/total_votes*100).round(2)
        q.save
      end
      @rejected = @rejected.order('approval_rating DESC')
    end
  end

尝试排序时出现错误：未定义[true，true，true]：数组的“order”方法

我也试过这个

@rejected = @rejected.sort_by(&:approval_ratings)

并得到错误：true:TrueClass的未定义方法“approval\u rating”

---

我在这里做错了什么？

您的代码创建了一个

数组

，其值为

true

（见下文）

将始终返回一个

ActiveRecord:：Relation

，因此：

if @rejected

将始终返回真值

您可能想考虑使用<代码>每个< /代码>，而不是<代码> MAP>代码>。但是，我相信这仍然会返回一个

数组。所以您仍然无法执行
@rejected.order（'approval\u rating DESC'）

我认为你应该能够做到：

def index
  ...
  @rejected = @questions.
                where("ques_num=? AND rejected=?", params[:ques_num], true).
                each do |q|
                  upvotes     = q.get_upvotes.size
                  downvotes   = q.get_downvotes.size
                  total_votes = Float(upvotes + downvotes)
                  q.approval_rating.update(
                    approval_rating: (upvotes/total_votes*100).round(2)
                  )
                end.
                sort_by(&:approval_rating)
end

我不能100%确定您的排序顺序是否正确，因此您可能需要检查一下

就个人而言，在我看来，您最好将
认可度
逻辑放在
问题
模型中。也许是这样的：

class Question < ApplicationRecord

  def update_approval_rating
    upvotes     = get_upvotes.size
    downvotes   = get_downvote.size
    total_votes = Float(upvotes+downvotes)
    update(
      approval_rating: (upvotes/total_votes*100).round(2)
    )
  end

end

class Question < ApplicationRecord
  class << self 

    def for_question_number(ques_num)
      where(ques_num: ques_num)
    end 

    def rejected
      where(rejected: true)
    end

    def best_first
      order(approval_rating: :desc)
    end

  end
end

<> P> >我想，你可能会考虑在每次代码< >问题>代码时设置<代码>批准>等级>代码>（在你的<代码> QuestionsController < /代码>中）。这样，您就不必在
索引
操作中处理设置
批准率
。此外，
索引
应该是幂等的，所以在那里修改记录似乎很难闻（IMO）

然后，你可以得到更像：

def index
  ...
  @rejected = @questions.
                where("ques_num=? AND rejected=?", params[:ques_num], true).
                order(approval_rating: :desc)
end

啊。。。好多了

您甚至可以在
问题
模型中添加一些类方法，例如：

class Question < ApplicationRecord

  def update_approval_rating
    upvotes     = get_upvotes.size
    downvotes   = get_downvote.size
    total_votes = Float(upvotes+downvotes)
    update(
      approval_rating: (upvotes/total_votes*100).round(2)
    )
  end

end

class Question < ApplicationRecord
  class << self 

    def for_question_number(ques_num)
      where(ques_num: ques_num)
    end 

    def rejected
      where(rejected: true)
    end

    def best_first
      order(approval_rating: :desc)
    end

  end
end

如果将来您决定在某个时候以其他方式确定什么是“最好的”，那么您可以首先对
问题
模型中的
最佳方法进行更改，并且您的
索引
操作是不明智的

现在这里开始感觉像彩虹和棒棒糖了。
您的代码创建了一个
数组
的值
true
（见下文）

将始终返回一个
ActiveRecord:：Relation
，因此：

if @rejected

将始终返回真值

您可能想考虑使用<代码>每个< /代码>，而不是<代码> MAP>代码>。但是，我相信这仍然会返回一个
数组。所以您仍然无法执行
@rejected.order（'approval\u rating DESC'）

我认为你应该能够做到：

def index
  ...
  @rejected = @questions.
                where("ques_num=? AND rejected=?", params[:ques_num], true).
                each do |q|
                  upvotes     = q.get_upvotes.size
                  downvotes   = q.get_downvotes.size
                  total_votes = Float(upvotes + downvotes)
                  q.approval_rating.update(
                    approval_rating: (upvotes/total_votes*100).round(2)
                  )
                end.
                sort_by(&:approval_rating)
end

我不能100%确定您的排序顺序是否正确，因此您可能需要检查一下

就个人而言，在我看来，您最好将
认可度
逻辑放在
问题
模型中。也许是这样的：

class Question < ApplicationRecord

  def update_approval_rating
    upvotes     = get_upvotes.size
    downvotes   = get_downvote.size
    total_votes = Float(upvotes+downvotes)
    update(
      approval_rating: (upvotes/total_votes*100).round(2)
    )
  end

end

class Question < ApplicationRecord
  class << self 

    def for_question_number(ques_num)
      where(ques_num: ques_num)
    end 

    def rejected
      where(rejected: true)
    end

    def best_first
      order(approval_rating: :desc)
    end

  end
end

<> P> >我想，你可能会考虑在每次代码< >问题>代码时设置<代码>批准>等级>代码>（在你的<代码> QuestionsController < /代码>中）。这样，您就不必在
索引
操作中处理设置
批准率
。此外，
索引
应该是幂等的，所以在那里修改记录似乎很难闻（IMO）

然后，你可以得到更像：

def index
  ...
  @rejected = @questions.
                where("ques_num=? AND rejected=?", params[:ques_num], true).
                order(approval_rating: :desc)
end

啊。。。好多了

您甚至可以在
问题
模型中添加一些类方法，例如：

class Question < ApplicationRecord

  def update_approval_rating
    upvotes     = get_upvotes.size
    downvotes   = get_downvote.size
    total_votes = Float(upvotes+downvotes)
    update(
      approval_rating: (upvotes/total_votes*100).round(2)
    )
  end

end

class Question < ApplicationRecord
  class << self 

    def for_question_number(ques_num)
      where(ques_num: ques_num)
    end 

    def rejected
      where(rejected: true)
    end

    def best_first
      order(approval_rating: :desc)
    end

  end
end

如果将来您决定在某个时候以其他方式确定什么是“最好的”，那么您可以首先对
问题
模型中的
最佳方法进行更改，并且您的
索引
操作是不明智的

现在这里开始感觉像彩虹和棒棒糖。
您使用的是返回数组的
map
。如果要应用AR查询方法，如
order
，则需要提供
ActiveRecord:：Relation
类。这里最简单的解决方案是：执行另一个查询，根据修改后的字段对关系进行排序，或者使用ruby使用
sort\u by
对
@rejected
进行排序

def index
  ...
  @rejected = @questions.where("ques_num=? AND rejected=?", params[:ques_num], true) 
  if @rejected.present?   
     @rejected.each do |q|
        upvotes = q.get_upvotes.size
        downvotes = q.get_downvotes.size
        total_votes = Float(upvotes + downvotes)
        q.approval_rating = (upvotes/total_votes*100).round(2)
        q.save
      end
      @rejected = @questions.where("ques_num=? AND rejected=?", params[:ques_num], true).order('approval_rating DESC')
    end
  end
end

注意：您的
@rejected
始终==true（空关系[]视为true）。使用
@拒绝。是否存在？

也许最好将迭代器中的代码写入SQL/AR语句，您使用的是返回数组的
map
。如果要应用AR查询方法，如
order
，则需要提供
ActiveRecord:：Relation
类。这里最简单的解决方案是：执行另一个查询，根据修改后的字段对关系进行排序，或者使用ruby使用
sort\u by
对
@rejected
进行排序

def index
  ...
  @rejected = @questions.where("ques_num=? AND rejected=?", params[:ques_num], true) 
  if @rejected.present?   
     @rejected.each do |q|
        upvotes = q.get_upvotes.size
        downvotes = q.get_downvotes.size
        total_votes = Float(upvotes + downvotes)
        q.approval_rating = (upvotes/total_votes*100).round(2)
        q.save
      end
      @rejected = @questions.where("ques_num=? AND rejected=?", params[:ques_num], true).order('approval_rating DESC')
    end
  end
end

注意：您的
@rejected
始终==true（空关系[]视为true）。使用
@拒绝。是否存在？

也许最好将迭代器中的代码写入SQL/AR语句
由
@rejected.each do | q |返回的对象的类是什么。。。结束
？你说得对，它是数组。OP必须在编辑每个问题后使用相同的参数执行另一个查询。或者对
数组进行排序，如下所示。出于好奇，如果@rejected.present？
？
true
关系中存在某种内容（如果
@rejected
不为空），则
的值是多少
@rejected.each do | q |返回的对象的类是什么。。。结束
？你说得对，它是数组。OP必须在编辑每个问题后使用相同的参数执行另一个查询。或者对
数组进行排序，如下所示。出于好奇，如果@rejected.present？
？
true
关系中存在某种内容（如果
@rejected
不为空），则
的值是多少