来自group_by哈希的自定义散列

Question

我正在尝试从一个表创建一个自定义散列。User有许多transactions。事务有一个member_id，company_id，contributions。我试图创建一个自定义散列，其中包含通过member_id向公司发生的事务(贡献)。

    {
    member_id: {
        company: {
            id: "",
            name: ""
        },
        transactions: [
            {
                particulars: "",
                contribution: {
                    contribution1: "",
                    contribution2: ""
                }
            }
        ]
       }
   }

我可以简单地用

transactions.group(:member_id, :company_id).count 

若要获取计数，但无法列出分组到它们的事务(有任何方法吗？)。因此，我使用group_by(&:member_id)对事务进行分组，并在哈希中循环以根据需要生成哈希。

有谁能回顾一下下面的代码并提出更好的方法来做到这一点呢？

user = User.find_by(id: 123)
return {} unless user

transactions = user.transactions
return {} unless transactions.present?

data = {}
transactions.group_by(&:member_id).each do |key, value|
  transactions = []
  company = {}
  value.each do |record|
    company['id'] = record.company_id
    company['name'] = record.company_name
    particulars = record.particulars
    contribution = {}
    contribution['contribution1'] = record.contribution1
    contribution['contribution2'] = record.contribution2
    details = { "particulars": particulars, "contribution": contribution }
    transactions << details
  end
  data[key] = { "company": company, "transactions": transactions }
end

Answer 1

听起来，您正在尝试按member_id和company_id对事务进行分组，尽管在您发布的代码中，您只是按member_id分组，然后用每个新事务的公司覆盖company。

但是，如果将块传递给group_by，则可以通过对象上的多个简单方法进行分组，例如，可以根据匹配的属性数组进行分组，例如：

transactions.group_by { |transaction| [transaction.member_id, transaction.company_id] }

然后，您仍然需要按您所需的方式遍历和格式化事务，但是您也可以使用map和each_with_object来清理这些事务：

transactions.
  group_by { |transaction| [transaction.member_id, transaction.company_id] }.
  each_with_object({}) do |((member_id, _), transactions), data|
    data[member_id] = {
      # no need to keep rebuilding the company hash, all transactions belong to
      # the same company
      company: { id: transactions.first.company_id,
                 name: transactions.first.company_name },
      transactions: transactions.map do |transaction|
        { 
          particulars: transaction.particulars,
          contribution: { contribution1: transaction.contribution1,
                          contribution2: transaction.contribution2 }
        }
      end
    }
  end

这可以被更多的清理，通过将这些散列的生成转移到演示者，但这只是在此时移动代码，不管您仍然需要遍历所有的事务并将它们表示为散列，所以循环是不可避免的。