Returns list of invalid views

@return array
175653
public function getInvalidViews()
    {
        $aInvalidViews = [];
        $aShopViews = $this->_getShopViews();

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

        return $aInvalidViews;
    }
942027
public function getInvalidFields()
    {
        $invalidFields = array();
        foreach ($this->currentFields as $field) {
            if (!$field->isValid) {
                $invalidFields[] = $field;
            }
        }
        return $invalidFields;
    }
1243398
public function getFirstErrors(): array
    {
        $errors = $this->getErrors();
        if (empty($errors)) {
            return [];
        } else {
            $errors = [];
            foreach ($errors as $name => $es) {
                if (!empty($es)) {
                    $errors[$name] = reset($es);
                }
            }

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

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

        if ($this->container['itemId'] === null) {
            $invalidProperties[] = "'itemId' 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['isSingleton'] === null) {
            $invalidProperties[] = "'isSingleton' can't be null";
        }
        return $invalidProperties;
    }
176466
public function getErrors()
    {
        $errors = array();
        /** @var \tao_helpers_form_Validator $validator */
        foreach ($this->validators as $validator) {
            $errors[] = $validator->getMessage();
        }

        return $errors;
    }
205625
public function getInvalidAttribs()
    {
        return array_combine(
            array_keys($this->invalidAttribs),
            array_map(function ($ref) {
                return $ref['attrib'];
            }, array_values($this->invalidAttribs))
        );
    }
945009
public static function getErrors()
	{
		$list	= array();
		foreach( $this->errors as $errorKey )
			$list[$errorKey]	= self::$rules[$errorKey];
		return $list;
	}
299997
protected function getViewDataFromRequest()
    {
        $lookupParams = ['warning', 'error'];
        $result = [];
        foreach ($lookupParams as $lookupParam) {
            if ($this->getRequest()->hasParameter($lookupParam) && !empty($this->getRequest()->getParameter($lookupParam))) {
                $result[] = [
                    'level' => $lookupParam,
                    'content' => $this->getRequest()->getParameter($lookupParam),
                    'timeout' => -1
                ];
            }
        }
        return $result;
    }
1357136
public static function getActionableViews() {
		static $views;
		if (isset($views)) {
			return $views;
		}

		$views = [];

		$plugin = elgg_get_plugin_from_id('hypeInteractions');
		$settings = $plugin->getAllSettings();
		foreach ($settings as $key => $value) {
			if (!$value) {
				continue;
			}
			list ($prefix, $view) = explode(':', $key);
			if ($prefix !== 'stream_object') {
				continue;
			}
			$views[] = $view;
		}

		return $views;
	}
588798
public function listInvalidProperties()
    {
        $invalidProperties = [];

        if ($this->container['bloodlineId'] === null) {
            $invalidProperties[] = "'bloodlineId' can't be null";
        }
        if ($this->container['name'] === null) {
            $invalidProperties[] = "'name' can't be null";
        }
        if ($this->container['description'] === null) {
            $invalidProperties[] = "'description' can't be null";
        }
        if ($this->container['raceId'] === null) {
            $invalidProperties[] = "'raceId' can't be null";
        }
        if ($this->container['shipTypeId'] === null) {
            $invalidProperties[] = "'shipTypeId' can't be null";
        }
        if ($this->container['corporationId'] === null) {
            $invalidProperties[] = "'corporationId' can't be null";
        }
        if ($this->container['perception'] === null) {
            $invalidProperties[] = "'perception' can't be null";
        }
        if ($this->container['willpower'] === null) {
            $invalidProperties[] = "'willpower' can't be null";
        }
        if ($this->container['charisma'] === null) {
            $invalidProperties[] = "'charisma' can't be null";
        }
        if ($this->container['memory'] === null) {
            $invalidProperties[] = "'memory' can't be null";
        }
        if ($this->container['intelligence'] === null) {
            $invalidProperties[] = "'intelligence' can't be null";
        }
        return $invalidProperties;
    }
572267
public function listInvalidProperties()
    {
        $invalidProperties = [];

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

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

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

        return $invalidProperties;
    }
630331
public function displayValidRoutesAction()
    {
        $this->di->views->add('default/error-routes', [
          'route'           => $this->di->request->getRoute(),
          'routes'          => $this->di->router->getAll(),
          'internalRoutes'  => $this->di->router->getInternal(),
          'controllers'     => $this->di->getControllers(),
        ]);
    }
360017
public function getItemsWithUnhandledErrors()
    {
        $list = [];
        foreach ($this->getItems() as $item) {
            if ($item->hasUnhandledError()) {
                $list[] = $item;
            }
        }

        return $list;
    }
1092811
public function getViews(): array
	{
		$result = [];
		foreach ($this->views->get() as $row) {
			/* @var $row PageView */
			$result[] = $row->translatedName;
		}
		return $result;
	}
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;
    }
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;
    }
535422
private function getValidatedFilters(): iterable
    {
        $ruleIndexes = $this->serializerClass::readFilterRulesIndexes($this->getSerializedRuleSet());

        if ($ruleIndexes === null) {
            // without validation
            foreach ($this->getFilterParameters() as $field => $operationsWithArgs) {
                yield $field => $this->parseOperationsAndArguments(static::PARAM_FILTER, $operationsWithArgs);
            }
        } else {
            // with validation
            $mainIndexes = $this->serializerClass::readRuleMainIndexes($ruleIndexes);
            $this->validationStarts(static::PARAM_FILTER, $ruleIndexes);
            foreach ($this->getFilterParameters() as $field => $operationsWithArgs) {
                if (is_string($field) === false || empty($field) === true ||
                    is_array($operationsWithArgs) === false || empty($operationsWithArgs) === true
                ) {
                    throw new InvalidQueryParametersException($this->createParameterError(
                        static::PARAM_FILTER,
                        $this->getInvalidParamMessage()
                    ));
                }

                if (array_key_exists($field, $mainIndexes) === false) {
                    // unknown field set type
                    $this->getValidationErrors()->add(
                        new ValidationError(
                            static::PARAM_FILTER,
                            $field,
                            ErrorCodes::INVALID_VALUE,
                            Messages::INVALID_VALUE,
                            []
                        )
                    );
                } else {
                    // for field a validation rule is defined so input value will be validated
                    $ruleIndex = $mainIndexes[$field];
                    $parsed    = $this->parseOperationsAndArguments(static::PARAM_FILTER, $operationsWithArgs);

                    yield $field => $this->validateFilterArguments($ruleIndex, $parsed);
                }
            }
            $this->validateEnds(static::PARAM_FILTER, $ruleIndexes);
        }
    }