Show all the invalid properties with reasons.

@return array invalid properties with reasons
430218
public function listInvalidProperties()
    {
        $invalidProperties = [];

        $allowedValues = $this->getAuthTypeAllowableValues();
        if (!is_null($this->container['auth_type']) && !in_array($this->container['auth_type'], $allowedValues, true)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'auth_type', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        $allowedValues = $this->getAuthSecondFactorTypeAllowableValues();
        if (!is_null($this->container['auth_second_factor_type']) && !in_array($this->container['auth_second_factor_type'], $allowedValues, true)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'auth_second_factor_type', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        return $invalidProperties;
    }
942027
public function getInvalidFields()
    {
        $invalidFields = array();
        foreach ($this->currentFields as $field) {
            if (!$field->isValid) {
                $invalidFields[] = $field;
            }
        }
        return $invalidFields;
    }
550515
public function getValidAttribs()
    {
        return array_combine(
            array_keys($this->validAttribs),
            array_map(function ($ref) {
                return $ref['attrib'];
            }, array_values($this->validAttribs))
        );
    }
381718
public function listInvalidProperties()
    {
        $invalidProperties = [];

        if ($this->container['loggedAt'] === null) {
            $invalidProperties[] = "'loggedAt' can't be null";
        }
        if ($this->container['containerId'] === null) {
            $invalidProperties[] = "'containerId' can't be null";
        }
        if ($this->container['containerTypeId'] === null) {
            $invalidProperties[] = "'containerTypeId' can't be null";
        }
        if ($this->container['characterId'] === null) {
            $invalidProperties[] = "'characterId' can't be null";
        }
        if ($this->container['locationId'] === null) {
            $invalidProperties[] = "'locationId' can't be null";
        }
        if ($this->container['locationFlag'] === null) {
            $invalidProperties[] = "'locationFlag' can't be null";
        }
        $allowedValues = $this->getLocationFlagAllowableValues();
        if (!in_array($this->container['locationFlag'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'locationFlag', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if ($this->container['action'] === null) {
            $invalidProperties[] = "'action' can't be null";
        }
        $allowedValues = $this->getActionAllowableValues();
        if (!in_array($this->container['action'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'action', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        $allowedValues = $this->getPasswordTypeAllowableValues();
        if (!in_array($this->container['passwordType'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'passwordType', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        return $invalidProperties;
    }
1154936
protected static function getInvalidCharacters()
    {
        if (!self::$invalidCharString) {
            self::$invalidCharString = implode('', array_map('chr', array_merge(
                range(0, 32),
                array(34, 40, 41, 44, 47),
                array(58, 59, 60, 61, 62, 63, 64, 91, 92, 93, 123, 125, 127)
            )));
        }

        return self::$invalidCharString;
    }
175653
public function getInvalidViews()
    {
        $aInvalidViews = [];
        $aShopViews = $this->_getShopViews();

        foreach ($aShopViews as $sView) {
            if (!$this->_isViewValid($sView)) {
                $aInvalidViews[] = $sView;
            }
        }

        return $aInvalidViews;
    }
1335429
public function listInvalidProperties()
    {
        $invalidProperties = [];

        if ($this->container['contractId'] === null) {
            $invalidProperties[] = "'contractId' can't be null";
        }
        if ($this->container['issuerId'] === null) {
            $invalidProperties[] = "'issuerId' can't be null";
        }
        if ($this->container['issuerCorporationId'] === null) {
            $invalidProperties[] = "'issuerCorporationId' can't be null";
        }
        if ($this->container['assigneeId'] === null) {
            $invalidProperties[] = "'assigneeId' can't be null";
        }
        if ($this->container['acceptorId'] === null) {
            $invalidProperties[] = "'acceptorId' can't be null";
        }
        if ($this->container['type'] === null) {
            $invalidProperties[] = "'type' can't be null";
        }
        $allowedValues = $this->getTypeAllowableValues();
        if (!in_array($this->container['type'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'type', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if ($this->container['status'] === null) {
            $invalidProperties[] = "'status' can't be null";
        }
        $allowedValues = $this->getStatusAllowableValues();
        if (!in_array($this->container['status'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'status', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if ($this->container['forCorporation'] === null) {
            $invalidProperties[] = "'forCorporation' can't be null";
        }
        if ($this->container['availability'] === null) {
            $invalidProperties[] = "'availability' can't be null";
        }
        $allowedValues = $this->getAvailabilityAllowableValues();
        if (!in_array($this->container['availability'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'availability', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if ($this->container['dateIssued'] === null) {
            $invalidProperties[] = "'dateIssued' can't be null";
        }
        if ($this->container['dateExpired'] === null) {
            $invalidProperties[] = "'dateExpired' can't be null";
        }
        return $invalidProperties;
    }
223168
public function listInvalidProperties()
    {
        $invalidProperties = [];

        if (!is_null($this->container['currentRank']) && ($this->container['currentRank'] > 9)) {
            $invalidProperties[] = "invalid value for 'currentRank', must be smaller than or equal to 9.";
        }

        if (!is_null($this->container['currentRank']) && ($this->container['currentRank'] < 0)) {
            $invalidProperties[] = "invalid value for 'currentRank', must be bigger than or equal to 0.";
        }

        if (!is_null($this->container['highestRank']) && ($this->container['highestRank'] > 9)) {
            $invalidProperties[] = "invalid value for 'highestRank', must be smaller than or equal to 9.";
        }

        if (!is_null($this->container['highestRank']) && ($this->container['highestRank'] < 0)) {
            $invalidProperties[] = "invalid value for 'highestRank', must be bigger than or equal to 0.";
        }

        if ($this->container['kills'] === null) {
            $invalidProperties[] = "'kills' can't be null";
        }
        if ($this->container['victoryPoints'] === null) {
            $invalidProperties[] = "'victoryPoints' can't be null";
        }
        return $invalidProperties;
    }
181379
public function getValidationErrors()
    {
        $errors = $this->errors;

        if (isset($this->validator)) {
            $validator_errors = $this->validator->getErrors();
            $errors = array_merge($errors, $validator_errors);
        }

        return $errors;
    }
1283894
public function listInvalidProperties()
    {
        $invalidProperties = [];

        if ($this->container['sender'] === null) {
            $invalidProperties[] = "'sender' can't be null";
        }
        if ($this->container['name'] === null) {
            $invalidProperties[] = "'name' can't be null";
        }
        if (!is_null($this->container['splitRule']) && ($this->container['splitRule'] > 50)) {
            $invalidProperties[] = "invalid value for 'splitRule', must be smaller than or equal to 50.";
        }

        if (!is_null($this->container['splitRule']) && ($this->container['splitRule'] < 1)) {
            $invalidProperties[] = "invalid value for 'splitRule', must be bigger than or equal to 1.";
        }

        $allowedValues = $this->getWinnerCriteriaAllowableValues();
        if (!in_array($this->container['winnerCriteria'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'winnerCriteria', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if (!is_null($this->container['winnerDelay']) && ($this->container['winnerDelay'] > 168)) {
            $invalidProperties[] = "invalid value for 'winnerDelay', must be smaller than or equal to 168.";
        }

        if (!is_null($this->container['winnerDelay']) && ($this->container['winnerDelay'] < 1)) {
            $invalidProperties[] = "invalid value for 'winnerDelay', must be bigger than or equal to 1.";
        }

        return $invalidProperties;
    }
722514
public function getValidationErrors()
    {
        if ($this->isValid()) {
            return [];
        }
        
        // if it's already cached, just return it
        if (count($this->validationErrors) > 0) {
            return $this->validationErrors;
        }


        // All errors can be spotted in the fields
        foreach ($this->getFields() as $field) {
            if (!$field->isValid()) {
                $this->validationErrors[$field->getName()] = $field->getErrors(true);
            }
        }

        return $this->validationErrors;
    }
892189
public function listInvalidProperties()
    {
        $invalid_properties = [];

        if ($this->container['name'] === null) {
            $invalid_properties[] = "'name' can't be null";
        }
        if ($this->container['document_type'] === null) {
            $invalid_properties[] = "'document_type' can't be null";
        }
        $allowed_values = $this->getDocumentTypeAllowableValues();
        if (!in_array($this->container['document_type'], $allowed_values)) {
            $invalid_properties[] = sprintf(
                "invalid value for 'document_type', must be one of '%s'",
                implode("', '", $allowed_values)
            );
        }

        if ($this->container['document_content'] === null) {
            $invalid_properties[] = "'document_content' can't be null";
        }
        $allowed_values = $this->getStrictAllowableValues();
        if (!in_array($this->container['strict'], $allowed_values)) {
            $invalid_properties[] = sprintf(
                "invalid value for 'strict', must be one of '%s'",
                implode("', '", $allowed_values)
            );
        }

        return $invalid_properties;
    }
852924
protected static function define_properties() {
        return [
            'contextid' => [
                'type' => PARAM_INT,
                'description' => 'The context id.',
            ],
            'defaultexpired' => [
                'type' => PARAM_INT,
                'description' => 'Whether to default retention period for the purpose has been reached',
                'default' => 1,
            ],
            'expiredroles' => [
                'type' => PARAM_TEXT,
                'description' => 'This list of roles to include during deletion',
                'default'  => '',
            ],
            'unexpiredroles' => [
                'type' => PARAM_TEXT,
                'description' => 'This list of roles to exclude during deletion',
                'default'  => '',
            ],
            'status' => [
                'choices' => [
                    self::STATUS_EXPIRED,
                    self::STATUS_APPROVED,
                    self::STATUS_CLEANED,
                ],
                'type' => PARAM_INT,
                'description' => 'The deletion status of the context.',
            ],
        ];
    }
500897
public function problems()
    {
        $rawProblems = $this->load('p');
        $problems = array();

        foreach ($rawProblems as $problem) {
            $problems[] = Helper\formatProblem($problem, false);
        }

        return $problems;
    }
350412
protected function renderValidationErrors()
    {
        $arguments = $this->controllerContext->getArguments();
        $validationResults = $arguments->getValidationResults();
        $validationErrors = [];
        foreach ($validationResults->getFlattenedErrors() as $key => $errors) {
            $validationError = ['property' => $key, 'errors' => []];
            foreach ($errors as $error) {
                /** @var \TYPO3\Flow\Error\Error $error */
                $validationError['errors'][] = [
                    'message' => $error->getMessage(),
                    'code' => $error->getCode()
                ];
            }
            $validationErrors[] = $validationError;
        }
        return $validationErrors;
    }
1212240
public function listInvalidProperties()
    {
        $invalidProperties = [];

        $allowedValues = $this->getGradeAllowableValues();
        if (!in_array($this->container['grade'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'grade', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        $allowedValues = $this->getSubjectAllowableValues();
        if (!in_array($this->container['subject'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'subject', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        return $invalidProperties;
    }
902377
public function listInvalidProperties()
    {
        $invalid_properties = [];
        if ($this->container['maxDockableShipVolume'] === null) {
            $invalid_properties[] = "'maxDockableShipVolume' can't be null";
        }
        if ($this->container['name'] === null) {
            $invalid_properties[] = "'name' can't be null";
        }
        if ($this->container['officeRentalCost'] === null) {
            $invalid_properties[] = "'officeRentalCost' can't be null";
        }
        if ($this->container['reprocessingEfficiency'] === null) {
            $invalid_properties[] = "'reprocessingEfficiency' can't be null";
        }
        if ($this->container['reprocessingStationsTake'] === null) {
            $invalid_properties[] = "'reprocessingStationsTake' can't be null";
        }
        if ($this->container['services'] === null) {
            $invalid_properties[] = "'services' can't be null";
        }
        if ($this->container['stationId'] === null) {
            $invalid_properties[] = "'stationId' can't be null";
        }
        if ($this->container['systemId'] === null) {
            $invalid_properties[] = "'systemId' can't be null";
        }
        if ($this->container['typeId'] === null) {
            $invalid_properties[] = "'typeId' can't be null";
        }
        return $invalid_properties;
    }