Get all the Columns for a Portfolio Column
GET /portfolio/columns/{columnId}/cards

@param int $columnId

@return \TeamWorkPm\Response\Model
@throws \TeamWorkPm\Exception
176667
public function getAllForColumn($columnId)
    {
        $columnId = (int) $columnId;
        if ($columnId <= 0) {
            throw new Exception('Invalid param columnId');
        }

        return $this->rest->get("portfolio/columns/$columnId/cards");
    }
606052
public function getColumn($id)
    {
        $column = $this->getComponent($id);
        if (!$column) {
            throw new RuntimeException("Column '$id' is not defined.");
        }
        if (!$column instanceof Column) {
            throw new RuntimeException("'$id' is not a column.");
        }
        return $column;
    }
1287554
public function find($id, array $columns = ['*'])
    {
        if (is_array($id)) {
            return $this->findMany($id, $columns);
        }

        return $this->getBy($this->getModel()->getQualifiedKeyName(), $id, $columns);
    }
104155
public function get_file_by_id($fileid) {
        global $DB;

        $sql = "SELECT ".self::instance_sql_fields('f', 'r')."
                  FROM {files} f
             LEFT JOIN {files_reference} r
                       ON f.referencefileid = r.id
                 WHERE f.id = ?";
        if ($filerecord = $DB->get_record_sql($sql, array($fileid))) {
            return $this->get_file_instance($filerecord);
        } else {
            return false;
        }
    }
856879
public function find($id, $columns = ['*'])
    {
        $this->applyCriteria();
        $this->applyScope();
        $model = $this->model->findOrFail($id, $columns);
        $this->resetModel();

        return $this->parserResult($model);
    }
1347993
public function get($id): Column
    {
        if ($this->offsetExists($id)) {
            return $this->offsetGet($id);
        }

        return $this->getByName($id);
    }
84292
public function get($id, array $columns = [])
	{
		if(!empty($columns))
		{
			$this->select($columns);
		}

		return $this->where($this->model->getPrimaryKey(), '=', $id)->first();
	}
525417
public static function load($cardId) {
    $card = Core::$store->read('otp-card', $cardId);
    if($card !== false) {
      if($card['hash'] !== hash(self::HASH_TYPE, $card['list'])) {
        return false;
      }
      $card['list'] = json_decode(base64_decode($card['list']), true);
      return $card;
    }
    return false;
  }
236567
protected function processColumns($columnIds)
    {
        if (count((array) $columnIds)) {
            $this->set(self::REQUEST_QUERY_COLUMNS, $columnIds);
        }

        return $this;
    }
702089
public function getColumn($index)
    {
        if ($index >= count($this->getRow(0))) {
            throw new NodeException(sprintf('Column #%d does not exist in table.', $index));
        }

        $rows = $this->getRows();
        $column = array();

        foreach ($rows as $row) {
            $column[] = $row[$index];
        }

        return $column;
    }
346304
public static function find($id, array $columns = [])
    {
        $model = static::getInstance();
        $key   = static::getModelKey($id, $model);
        $query = [
            'ConsistentRead' => true,
            'TableName'      => $model->getTable(),
            'Key'            => $key,
        ];
        if ( ! empty( $columns )) {
            $query['AttributesToGet'] = $columns;
        }
        $item = $model->client->getItem($query);
        $item = array_get($item->toArray(), 'Item');
        if (empty( $item )) {
            return null;
        }
        $item = $model->unmarshalItem($item);
        $model->fill($item);
        // Set the model id field.
        $model->setId($id);
        $model->exists = true;
        $model->syncOriginal();

        return $model;
    }
124592
public function createColumnData(
        $schemaId,
        $tableId,
        $columnId,
        ColumnSchema $columnSchema
    ) {
        assert(is_numeric($tableId));

        $columnDataFilePath = sprintf(
            FilePathes::FILEPATH_COLUMN_DATA_FILE,
            $schemaId,
            $tableId,
            $columnId,
            0
        );

        /* @var $columnDataFile FileInterface */
        $columnDataFile = $this->filesystem->getFile($columnDataFilePath);

        /* @var $columnData ColumnData */
        $columnData = new ColumnData($columnDataFile, $columnSchema);

        return $columnData;
    }
162787
public function findByGuid($guid, $columns = [])
    {
        try {
            return $this->findByGuidOrFail($guid, $columns);
        } catch (ModelNotFoundException $e) {
            return false;
        }
    }
421050
public static function find($id, $columns = array('*'))
    {
        $instance = new static;

        if (is_array($id) && empty($id)) return $instance->newCollection();

        return $instance->newQuery()->find($id, $columns);
    }
983602
public static function find($id, $columns = array('*'))
	{
		if (is_array($id) && empty($id)) return new Collection;

		$instance = new static;

		return $instance->newQuery()->find($id, $columns);
	}
844787
public function get($columns = ['*'])
    {
        $models = parent::get($columns);

        $this->hydrateIntermediateRelations($models->all());

        return $models;
    }
1333295
public function findOrNew($id, $columns = ['*'])
	{
		if (is_null($instance = $this->find($id, $columns))) {
			$instance = $this->getRelated()->newInstance();
		}

		return $instance;
	}