Return all models in the repository as a select list

@param   bool $includeNull
@return array
489462
public function getAllAsSelectList($includeNull = false)
    {
        $models = $this->repository->all();

        return $this->convertToSelectList($includeNull, $models);
    }
980080
public function listContainers($include_properties = false)
    {
        $this->checkConnection();

        if (!empty($this->container)) {
            return $this->listResource($include_properties);
        }

        try {
            /** @var Collection $containers */
            $containers = $this->blobConn->ContainerList();

            $out = [];

            /** @var Container $container */
            while (($container = $containers->Next())) {
                $name = rtrim($container->name);
                $out[] = ['name' => $name, 'path' => $name];
            }

            return $out;
        } catch (\Exception $ex) {
            static::handleGuzzleException($ex);
            throw new DfException('Failed to list containers: ' . $ex->getMessage());
        }
    }
245921
function getConstList($include_default = false)
    {
        if (isset($this->_c__consts))
            return $this->_c__consts;

        $reflection = new ReflectionClass($this);
        $consts     = $reflection->getConstants();
        if ((bool)$include_default === false)
            unset($consts['__default']);

        return $this->_c__consts = $consts;
    }
785520
public function toArray($skip_empty = false, $include_original = true)
    {
        // Skip when no media
        if ($skip_empty === true && $this->hasMedia() === false) {
            return null;
        }

        $urls = [];

        foreach ($this->styles as $name => $style) {
            if ($include_original === false
                && $this->config('default_style') === $name
            ) {
                continue;
            }

            $urls[$name] = $this->url($name);
        }

        return $urls;
    }
1079821
public function getSiblings($includeNode = true)
	{
		$parent = $this->getParent();
		$siblings = null;
		
		if ( ! is_null($parent)) {
			$siblings = $parent->getChildren();
		} else {
			$siblings = $this->repository->getRootNodes();
		}
		
		if ( ! $includeNode) {
			foreach ($siblings as $key => $sibling) {
				if ($sibling->isEqualTo($this)) {
					unset($siblings[$key]);
					break;
				}
			}
			// reset index
			$siblings = array_values($siblings);
		}
		
		return $siblings;
	}
1233593
public function bucket_list($include_default_bucket = true)
	{
		$bucket_list = array();

		foreach ($this->buckets as $bucket_id)
		{
			// skip the default bucket if ignored
			if ( ($include_default_bucket === false) && ($bucket_id === self::DEFAULT_BUCKET) )
			{
				continue;
			}

			$bucket_list[] = $bucket_id;
		}

		return $bucket_list;
	}
618269
public function selectManyModels(Select $select, HydratorInterface $hydrator = null, AbstractModel $model = null)
    {
        $resultSet = new ResultSet\HydratingResultSet($this->getHydrator(), $this->getModel());
        return $this->selectMany($select, $resultSet);
    }
1180916
public function otherModules(bool $include_disabled = false): Collection
    {
        return $this->findByInterface(ModuleInterface::class, $include_disabled, true)
            ->filter(static function (ModuleInterface $module): bool {
                foreach (self::COMPONENTS as $interface) {
                    if ($module instanceof $interface) {
                        return false;
                    }
                }

                return true;
            });
    }
102791
public function getFieldNames($includeMany = false)
    {
        $fieldNames = $this->getReadOnlyFields();
        foreach ($this->fields as $field => $value) {
            if ($includeMany || $this->getType($field) !== 'many') {
                $fieldNames[] = $field;
            }
        }
        return $fieldNames;
    }
327525
protected function getInverseBooleanSelectList($includeNull = false)
    {
        $results = array();
        if( $includeNull ) {
            $results[ '' ] = Translate::recursive('common.both');
        }

        $results[ 0 ] = Translate::recursive('common.yes');
        $results[ 1 ] = Translate::recursive('common.no');

        return $results;
    }
462723
public function getMultiOptions($includeSelf = true)
    {
        $this->_tmpResult = [];
        if (!$this->isNewRecord && $includeSelf) {
            $this->_tmpResult[$this->id] = $this;
        }
        return $this->_buildTreeArrayRecursive($this, $this->_filter);
    }
940568
public function getList($email = NULL, $includeExpired = false, $subaccount = NULL) {
        return $this->listRejects($email, $includeExpired, $subaccount);
    }
1156835
public static function get_all_eventlist($withoutcomponent = false) {
        if ($withoutcomponent) {
            $return = array_merge(self::get_core_eventlist(), self::get_non_core_eventlist($withoutcomponent));
            array_multisort($return, SORT_NATURAL);
        } else {
            $return = array_merge(array('core' => self::get_core_eventlist()),
                    self::get_non_core_eventlist($withoutcomponent = false));
        }
        return $return;
    }
317674
public static function getList($scheduledOnly = false)
    {
        $db = Loader::db();

        if ($scheduledOnly) {
            $q = "SELECT jID FROM Jobs WHERE isScheduled = 1 ORDER BY jDateLastRun, jID";
        } else {
            $q = "SELECT jID FROM Jobs ORDER BY jDateLastRun, jID";
        }
        $r = $db->Execute($q);
        $jobs = array();
        while ($row = $r->FetchRow()) {
            $j = static::getByID($row['jID']);
            if (is_object($j)) {
                $jobs[] = $j;
            }
        }

        return $jobs;
    }
1227874
public static function getList()
    {
        /** @var Model $model */
        $model = new static();
        $fields = [
            trim($model->getPrimaryKey(), '_'),
            trim($model->getDisplayField(), '_')
        ];
        $rows = Sql::createSql($model->getAdapter())
            ->select($model->getTableName(), $fields)
            ->limit(null)
            ->all();
        $list = [];
        list($id, $value) = $fields;
        if (!empty($rows)) {
            foreach ($rows as $row) {
                $list[$row[$id]] = $row[$value];
            }
        }
        return $list;
    }
83795
protected static function getSkippedDisplayFields(RepositoryInterface $table, bool $aliased = false): array
    {
        /** @var \Cake\ORM\Table */
        $table = $table;

        if (! $aliased) {
            return static::$skipDisplayFields;
        }

        $result = [];
        foreach (static::$skipDisplayFields as $field) {
            $result[] = $table->aliasField($field);
        }

        return $result;
    }
493958
public function get_fields(array $grep_fields = null, $includeBusiness = false)
    {
        $fields = [];

        foreach ($this->retrieve_fields() as $meta_struct_id => $field) {
            if ($grep_fields && ! in_array($field->get_name(), $grep_fields, true)) {
                continue;
            }

            if ((!$includeBusiness) && $field->get_databox_field()->isBusiness() === true) {
                continue;
            }

            $fields[] = $field;
        }

        return $fields;
    }