Get error message

@param integer $intDynamicPosition
@return string
550887
public function getError($intDynamicPosition = 0)
    {
        $strReturn = "";

        if (isset($this->__errors[$intDynamicPosition]) && !empty($this->__errors[$intDynamicPosition])) {
            $strReturn = $this->__errors[$intDynamicPosition];
        }

        return $strReturn;
    }
86457
private function errorMessage()
    {


        if ($this->preparedExec == false){
    		$info = $this->dbConnector->errorInfo();
    	}
    	else{
    		$info = $this->lastPreparedExecStatement->errorInfo();
    	}
    	
    	if (!empty($info[2])){
    		$returnValue = $info[2];
    	}
    	else if (!empty($info[1])){
            $returnValue = 'Driver error: ' . $info[1];
    	}
    	else if (!empty($info[0])){
    		$returnValue = 'SQLSTATE: ' . $info[0];
    	}
        else{
            $returnValue = 'No error message to display.';
        }

        return (string) $returnValue;
    }
596184
public function getErrorText()
    {
        $message = '';
        if ($this->isError()) {
            $message = $this->messages->message[0]->text;
            if (@$this->transactionResponse->errors[0]->errorText) {
                $message = $this->transactionResponse->errors[0]->errorText;
            }
        }
        return $message;
    }
152552
function ErrorMsg()
	{
		if (!empty($this->_logsql)) return $this->_errorMsg;
		$this->_errorMsg = ifx_errormsg();
		return $this->_errorMsg;
	}
1219465
private function getIDNAErrors(int $error_byte): string
    {
        /**
         * IDNA errors.
         */
        static $idn_errors = [
            IDNA_ERROR_EMPTY_LABEL => 'a non-final domain name label (or the whole domain name) is empty',
            IDNA_ERROR_LABEL_TOO_LONG => 'a domain name label is longer than 63 bytes',
            IDNA_ERROR_DOMAIN_NAME_TOO_LONG => 'a domain name is longer than 255 bytes in its storage form',
            IDNA_ERROR_LEADING_HYPHEN => 'a label starts with a hyphen-minus ("-")',
            IDNA_ERROR_TRAILING_HYPHEN => 'a label ends with a hyphen-minus ("-")',
            IDNA_ERROR_HYPHEN_3_4 => 'a label contains hyphen-minus ("-") in the third and fourth positions',
            IDNA_ERROR_LEADING_COMBINING_MARK => 'a label starts with a combining mark',
            IDNA_ERROR_DISALLOWED => 'a label or domain name contains disallowed characters',
            IDNA_ERROR_PUNYCODE => 'a label starts with "xn--" but does not contain valid Punycode',
            IDNA_ERROR_LABEL_HAS_DOT => 'a label contains a dot=full stop',
            IDNA_ERROR_INVALID_ACE_LABEL => 'An ACE label does not contain a valid label string',
            IDNA_ERROR_BIDI => 'a label does not meet the IDNA BiDi requirements (for right-to-left characters)',
            IDNA_ERROR_CONTEXTJ => 'a label does not meet the IDNA CONTEXTJ requirements',
        ];

        $res = [];
        foreach ($idn_errors as $error => $reason) {
            if ($error_byte & $error) {
                $res[] = $reason;
            }
        }

        return [] === $res ? 'Unknown IDNA conversion error.' : implode(', ', $res).'.';
    }
1269119
public function getStatusMessageFromCode(int $code) : string
    {
        if (isset($this->statusMessageList[$code])) {
            return $this->statusMessageList[$code];
        }
        throw new \InvalidArgumentException(
            'Invalid status code'
        );
    }
119090
private function getMessage(ErrorInterface $error): string
    {
        $message = $this->formatMessage($error->getMessageTemplate(), $error->getMessageParameters());

        return $message;
    }
183595
public function getErrorsAsString(): string
    {
        $errors = $this->getErrors();
        if (0 === $errors->count()) {
            return '';
        }
        $message = 'found ' . $errors->count() . ' errors validating '
                   . \get_class($this->dataObject);
        foreach ($errors as $error) {
            $message .= "\n\n" . $error->getPropertyPath() . ': ' . $error->getMessage();
        }

        return $message;
    }
112029
public function getErrorMessage($intCode, $arrOptions=array()) {
		if (isset($arrOptions['error']))
			return $arrOptions['error'];

		if (isset($arrOptions['message']))
			return $this->locale->insert($arrOptions['message'], array('value' => isset($arrOptions['value']) ? $arrOptions['value'] : $arrOptions['field'], 'field' => $arrOptions['field']));

		$field = isset($arrOptions['label']) ? $arrOptions['label'] : (isset($arrOptions['field']) ? $this->locale->get($arrOptions['field']) : '');

		switch ($intCode) {
			case FILTER_VALIDATE_REQUIRED:
				return $this->locale->insert('error.empty', array('value' => $field));
			case FILTER_VALIDATE_PASSWORD:
				return $this->locale->get('error.password');
			case FILTER_VALIDATE_USERNAME:
				return $this->locale->insert('error.username', array('value' => '"'.$arrOptions['value'].'"'));
			case FILTER_VALIDATE_IDENTIFIER:
				return $this->locale->insert('error.identifier', array('value' => '"'.$arrOptions['value'].'"'));
			case FILTER_VALIDATE_RESOURCE:
				return $this->locale->insert('error.resource', array('value' => '"'.$arrOptions['value'].'"'));
			case FILTER_VALIDATE_EMAIL:
				return $this->locale->insert('error.not_a_address', array('value' => '"'.$arrOptions['value'].'"', 'type' => 'E-mail'));
			case FILTER_VALIDATE_IPV4:
				return $this->locale->insert('error.not_a_address', array('value' => '"'.$arrOptions['value'].'"', 'type' => 'IPv4'));
			case FILTER_VALIDATE_IPV6:
				return $this->locale->insert('error.not_a_address', array('value' => '"'.$arrOptions['value'].'"', 'type' => 'IPv6'));
			case FILTER_VALIDATE_IP:
				return $this->locale->insert('error.not_a_address', array('value' => '"'.$arrOptions['value'].'"', 'type' => 'IP'));
			case FILTER_VALIDATE_URL:
				return $this->locale->insert('error.not_a_url', array('value' => $arrOptions['value']));
			case FILTER_VALIDATE_FLOAT:
				return $this->locale->insert('error.not_a_number', array('value' => $field));
			case FILTER_VALIDATE_INT:
				if (isset($arrOptions['min_range']) && isset($arrOptions['max_range']))
					return $this->locale->insert('error.in_between', array('value' => $field, 'min' => $arrOptions['min_range'], 'max' => $arrOptions['max_range']));
				elseif (isset($arrOptions['min_range']))
					return $this->locale->insert('error.greater_than', array('value' => $field, 'count' => $arrOptions['min_range']));
				elseif (isset($arrOptions['max_range']))
					return $this->locale->insert('error.less_than', array('value' => $field, 'count' => $arrOptions['max_range']));
				else
					return $this->locale->insert('error.not_a_int', array('value' => $field));
			case FILTER_VALIDATE_BOOLEAN:
				break;
			case FILTER_VALIDATE_MIN_LENGTH:
				return $this->locale->insert('error.too_short', array('value' => $field, 'count' => $arrOptions['len']));
			case FILTER_VALIDATE_MAX_LENGTH:
				return $this->locale->insert('error.too_long', array('value' => $field, 'count' => $arrOptions['len']));
			case FILTER_VALIDATE_LENGTH:
				return $this->locale->insert('error.wrong_range', array('value' => $field, 'min' => $arrOptions['min'], 'max' => $arrOptions['max']));
			case FILTER_VALIDATE_DATE_RANGE:
				$arrOptions['format'] = isset($arrOptions['format']) ? $arrOptions['format'] : $this->locale->getDateFormat('date.format.default');
				return $this->locale->insert('error.date_range', array('value' => $field, 'min' => date($arrOptions['format'], $arrOptions['min']), 'max' => date($arrOptions['format'], $arrOptions['max'])));
			case FILTER_VALIDATE_DATE_START_END:
				$arrOptions['format'] = isset($arrOptions['format']) ? $arrOptions['format'] : $this->locale->getDateFormat('date.format.default');
				return $this->locale->insert('error.date_start_end', array('value' => $field, 'end' => date($arrOptions['format'], $arrOptions['end'])));
			default:
				// too_long
				// too_short
				// empty (Muss ausgefüllt werden)
				// invalid
				// start_before_end
				// range: Ist keine gültige {model}
				break;
		}

		return $this->locale->insert('error.invalid', array('value' => isset($arrOptions['value']) ? $arrOptions['value'] : $field, 'field' => $field));
	}
125360
public function getErrorMessage()
    {
        switch ($this->error) {
            case UPLOAD_ERR_INI_SIZE:
                $message = "The uploaded file exceeds the upload_max_filesize directive in php.ini";
                break;
            case UPLOAD_ERR_FORM_SIZE:
                $message = "The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form";
                break;
            case UPLOAD_ERR_PARTIAL:
                $message = "The uploaded file was only partially uploaded";
                break;
            case UPLOAD_ERR_NO_FILE:
                $message = "No file was uploaded";
                break;
            case UPLOAD_ERR_NO_TMP_DIR:
                $message = "Missing a temporary folder";
                break;
            case UPLOAD_ERR_CANT_WRITE:
                $message = "Failed to write file to disk";
                break;
            case UPLOAD_ERR_EXTENSION:
                $message = "File upload stopped by extension";
                break;

            default:
                $message = "Unknown upload error";
        }

        return $message;
    }
1267873
public function getError()
    {
        $oOut       = new \stdClass();
        $oOut->msg  = $this->sErrorMsg;
        $oOut->code = $this->sErrorCode;
        $oOut->user = $this->sErrorUser;

        return $oOut;
    }
388547
public function getMessage()
    {
        if ($this->getErrorMessage()) {
            return $this->getErrorMessage() . ' (' . $this->getErrorFieldName() . ')';
        }

        if ($this->isSuccessful()) {
            return ($this->getStatus()) ? ucfirst($this->getStatus()) : 'Successful';
        }
        // default to unsuccessful message
        return 'The transaction was unsuccessful.';
    }
398864
public function getPotentialMessage()
    {
        $message = clone ($this->getErrorMessagePrototype());
        $message->setTemplate($this->getMessageTemplate());
        $message->setVariables($this->options);

        return $message;
    }
790358
public function getValue($intDynamicPosition = 0)
    {
        $varValue = null;

        if ($intDynamicPosition > 0) {
            $objValidator = $this->__validator;
            $objValidator->validate($intDynamicPosition);

            $varValue = $objValidator->getValidValue($intDynamicPosition);
        } else {
            $varValue = $this->__validator->getValidValue();
        }

        //*** Sanitize the value before returning.
        $varValue = $this->sanitize($varValue, $this->__sanitize);

        return $varValue;
    }
177954
public function isMet($intDynamicPosition = 0)
    {
        $blnResult = false;

        switch ($this->__comparisontype) {
            default:
            case ValidForm::VFORM_MATCH_ANY:
				/* @var $objComparison Comparison */
				foreach ($this->__comparisons as $objComparison) {
                    if ($objComparison->check($intDynamicPosition)) {
                        $blnResult = true; // One of the comparisons is true, that's good enough.
                        break;
                    }
                }

                break;

            case ValidForm::VFORM_MATCH_ALL:
                $blnFailed = false;
				/* @var $objComparison Comparison */
                foreach ($this->__comparisons as $objComparison) {
                    if (!$objComparison->check($intDynamicPosition)) {
                        $blnFailed = true;
                        break;
                    }
                }

                $blnResult = !$blnFailed;

                break;
        }

        return $blnResult;
    }
1315245
public function toJS($intDynamicPosition = 0)
    {
        $strOutput = "";

        foreach ($this->__fields as $field) {
            $strOutput .= $field->toJS($this->__dynamic);
        }

        // *** Condition logic.
        if ($this->__dynamic || $intDynamicPosition) {
            $intDynamicCount = $this->getDynamicCount();

            for ($intCount = 0; $intCount <= $intDynamicCount; $intCount ++) {
                // *** Render the condition logic per dynamic field.
                $strOutput .= $this->conditionsToJs($intCount);
            }
        } else {
            // *** Condition logic.
            $strOutput .= $this->conditionsToJs();
        }

        return $strOutput;
    }
646160
public static function getUploadErrorMessage(int $errorCode): string
    {
        switch ($errorCode) {
            case \UPLOAD_ERR_INI_SIZE:
                return 'The uploaded file exceeds the upload_max_filesize directive in php.ini';
            case \UPLOAD_ERR_FORM_SIZE:
                return 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form';
            case \UPLOAD_ERR_PARTIAL:
                return 'The uploaded file was only partially uploaded';
            case \UPLOAD_ERR_NO_FILE:
                return 'No file was uploaded';
            case \UPLOAD_ERR_NO_TMP_DIR:
                return 'Missing a temporary folder';
            case \UPLOAD_ERR_CANT_WRITE:
                return 'Failed to write file to disk';
            case \UPLOAD_ERR_EXTENSION:
                return 'File upload stopped by extension';
            default:
                return 'Unknown upload error';
        }
    }