Gets statuses that are currently in the scheduler table

@return array
430902
public function getStatuses()
    {
        $schedules = clone $this->getCollection()
            ->setOrder('status', Zend_Db_Select::SQL_ASC);
        $schedules->getSelect()
            ->group('status')
            ->reset(Zend_Db_Select::COLUMNS)
            ->columns('status');
        $statuses = $schedules->getConnection()
            ->fetchCol($schedules->getSelect());
        $statusArray = array();
        foreach ($statuses as $status) {
            $statusArray[$status] = $status;
        }
        return $statusArray;
    }
185284
public static function get_all_scheduled_tasks() {
        global $DB;

        $records = $DB->get_records('task_scheduled', null, 'component, classname', '*', IGNORE_MISSING);
        $tasks = array();

        foreach ($records as $record) {
            $task = self::scheduled_task_from_record($record);
            // Safety check in case the task in the DB does not match a real class (maybe something was uninstalled).
            if ($task) {
                $tasks[] = $task;
            }
        }

        return $tasks;
    }
891839
public function getStatusAllowableValues()
    {
        return [
            self::STATUS_DRAFT,
            self::STATUS_SENT,
            self::STATUS_ARCHIVE,
            self::STATUS_QUEUED,
            self::STATUS_SUSPENDED,
            self::STATUS_IN_PROCESS,
        ];
    }
198411
public function getStatusesHuman()
    {
        return [
            self::STATUS_PENDING          => 'Pending',
            self::STATUS_PROCESSING       => 'Processing',
            self::STATUS_COMPLETE         => 'Complete',
            self::STATUS_FAILED           => 'Failed',
            self::STATUS_REFUNDED         => 'Refunded',
            self::STATUS_REFUNDED_PARTIAL => 'Partially Refunded',
        ];
    }
1013291
static public function getStatuses()
    {
        return [
            self::STATUS_NEW => \Yii::t('skeeks/reviews2', "New"),
            self::STATUS_PROCESSED => \Yii::t('skeeks/reviews2', "In Progress"),
            self::STATUS_ALLOWED => \Yii::t('skeeks/reviews2', "Approved"),
            self::STATUS_CANCELED => \Yii::t('skeeks/reviews2', "Rejected"),
        ];
    }
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';
    }
98824
protected function getUpdateableStatuses()
    {
        return $this->hasOption(self::OPTION_UPDATEABLE_STATUSES)
            ? $this->getOption(self::OPTION_UPDATEABLE_STATUSES)
            : [
                DeliveryExecution::STATE_ACTIVE,
                DeliveryExecution::STATE_PAUSED,
            ];
    }
925147
public function getStatus()
    {
        $reports = [];
        $solrConnections = GeneralUtility::makeInstance(ConnectionManager::class)->getAllConnections();

        foreach ($solrConnections as $solrConnection) {
            $adminService = $solrConnection->getAdminService();
            if ($adminService->ping()) {
                $installationStatus = $this->checkPluginInstallationStatus($adminService);
                $versionStatus = $this->checkPluginVersion($adminService);

                if (!is_null($installationStatus)) {
                    $reports[] = $installationStatus;
                }

                if (!is_null($versionStatus)) {
                    $reports[] = $versionStatus;
                }
            }
        }

        return $reports;
    }
81343
protected function getStatusData() : array
    {
        $statusData = [
            'version' => self::VERSION,
            'starttime' => '',
            'uptime' => '',
            'active_worker' => [],
            'job_info' => [],
        ];

        $starttime = date('Y-m-d H:i:s', $this->startTime);
        $start = new \DateTime($starttime);
        $now = new \DateTime('now');
        $uptime = $start->diff($now)->format('%ad %Hh %Im %Ss');
        $statusData['starttime'] = $starttime;
        $statusData['uptime'] = $uptime;

        foreach (array_keys($this->processes) as $poolName) {
            if (!isset($statusData['active_worker'][$poolName])) {
                $statusData['active_worker'][$poolName] = 0;
            }
            /** @var Process $process */
            foreach ($this->processes[$poolName] as $process) {
                $processIsRunning = $process->isRunning();
                if ($processIsRunning === true) {
                    $statusData['active_worker'][$poolName]++;
                }
            }
        }
        $statusData['job_info']['job_requests_total'] = $this->totalJobRequests;
        $statusData['job_info']['queue_length'] = $this->jobsInQueue;
        $statusData['job_info']['worker_stats'] = $this->workerStats;
        return $statusData;
    }
360005
public function getListQueuedTask() {
		$result = [];
		if (!CakeSession::check($this->_sessionKey)) {
			return $result;
		}

		$tasks = CakeSession::read($this->_sessionKey);
		if (!is_array($tasks)) {
			return $result;
		}

		return $tasks;
	}
253756
public function getStatusAllowableValues()
    {
        return [
            self::STATUS_OK,
            self::STATUS_ERROR,
            self::STATUS_WAITING,
            self::STATUS_CREATING,
            self::STATUS_RESTORING,
            self::STATUS_DELETING,
        ];
    }
153233
protected function getRecordStatus()
    {
        /** @var DataObject|Versioned $record */
        $record = $this->record;

        // No status if un-versioned
        if (!$this->record->hasExtension(Versioned::class)) {
            return null;
        }

        if ($record->isOnDraftOnly()) {
            return [
                'class' => 'addedtodraft',
                'title' => _t(__CLASS__ . '.DRAFT', 'Draft')
            ];
        }

        if ($record->isModifiedOnDraft()) {
            return [
                'class' => 'modified',
                'title' => _t(__CLASS__ . '.MODIFIED', 'Modified')
            ];
        }

        return null;
    }
1101967
function fetchOrderStatus()
    {
        $statusList = eZOrderStatus::fetchMap( true, true );
        if ( isset( $statusList[$this->StatusID] ) )
        {
            return $statusList[$this->StatusID];
        }
        return false;
    }
742998
public function getExecTasks(): array
    {
        $data = [];
        $runTimeTableTasks = $this->getRunTimeTable()->table;
        if (\count($runTimeTableTasks) <= 0) {
            return $data;
        }

        $min = date('YmdHi');

        foreach ($runTimeTableTasks as $key => $value) {
            if ($value['minute'] == $min) {
                if (time() == $value['sec'] && $value['runStatus'] == self::NORMAL) {
                    $data[] = [
                        'key'        => $key,
                        'taskClass'  => $value['taskClass'],
                        'taskMethod' => $value['taskMethod'],
                    ];
                }
            }
        }

        foreach ($data as $item) {
            $this->startTask($item['key']);
        }

        return $data;
    }
854368
public function getScheduledCommands()
    {
        $scheduledCommands = [];
        foreach ($this->console->all() as $command) {
            if ($command instanceof ScheduledCommandInterface) {
                $scheduledCommands[] = $command;
            }
        }

        return $scheduledCommands;
    }
1062441
public function getScheduleStatus()
    {
        if (!$this->scheduleStatus) {
            return false;
        } else {
            list($scheduleStatus) = explode(';', $this->scheduleStatus);

            return $scheduleStatus;
        }
    }
1078036
public static function getStatusList()
    {
        return [
            self::STATUS_OK => 'ok',
            self::STATUS_SENDING => 'sending',
            self::STATUS_PENDING => 'pending',
            self::STATUS_ERROR => 'error',
            self::STATUS_ENCODING => 'encoding',
        ];
    }