Uploadable File Types ~
Here you can enter a list of files that can be uploaded into 'assets/files/' using the Resource Manager. Please enter the extensions for the filetypes, seperated by commas.

@param string $value

@return $this
765906
public function setCoreUploadFiles($value)
    {
        $this->setFieldName('upload_files');
        $this->loadObject(true);
        $this->setFieldValue($value);

        return $this;
    }
1048707
public function setType(string $value) : ScheduledJob
    {

        if ($this->data['type'] !== $value) {
            $this->data['type'] = $value;
            $this->setModified('type');
        }

        return $this;
    }
1211550
public function setValue( $value ) {
		if ( strtolower( $this->tag ) === 'textarea' ) {
			$this->clearContent();
			$this->appendContent( $value );
		} else {
			$this->setAttributes( [ 'value' => $value ] );
		}
		return $this;
	}
75430
public function add($value) {

		if($this->_ReadOnly){
			throw new ReadOnlyException(\get_called_class() . ' is read only');
		}
		
		$this->_Arr = \array_merge($this->_Arr, \func_get_args());
		
		return $this;
		
	}
845976
private function setRealFileName($value) {
        $base64FileNamePos = strpos($value, 'filename ');
        if (is_int($base64FileNamePos) && $base64FileNamePos >= 0) {
            $value = substr($value, $base64FileNamePos + 9); // 9 - length of 'filename '
            $this->realFileName = base64_decode($value);
        } else {
            $this->realFileName = $value;
        }
        return $this;
    }
1155904
public function set_value($value) {

        // Getting the filemanager label from the DOM.
        $fieldlabel = $this->get_field_locator();

        // Getting the filepicker context and using the step definition
        // to upload the requested file.
        $uploadcontext = behat_context_helper::get('behat_repository_upload');
        $uploadcontext->i_upload_file_to_filemanager($value, $fieldlabel);
    }
1006686
protected function validateValue($value)
    {
        if (is_string($value) && file_exists($value))
        {
            $uploadFile = new UploadedFile();
            $uploadFile->size = filesize($value);
            $uploadFile->type = FileHelper::getMimeType($value, null, false);
            $uploadFile->tempName = $value;
            $uploadFile->name = $value;

            $value = $uploadFile;
        }

        $result = parent::validateValue($value);

        return empty($result) ? $this->validateImage($value) : $result;
    }
1256652
public function setCoreCompressCss($value)
    {
        $this->setFieldName('compress_css');
        $this->loadObject(true);
        $this->setFieldValue($value);

        return $this;
    }
437644
public function setCoreUdpermsAllowroot($value)
    {
        $this->setFieldName('udperms_allowroot');
        $this->loadObject(true);
        $this->setFieldValue($value);

        return $this;
    }
1293074
public function setValue($value)
    {
        switch ($this->type) {
            case Parameter::TYPE_INTEGER:
                $this->value = (int) $value;
                break;
            case Parameter::TYPE_STRING:
            case Parameter::TYPE_ANY:
            default:
                $this->value = (string) $value;
        }

        return $this;
    }
296448
public function setPermissions($value)
    {
        $allowedResources = self::allowedResources();
        $allowedMethods = self::allowedMethods();

        if ($value !== null && !is_array($value)) {
            throw new DomainException(self::MSG_INVALID_FORMAT);
        }

        foreach ($value as $rule) {
            if (!is_array($rule)) {
                throw new DomainException(self::MSG_INVALID_FORMAT);
            }

            if (!empty($rule['resourceName']) && !in_array($rule['resourceName'], $allowedResources, true)) {
                throw new DomainException(sprintf(self::MSG_UNEXPECTED_RESOURCE, implode(', ', $allowedResources)));
            }

            if (!empty($rule['resourceIds']) && !is_array($rule['resourceIds'])) {
                throw new DomainException(self::MSG_INVALID_RESOURCE_IDS);
            }

            if (!empty($rule['methods']) && !is_array($rule['methods'])) {
                throw new DomainException(self::MSG_INVALID_METHODS);
            }

            if (!empty($rule['methods'])) {
                foreach ($rule['methods'] as $method) {
                    if (!in_array($method, $allowedMethods, true)) {
                        throw new DomainException(sprintf(self::MSG_UNEXPECTED_METHOD, implode(', ', $allowedMethods)));
                    }
                }
            }
        }

        return $this->setAttribute('permissions', $value);
    }
420856
public final function setValue($value) {
		$this->assetConstraints($value);

		$this->value = $value;
		$this->valueLoaded = true;
	}
1276940
public function addValue($value)
    {
        if ($this->datatype == 'string') {
            if (is_string($value) == false) {
                throw new InvalidArgumentException('The value(' . $value . ') is not string but the restriction demands it');
            }
        } elseif ($this->datatype == 'integer') {
            // The value comes as string from the wsdl
            if (is_string($value)) {
                $value = intval($value);
            }

            if (is_int($value) == false) {
                throw new InvalidArgumentException('The value(' . $value . ') is not int but the restriction demands it');
            }
        } else {
            if ($value == null) {
                throw new InvalidArgumentException('Value(' . $value . ') is null');
            }
        }

        $this->values[] = $value;
    }
639751
public function isValid($value)
    {
        if (array_key_exists($value, $this->_files)) {
            $files[$value] = $this->_files[$value];
        } else {
            foreach ($this->_files as $file => $content) {
                if ($content['name'] === $value) {
                    $files[$file] = $this->_files[$file];
                }

                if ($content['tmp_name'] === $value) {
                    $files[$file] = $this->_files[$file];
                }
            }
        }

        if (empty($files)) {
            $this->_error(self::FILE_NOT_FOUND);
            return false;
        }

        foreach ($files as $file => $content) {
            $this->_value = $file;
            switch($content['error']) {
            case 0:
                if (!is_uploaded_file($content['tmp_name'])) {
                    $this->_error(self::ATTACK);
                }
                break;

            case 1:
                $this->_error(self::INI_SIZE);
                break;

            case 2:
                $this->_error(self::FORM_SIZE);
                break;

            case 3:
                $this->_error(self::PARTIAL);
                break;

            case 4:
                $this->_error(self::NO_FILE);
                break;

            case 6:
                $this->_error(self::NO_TMP_DIR);
                break;

            case 7:
                $this->_error(self::CANT_WRITE);
                break;

            case 8:
                $this->_error(self::EXTENSION);
                break;

            default:
                $this->_error(self::UNKNOWN);
                break;
            }
        }

        if (count($this->_messages) > 0) {
            return false;
        } else {
            return true;
        }
    }
1011230
public function setCodeType($value)
    {
        if (in_array($value, $this->codeTypeList)) {
            $this->codeType = $value;
        } else {
            throw new \Exception('Wrong code type "' . $value . '". Accepted : numeric, alpha or alphanumeric');
        }

        return $this;
    }
772197
public function setValue($value) {
        switch ($this->type) {
            case self::TYPE_BOOLEAN:
                $this->value = (bool) $value;
                break;
            case self::TYPE_STRING:
                $this->value = (string) $value;
                break;
        }
        return $this;
    }
19940
public function filter($value)
    {
        if (is_object($value) && ! method_exists($value, '__toString')) {
            return '';
        }

        if (is_array($value)) {
            $dummy = [
                'name' => '',
                'tmp_name' => '',
                'error' => UPLOAD_ERR_NO_FILE,
                'size' => 0,
                'type' => '',
            ];
            $value = ArrayUtils::merge($dummy, $value);
        } else {
            $value = (string) $value;
        }

        if (isset($value['error']) && $value['error'] !== UPLOAD_ERR_OK) {
            return '';
        }

        if ($this->options['use_uploaded_name'] && isset($value['name'])) {
            $value = $value['name'];
        } elseif (isset($value['tmp_name'])) {
            $value = $value['tmp_name'];
        }

        if ($this->options['basename']) {
            $value = basename($value);
        }

        return $value;
    }