returns array of order statuses
@return array
327945
public function getOrderStatus()
    {
        $statuses = $this->getDoctrine()->getRepository(self::$orderStatusEntityName)->findAll();
        $locale = $this->getUser()->getLocale();
        $statusArray = [];

        foreach ($statuses as $statusEntity) {
            $status = new OrderStatus($statusEntity, $locale);
            $statusArray[] = array(
                'id' => $status->getId(),
                'status' => $status->getStatus()
            );
        }
        return $statusArray;
    }
579049
public static function getOpenStatusCodes()
    {
        return array(
            self::STATUS_NEW,
            self::STATUS_ACCEPTED_BY_SELLER,
            self::STATUS_REJECTED_BY_SELLER,
            self::STATUS_IN_PICK_AT_SELLER,
            self::STATUS_READY_FOR_DISPATCH_TO_HUB,
            self::STATUS_IN_TRANSIT_TO_HUB,
            self::STATUS_READY_FOR_PICKUP_FROM_HUB,
            self::STATUS_AT_HUB,
        );
    }
542018
public static function getStatusList()
    {
        // @todo: check for a complete list of available CloudFront statuses
        return [
            self::STATUS_OK => 'Completed',
            self::STATUS_TO_SEND => 'STATUS_TO_SEND',
            self::STATUS_TO_FLUSH => 'STATUS_TO_FLUSH',
            self::STATUS_ERROR => 'STATUS_ERROR',
            self::STATUS_WAITING => 'InProgress',
        ];
    }
973166
public static function getStatusList()
    {
        return [
            TransactionInterface::STATUS_ORDER_UNKNOWN => 'order_unknown',
            TransactionInterface::STATUS_OPEN => 'open',
            TransactionInterface::STATUS_PENDING => 'pending',
            TransactionInterface::STATUS_VALIDATED => 'validated',
            TransactionInterface::STATUS_CANCELLED => 'cancelled',
            TransactionInterface::STATUS_UNKNOWN => 'status_unknown',
            TransactionInterface::STATUS_ERROR_VALIDATION => 'error_validation',
            TransactionInterface::STATUS_WRONG_CALLBACK => 'wrong_callback',
            TransactionInterface::STATUS_WRONG_REQUEST => 'wrong_request',
            TransactionInterface::STATUS_ORDER_NOT_OPEN => 'order_to_open',
        ];
    }
296953
public function getStatus() : array
    {
        return [
            'status'        => [
                'entries-stored' => \count($this->store),
                'accessed'       => $this->readCount,
                'removed'        => $this->removeCount,
                'written'        => $this->writeCount,
            ],
        ];
    }
1358507
public function order()
    {
        $options = array(
            'order' => 'desc',
            'sort' => 'created',
            'limit' => array(0, $this->config->get('dashboard_limit', 10)));

        $items = $this->order->getList($options);

        array_walk($items, function (&$item) {
            $this->setItemTotalFormatted($item, $this->price);
            $this->setItemOrderNew($item, $this->order_history);
        });

        return $items;
    }
476735
public static function getStatusList()
    {
        return [
            self::STATUS_OPEN => 'status_open',
            self::STATUS_PENDING => 'status_pending',
            self::STATUS_VALIDATED => 'status_validated',
            self::STATUS_CANCELLED => 'status_cancelled',
            self::STATUS_ERROR => 'status_error',
            self::STATUS_STOPPED => 'status_stopped',
        ];
    }
1101967
function fetchOrderStatus()
    {
        $statusList = eZOrderStatus::fetchMap( true, true );
        if ( isset( $statusList[$this->StatusID] ) )
        {
            return $statusList[$this->StatusID];
        }
        return false;
    }
465987
public function getOrderList()
    {
        if ($this->_aOrderList === null) {
            $this->_aOrderList = [];

            // Load user Orderlist
            if ($oUser = $this->getUser()) {
                $iNrofCatArticles = (int) \OxidEsales\Eshop\Core\Registry::getConfig()->getConfigParam('iNrofCatArticles');
                $iNrofCatArticles = $iNrofCatArticles ? $iNrofCatArticles : 1;
                $this->_iAllArtCnt = $oUser->getOrderCount();
                if ($this->_iAllArtCnt && $this->_iAllArtCnt > 0) {
                    $this->_aOrderList = $oUser->getOrders($iNrofCatArticles, $this->getActPage());
                    $this->_iCntPages = ceil($this->_iAllArtCnt / $iNrofCatArticles);
                }
            }
        }

        return $this->_aOrderList;
    }
927679
public function getSorting()
    {
        $sortOrder = $this->getRequest()->get('sortOrder', 'asc');
        $sortBy = $this->getRequest()->get('sortBy', 'id');

        return [$sortBy => $sortOrder];
    }
163285
public static function get_backup_status_array() {
        global $DB;

        $result = array(
            self::BACKUP_STATUS_ERROR => 0,
            self::BACKUP_STATUS_OK => 0,
            self::BACKUP_STATUS_UNFINISHED => 0,
            self::BACKUP_STATUS_SKIPPED => 0,
            self::BACKUP_STATUS_WARNING => 0,
            self::BACKUP_STATUS_NOTYETRUN => 0
        );

        $statuses = $DB->get_records_sql('SELECT DISTINCT bc.laststatus, COUNT(bc.courseid) AS statuscount FROM {backup_courses} bc GROUP BY bc.laststatus');

        foreach ($statuses as $status) {
            if (empty($status->statuscount)) {
                $status->statuscount = 0;
            }
            $result[(int)$status->laststatus] += $status->statuscount;
        }

        return $result;
    }
1214007
public function getBarStateInfo() {
		$result = [];
		$fields = [
			'count(*) AS amount',
			$this->alias . '.status'
		];
		$group = $this->alias . '.status';
		$order = [$this->alias . '.status' => 'asc'];
		$this->recursive = -1;
		$data = $this->find('all', compact('fields', 'group', 'order'));
		if (empty($data)) {
			return $result;
		}

		$taskStateList = $this->getListTaskState();
		$taskClassList = $this->getListBarStateClass();
		foreach ($data as $dataItem) {
			$stateId = $dataItem[$this->alias]['status'];
			$stateName = Hash::get($taskStateList, $stateId);
			$class = Hash::get($taskClassList, $stateId);
			$amount = (int)Hash::get($dataItem, '0.amount');
			$stateUrl = ['controller' => 'queues', 'action' => 'index', 'plugin' => 'cake_settings_app',
				'?' => ['data[FilterData][0][' . $this->alias . '][status]' => $stateId]];
			$result[] = compact('stateName', 'stateId', 'amount', 'stateUrl', 'class');
		}

		return $result;
	}
699381
public function getStatus()
    {
        $statuses = array(
            self::STATUS_CART                       => 'Cart',
            self::STATUS_NEW                        => 'New',
            self::STATUS_CANCELED_BY_BUYER          => 'Canceled by Buyer',
            self::STATUS_ACCEPTED_BY_SELLER         => 'Accepted by Seller',
            self::STATUS_REJECTED_BY_SELLER         => 'Rejected by Seller',
            self::STATUS_IN_PICK_AT_SELLER          => 'In pick at Seller',
            self::STATUS_READY_FOR_DISPATCH_TO_HUB  => 'Ready to be dispatched to Hub',
            self::STATUS_IN_TRANSIT_TO_HUB          => 'In transit to Hub',
            self::STATUS_AT_HUB                     => 'At Hub',
            self::STATUS_READY_FOR_PICKUP_FROM_HUB  => 'Ready to be picked up from Hub',
            self::STATUS_PICKED_UP_FROM_HUB         => 'Picked up by Buyer',
        );

        if (array_key_exists($this->getStatusCode(), $statuses))
        {
            return $statuses[$this->getStatusCode()];
        }

        return 'Unknown';
    }
782725
protected function updateOrderStatus()
    {
        $data = array('status' => $this->getModuleSetting('order_status_success'));
        $this->order->update($this->data_order['order_id'], $data);
        $this->data_order = $this->order->get($this->data_order['order_id']);
    }
381524
public function getStatus(){

        // set response to json
        $this->setEndpoint('json');

        // get response
        $obj = json_decode( $this->get(), true);

        return array_get($obj, 'status', null);

    }
962091
public function statusCodes(): array
    {
        return array_map(
                function($status)
                {
                    return new Status($status->getCode(), $status->getDescription());
                },
                $this->annotations->named('Status')
        );
    }
991737
public static function get_request_statuses() {
        return [
            api::DATAREQUEST_STATUS_PENDING => get_string('statuspending', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_AWAITING_APPROVAL => get_string('statusawaitingapproval', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_APPROVED => get_string('statusapproved', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_PROCESSING => get_string('statusprocessing', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_COMPLETE => get_string('statuscomplete', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_DOWNLOAD_READY => get_string('statusready', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_EXPIRED => get_string('statusexpired', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_CANCELLED => get_string('statuscancelled', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_REJECTED => get_string('statusrejected', 'tool_dataprivacy'),
            api::DATAREQUEST_STATUS_DELETED => get_string('statusdeleted', 'tool_dataprivacy'),
        ];
    }