Return the inventory bought items view.

@return \Illuminate\View\View
423847
public function getBought()
    {
        $items = Item::join('seller')
            ->leftJoin('purchases')
            ->where('purchases.user_id', Auth::user()->userId);

        if (mustard_loaded('auctions')) {
            $items->leftJoin('winningBid')
                ->orWhere('bids.user_id', Auth::user()->userId);
        }

        $table = new InventoryBought($items);

        return view('mustard::inventory.bought', [
            'table' => $table,
            'items' => $table->paginate(),
        ]);
    }
1257940
public function getTrashed()
    {
        if (!$this->modelAdmin->hasSoftDeleting()) {
            return $this->missingMethod();
        }

        return view('flare::admin.modeladmin.trashed', [
                                                        'modelItems' => $this->modelAdmin->onlyTrashedItems(),
                                                        'totals' => $this->modelAdmin->totals(),
                                                    ]
                                                );
    }
131620
public function getOrderedItems()
    {
        if (config('menus.ordering') || $this->ordering) {
            return $this->toCollection()->sortBy(function ($item) {
                return $item->order;
            })->all();
        }

        return $this->items;
    }
368156
protected function _getShopViews()
    {
        if (empty($this->_aShopViews)) {
            $this->_aShopViews = [];
            $aAllViews = $this->_getAllViews();

            foreach ($aAllViews as $sView) {
                if ($this->_isCurrentShopView($sView)) {
                    $this->_aShopViews[] = $sView;
                }
            }
        }

        return $this->_aShopViews;
    }
653724
public function getOrderedProducts(): Collection
    {
        return $this->products->matching(Criteria::create()->orderBy(['order' => Criteria::ASC]));
    }
805529
public function index()
    {
        $orderStateGrid = new OrderStatusDataGrid($this->repository->query());

        return view('avored-framework::product.order-status.index')->with('dataGrid', $orderStateGrid->dataGrid);
    }
980765
public function getOrderItems()
    {
        if (\Yii::$app->user->isGuest) {
            $session = \Yii::$app->session;
            $products = $session[self::SESSION_KEY];
        } else {
            $order = Order::find()->where(['user_id' => \Yii::$app->user->id, 'status' => OrderStatus::STATUS_INCOMPLETE])->one();
            if (!empty($order))
                $products = OrderProduct::find()->asArray()->where(['order_id' => $order->id])->all();
        }
        return $products ?? false;
    }
1342173
public function index()
    {
        $propertyGrid = new Property(Model::query()->orderBy('id', 'desc'));

        return view('avored-ecommerce::property.index')->with('dataGrid', $propertyGrid->dataGrid);
    }
70647
public function getItems()
    {
        foreach ($this->_items as $name => $item) {
            $this->getItem($name);
        }

        return $this->_items;
    }
804310
public function getRiverItem() {

		if (isset($this->_river_item)) {
			return $this->_river_item;
		}

		$id = $this->river_id;

		$items = elgg_get_river(array(
			'ids' => $id,
			'limit' => 1,
		));

		$this->_river_item = (is_array($items) && count($items)) ? $items[0] : false;
		return $this->_river_item;
	}
308930
public function getVendor()
    {
        if ($this->_oVendor === null) {
            $this->_oVendor = $this->getProduct()->getVendor(false);
        }

        return $this->_oVendor;
    }
709715
public function &GetOwningBundleOrderItem()
    {
        $oOwningOrderItem = $this->GetFromInternalCache('oOwningOrderItem');
        if (is_null($oOwningOrderItem)) {
            $oOwningOrderItem = false;
            if (!is_null($this->id)) {
                $query = "SELECT `shop_order_item`.*
                      FROM `shop_order_item`
                INNER JOIN `shop_order_bundle_article` ON `shop_order_item`.`id` = `shop_order_bundle_article`.`shop_order_item_id`
                     WHERE `shop_order_bundle_article`.`bundle_article_id` = '".MySqlLegacySupport::getInstance()->real_escape_string($this->id)."'
                   ";
                if ($aOwner = MySqlLegacySupport::getInstance()->fetch_assoc(MySqlLegacySupport::getInstance()->query($query))) {
                    $oOwningOrderItem = TdbShopOrderItem::GetNewInstance();
                    /** @var $oOwningOrderItem TdbShopOrderItem */
                    $oOwningOrderItem->LoadFromRow($aOwner);
                }
            }
            $this->SetInternalCache('oOwningOrderItem', $oOwningOrderItem);
        }

        return $oOwningOrderItem;
    }
851248
public function getLoadedProductCollection()
    {
        $params = $this->getRequest()->getParams();
        //check for param code and id
        if (! isset($params['order_id']) ||
            ! isset($params['code']) ||
            ! $this->helper->isCodeValid($params['code'])
        ) {
            $this->helper->log('Product recommendation for this order not found or invalid code');
            return [];
        }

        //products to be displayed for recommended pages
        $orderId = (int) $this->getRequest()->getParam('order_id');
        //display mode based on the action name
        $mode = $this->getRequest()->getActionName();
        $orderModel = $this->orderFactory->create();
        $this->orderResource->load($orderModel, $orderId);
        //number of product items to be displayed
        $limit = $this->recommendedHelper
            ->getDisplayLimitByMode($mode);
        $orderItems = $orderModel->getAllItems();
        $numItems = count($orderItems);

        //no product found to display
        if ($numItems == 0 || !$limit) {
            return [];
        } elseif ($numItems > $limit) {
            $maxPerChild = 1;
        } else {
            $maxPerChild = number_format($limit / $numItems);
        }

        $this->helper->log(
            'DYNAMIC PRODUCTS : limit ' . $limit . ' products : '
            . $numItems . ', max per child : ' . $maxPerChild
        );

        $productsToDisplayCounter = 0;
        $productsToDisplay = $this->recommendedHelper->getProductsToDisplay(
            $orderItems,
            $mode,
            $productsToDisplayCounter,
            $limit,
            $maxPerChild
        );

        //check for more space to fill up the table with fallback products
        if ($productsToDisplayCounter < $limit) {
            $productsToDisplay = $this->recommendedHelper->fillProductsToDisplay(
                $productsToDisplay,
                $productsToDisplayCounter,
                $limit
            );
        }

        $this->helper->log('loaded product to display ' . count($productsToDisplay));

        return $productsToDisplay;
    }
843262
public function getItems()
    {
        $manager = Yii::$app->getAuthManager();
        $avaliable = [];
        foreach (array_keys($manager->getRoles()) as $name) {
            $avaliable[$name] = 'role';
        }

        foreach (array_keys($manager->getPermissions()) as $name) {
            if ($name[0] != '/') {
                $avaliable[$name] = 'permission';
            }
        }

        $assigned = [];
        foreach ($manager->getAssignments($this->id) as $item) {
            $assigned[$item->roleName] = $avaliable[$item->roleName];
            unset($avaliable[$item->roleName]);
        }

        return [
            'avaliable' => $avaliable,
            'assigned' => $assigned
        ];
    }
509055
public function getProduct()
    {
        if (($sActProduct = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter('anid'))) {
            $oParentView = $this->getParent();
            if (($oProduct = $oParentView->getViewProduct())) {
                return $oProduct;
            } else {
                $oProduct = oxNew(\OxidEsales\Eshop\Application\Model\Article::class);
                if ($oProduct->load($sActProduct)) {
                    // storing for reuse
                    $oParentView->setViewProduct($oProduct);

                    return $oProduct;
                }
            }
        }
    }
834133
public static function getItems()
    {
        if (self::$items === null) {
            $items = (new Query())
            ->select(['cms_nav.id', 'nav_item_id' => 'cms_nav_item.id', 'nav_container_id', 'parent_nav_id', 'is_hidden', 'layout_file', 'is_offline', 'is_draft', 'is_home', 'cms_nav_item.title', 'publish_from', 'publish_till'])
            ->from('cms_nav')
            ->leftJoin('cms_nav_item', 'cms_nav.id=cms_nav_item.nav_id')
            ->orderBy(['sort_index' => SORT_ASC])
            ->where(['cms_nav_item.lang_id' => Lang::getDefault()['id'], 'cms_nav.is_deleted' => false, 'cms_nav.is_draft' => false])
            ->all();
            
            self::loadInheritanceData(0);
            
            $data = [];
            
            foreach ($items as $key => $item) {
                $item['is_editable'] = (int) Yii::$app->adminuser->canRoute('cmsadmin/page/update');
                $item['toggle_open'] = (int) Yii::$app->adminuser->identity->setting->get('tree.'.$item['id']);
                
                // the user have "page edit" permission, now we can check if the this group has more fined tuned permisionss from the
                // cms_nav_permissions table or not
                if ($item['is_editable']) {
                    $permitted = false;
                    
                    foreach (Yii::$app->adminuser->identity->groups as $group) {
                        if ($permitted) {
                            continue;
                        }
                        
                        $permitted = self::navGroupPermission($item['id'], $group->id);
                    }

                    if (!$permitted) {
                        $value = (isset(self::$_inheritData[$item['id']])) ? self::$_inheritData[$item['id']] : false;
                        if ($value === true) {
                            $permitted = true;
                        }
                    }
                    
                    $item['is_editable'] = $permitted;
                }
            
                $data[$key] = $item;
            }
            
            self::$items = $data;
        }
        
        return self::$items;
    }
1190055
public function index()
    {
        $orderReturnGrid = new OrderReturnRequestDataGrid($this->repository->all());

        return view('avored-framework::order.return-request.index')
                    ->withDataGrid($orderReturnGrid->dataGrid);
    }