getPutPostBodyDescriptionReadyOnlyFields

@param bool $isCreating

@return string
500566
private function getPutPostBodyDescriptionReadyOnlyFields($isCreating) {
        $description = '';
        $models = [[null, $this->getModel()]];
        foreach($this->getRelatedModels() as $alias => $relatedModel) {
            $models[] = [$alias, $relatedModel];
        }
        $automaticFields = array();
        foreach($models as $modelData) {
            /** @var Base $model */
            list($alias, $model) = $modelData;
            if($isCreating) {
                $automaticAttributes = $model->getModelsMetaData()->getAutomaticCreateAttributes($model);
            } else {
                $automaticAttributes = $model->getModelsMetaData()->getAutomaticUpdateAttributes($model);
            }
            $columnMap = $model->getModelsMetaData()->getColumnMap($model);
            foreach($model->getAutomaticallyUpdatedFields() as $field) {
                $automaticFields[(!is_null($alias) ? $alias . '.' : '') . $field] = null;
            }
            foreach($automaticAttributes as $fullName => $null) {
                $automaticFields[(!is_null($alias) ? $alias . '.' : '') . $columnMap[$fullName]] = null;
            }
        }
        foreach($this->getModel()->getExtraProperties() as $string) {
            $automaticFields[$string] = '';
        }
        if(!empty($automaticFields)) {
            $description .= "\n" . 'The following fields are read only: ' . implode(', ', array_keys($automaticFields)) . '.';
        }
        return $description;
    }
918561
private function requestBodyContainsProtectedFields($object_or_object_class, array $request_body)
    {
        if ($object_or_object_class instanceof EntityInterface) {
            $protected_fields = $object_or_object_class instanceof ProtectedFieldsInterface ? $object_or_object_class->getProtectedFields() : [];
        } elseif (is_string($object_or_object_class)) {
            $object = $this->pool->produce($object_or_object_class, [], false);

            $protected_fields = $object instanceof ProtectedFieldsInterface ? $object->getProtectedFields() : [];
        } else {
            throw new InvalidArgumentException('Valid object instance of object class expected');
        }

        foreach (array_keys($request_body) as $field) {
            if (in_array($field, $protected_fields)) {
                return true;
            }
        }

        return false;
    }
1191249
protected function getMigrationCapsule(MigrationInput $input, $resource, $name, $isCreate = true)
    {
        $migration = MigrationCapsule::get($name);
        $migration->path = $this->getMigrationFullName($name);
        $migration->resource = $resource;
        $migration->className = $this->makeCreateTableClassName(Helpers::makeTableName($this->tableName));
        $migration->isCreate = $isCreate;
        $migration->withoutTimestamps = $input->withoutTimestamps;
        $migration->withSoftDelete = $input->withSoftDelete;

        return $migration;
    }
172003
public function getInputName()
  {
    $n = false;
    if ($f = $this->getForm()) {
      $n = $f->getName();
    }

    $inp = $this->getField();

    return $n ? $n . '[' . $inp . ']' : $inp;
  }
942381
public function compileDbTableStructureDump($create = false)
	{
		$fields = $this->entity->getScalarFields();
		$connection = $this->entity->getConnection();

		$autocomplete = array();

		foreach ($fields as $field)
		{
			if ($field->isAutocomplete())
			{
				$autocomplete[] = $field->getName();
			}
		}

		if($create === false){
			// start collecting queries
			$connection->disableQueryExecuting();
		}

		// create table
		$this->createTableMysql($this->entity->getDBTableName(), $fields, $this->entity->getPrimaryArray(), $autocomplete);
		$dump = $connection->getDisabledQueryExecutingDump();
		if($create === false){
			// stop collecting queries
			$connection->enableQueryExecuting();
		}

		return $dump;
	}
924028
public function getCustomHTMLBody($callback = false) {
        $body = $this->getHtmlBody();
        if($body === null) return null;

        if ($callback !== false) {
            $aAttachment = $this->parent->getAttachments();
            $aAttachment->each(function($oAttachment) use(&$body, $callback) {
                /** @var Attachment $oAttachment */
                if(is_callable($callback)) {
                    $body = $callback($body, $oAttachment);
                }elseif(is_string($callback)) {
                    call_user_func($callback, [$body, $oAttachment]);
                }
            });
        }

        return $body;
    }
1091618
function fetchObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute )
    {
        $enabledName = $base . '_ezcomcomments_enabled_' . $contentObjectAttribute->attribute( 'id' );
        $shownName = $base . '_ezcomcomments_shown_' . $contentObjectAttribute->attribute( 'id' );
        $enabledValue = -1;
        $shownValue = -1;
        if ( $http->hasPostVariable( $enabledName ) )
        {
            $enabledValue = 1;
        }
        if ( $http->hasPostVariable( $shownName ) )
        {
            $shownValue = 1;
        }
        $contentObjectAttribute->setAttribute( 'data_float', $shownValue );
        $contentObjectAttribute->setAttribute( 'data_int', $enabledValue );
        return true;
    }
655485
public function getCreatedBy()
    {
        $createdByAttribute = $this->createdByAttribute;
        return (!is_string($createdByAttribute) || empty($createdByAttribute)) ? null : $this->$createdByAttribute->getData();
    }
1200010
public function getPostParameter($key, $isRequired = true, $defaultValue = null)
    {
        return Utils::getValueFromArray($this->postData, $key, $isRequired, $defaultValue);
    }
920719
public function formatted($isFormatted=null)
    {
        if (isset($isFormatted)) {
            $this->data['formatted'] = $isFormatted;
            return $this;
        }
        
        return isset($this->data['formatted']) ? $this->data['formatted'] : false;
    }
703652
protected function saveEntity(\stdClass $postParams, ModelInterface $entity, $isCreating) {
        $postParams = $this->findPostParams($postParams, $entity);
        /** @var Save $save */
        $save = $this->getDI()->get(Save::class, [$this->request, $entity, $isCreating]);
        return $save->process($postParams);
    }
325620
function is_link($new = null, $return_entity = false)
    {
        if (isset($new) && ($this->_attributes['is_link'] != $new)){
            $this->change('is_link', (bool)$new);
        }
        if ($return_entity){
            if (!isset($this->_link)){
                if (empty($this->_attributes['is_link'])){
                    $this->_link = false;
                }else
                if (($this->_link = $this->proto(null, true))){
                    if ($p = $this->_link->is_link(null, true)) $this->_link = $p;
                }
            }
            return $this->_link;
        }
        return $this->_attributes['is_link'];
    }
895317
public function getPost($formatAble = false)
    {
        $post = Post::published()->first();
        $post = self::fix($post);

        if ($formatAble) {
            $post = Manager::formatAble($post);
        }

        return $post;
    }
282192
public function getCreatedAt()
    {
        $createdAtAttribute = $this->createdAtAttribute;
        if (!is_string($createdAtAttribute) || empty($createdAtAttribute)) {
            return null;
        }
        return $this->$createdAtAttribute;
    }
454215
public function getTypeId($type, $createIfMissing = true)
    {
        if (null === $this->types) {
            $this->loadCache();
        }

        if (false === ($key = array_search($type, $this->types, true))) {

            if (!$createIfMissing) {
                return null;
            }

            try {
                $this
                    ->backend
                    ->getConnection()
                    ->insert('apb_msg_type')
                    ->fields(array('type' => $type))
                    ->execute()
                ;

            } catch (\PDOException $e) {
                // Another thread went doing this at the same time and created
                // the same type, ignore error and continue
            }

            $this->loadCache();

            return array_search($type, $this->types, true);

        } else {
            return $key;
        }
    }
526264
public static function Factory($name, $caption, $dataType, $xmlObject, $size, $maxLength, $visible, $required)
	{
		$fieldPage = new CrudField();
		$fieldPage->fieldName = strtolower($name);
		$fieldPage->fieldCaption = $caption;
		$fieldPage->key = false;
		$fieldPage->dataType = $dataType;
		$fieldPage->size = $size;
		$fieldPage->maxLength = $maxLength;
		$fieldPage->fieldXmlInput = $xmlObject ;
		$fieldPage->visibleInList = $visible;
		$fieldPage->editable = true;
		$fieldPage->required = $required;
		return $fieldPage;
	}
1351233
protected function renderDescription($text, $isFieldset = false)
    {
        $output = '';

        // Help text.
        if (!empty($text)) {
            // Allow for links in the help text, so no filtering anymore.
            $wrapperType = $isFieldset ? 'fieldsetDescription' : 'description';
            $output .= $this->getWrapper($wrapperType);
            $output .= $text;
            $output .= $this->getWrapperEnd($wrapperType);
        }

        return $output;
    }