通过关系检索所有变形

Question

一个Order有很多订购的物品

一个Order的点项目可以是一个User或Product

我正在寻找的是一种将所有变形对象检索到的方法Order。相反的$order->users或$order->products我想这样做$order->items。

我的进度

到目前为止，我的进步涉及到多对多态关系。

我的桌子：

orders
    id - integer

orderables (the order items)
    order_id - integer
    orderable_id - integer
    orderable_type - string

    quantity - integer
    price - double

-----------

users
    id - integer
    name - string

products
    id - integer
    name - string

---

orderables表格外观示例

这是我创建订单并添加用户和产品的方式：

/**
 * Order
 * @var Order
 */

    $order = new App\Order;
    $order->save();

/**
 * Add user to order
 * @var [type]
 */

    $user = \App\User::find(1);

    $order->users()->sync([
        $user->id => [
            'quantity' => 1,
            'price' => $user->price()
        ]
    ]);

/**
 * Add product to order
 * @var [type]
 */

    $product = \App\product::find(1);

    $order->products()->sync([
        $product->id => [
            'quantity' => 1,
            'price' => $product->price()
        ]
    ]);

Order.php

/**
 * Ordered users
 * @return [type] [description]
 */

    public function users() {
        return $this->morphedByMany('Athliit\User', 'orderable');
    }

/**
 * Ordered products
 */

    public function products() {
        return $this->morphedByMany('Athliit\Product', 'orderable');
    }

目前我可以做

foreach($order->users as $user) {
    echo $user->id;
}

要么..

foreach($order->products as $product) {
    echo $product->id;
}

但是我希望能够按照以下方式做点事情...

foreach($order->items as $item) {
    // $item is either User or Product class
}

我已经找到了这个问题，它是我能找到的最接近的问题，但是我无法根据自己的需要来解决这个问题，它已经过时了，而且似乎也很棘手。

有不同的方法吗？

如果您使用的方法不同于多态关系，请告诉我。

Answer 1

就我个人而言，我的Order模型有许多OrderItems，并且OrderItems具有多态关系。这样，无论它们是什么类型的模型，我都可以获取订单的所有项目：

class Order extends Model
{
    public function items()
    {
        return $this->hasMany(OrderItem::class);
    }

    public function addItem(Orderable $item, $quantity)
    {
        if (!is_int($quantity)) {
            throw new InvalidArgumentException('Quantity must be an integer');
        }

        $item = OrderItem::createFromOrderable($item);
        $item->quantity = $quantity;

        $this->items()->save($item);
    }
}

class OrderItem extends Model
{
    public static function createFromOrderable(Orderable $item)
    {
        $this->orderable()->associate($item);
    }

    public function order()
    {
        return $this->belongsTo(Order::class);
    }

    public function orderable()
    {
        return $this->morphTo('orderable');
    }
}

然后，我将创建一个接口和特征，将它们应用于Eloquent模型，使它们“可排序”：

interface Orderable
{
    public function getPrice();
}

trait Orderable
{
    public function orderable()
    {
        return $this->morphMany(OrderItem::class, 'orderable');
    }
}

use App\Contracts\Orderable as OrderableContract; // interface
use App\Orderable; // trait

class Product extends Model implements OrderableContract
{
    use Orderable;
}

class EventTicket extends Model implements OrderableContract
{
    use Orderable;
}

正如你所看到的，我的OrderItem实例可以是一个Product，EventTicket或任何其他模式，实现了Orderable接口。然后，您可以像这样获取订单的所有项目：

$orderItem = Order::find($orderId)->items;

OrderItem实例变形为哪种类型都没有关系。

编辑：向您的订单添加项目：

// Create an order instance
$order = new Order;

// Add an item to the order
$order->addItem(User::find($userId), $quantity);