我有一个名为 Product 的模型，它具有以下自引用多对多关系:

// parent products based on the product_product pivot table
public function parent_products()
{
    return $this->belongsToMany('App\Product', 'product_product', 'child_id', 'parent_id')->withPivot('amount');
}

// child products based on the product_product pivot table
public function child_products()
{
    return $this->belongsToMany('App\Product', 'product_product', 'parent_id', 'child_id')->withPivot('amount');
}

// movements
public function movements()
{
    return $this->hasMany('App\Movement', 'product_id');
}

因此任何产品都可以“理想地”拥有无限的祖先和 child 。

此外，任何产品都是其他产品的组合，因为它们就像“组件”。

所以我需要根据每个 child 的可用性以及他们构建产品所需的数量来返回“可生产”产品的数量。

如果这是一层深度的东西没问题，但系统应该让你有多个深度层次，所以任何 child 也可以由 child 组成。

我无法控制每个产品->产品->产品链的深度。

除了性能问题，我需要一种递归方法来返回链接中每个产品的“可生产”数量。

我设法像这样递归地获取 child 直到链的末尾

public function child_products_recursive()
{
  return $this->child_products()->with(['child_products_recursive','movements'=>function($query){
    $query->whereDate('ready_date', '<=', date('Y-m-d'))->sum('amount');
  }]);
}

而且有效。

但无法弄清楚如何从中返回值或如何导航每个模型。

涉及的表是这样“简化”的:

products
---------
id | name
---------
1  | something
2  | something
3  | something
4  | something
5  | something
6  | something
7  | something


product_product
-----------------------------
parent_id | child_id | amount (amount of children in the parent product)
-----------------------------
1         | 2        | 2
1         | 3        | 4
2         | 4        | 1.5
2         | 5        | 3
4         | 6        | 0.7
4         | 7        | 0.3


movements table
-------------------------------------
id | product_id | date       | amount
-------------------------------------
1  | 4          | 2016-01-06 | 300
2  | 5          | 2016-01-06 | 200
3  | 6          | 2016-01-06 | 125
4  | 7          | 2016-01-06 | 1000

所以产品 ID 1 没有 Action ，但可以基于没有 Action 但也可以由子产品构建的子产品构建成许多件。

这是可视化表示(我之前没有按照表格的数据，只是给出想法):

            Wine box        Wine box
            6 bottles       12 bottles ---1x-- Box for
            of Wine3        of Wine4           12 Bottles
               /  \             |   \          
              /    \            |    \
            x6      x1          |     x12
            /        \          |      \
         Bottle      Box for    |     Bottle
         of Wine3    6 Bottles  |     Label
         /  |  \                |        
        /   |   \              / \    
       /    |    \            /   \
      /     |     \          /     \
    x1    x0.75    x1      x12      x9
    /       |       \      /         \
Empty       |        Bottle         Wine4
Bottle XY   |        Cork ABC
            |        
            |        
            |
            |
          Wine3
         /    \
        /      \
     x0.7      x0.3
      /          \
   Wine1        Wine2

提前致谢。 再见

最佳答案

我不知道我是否理解了这个想法，但为了测试产品是否可生产，我建议如下:

public function getIsProducibleAttribute()
{
    if($this->movements > 0)
        return true;
    else{
        foreach($this->child_products_recursive as $child)
        {
            if(!$child->is_producible)
                return false;

            if($child->movements < $child->pivot->amount)
                return false;
        }

        return true;
    }

}

如果产品有移动那么它已经存在了，否则检查 child ，如果isProducible检查数量，如果任何失败 child 返回false;

让我再试一次:

public function getProducibleQuantityAttribute()
{
    $quantity = 0;
    foreach($this->child_products_recursive as $child)
    {
        //The production expected of that child with its stock and producible take in account.
        $child_producible = ($child->movements + 
                             $child->producible_quantity)
                            / $child->pivot->amount;

        //The first value
        if($quantity == 0)
            $quantity = $child_producible;
        //Takes the lowest
        else if($child_producible < $quantity) 
            $quantity = $child_producible;
    }

    return $quantity ;
    }
}

因此，我检查子代的库存和可生产数量，然后除以父代制作一个单元所需的数量。取最小值，例如:

我有 24 瓶，但只有一盒 12 瓶，所以答案是 1。

PS.: 不要忘记四舍五入;)

关于php - Laravel 5 递归函数多对多自引用模型，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37709185/