Status.php

Go to the documentation of this file.

<?php
class Status {
    public $ok = true;

    public $value;

    public $successCount = 0;

    public $failCount = 0;

    public $success = array();

    public $errors = array();

    public $cleanCallback = false;

    static function newFatal( $message /*, parameters...*/ ) {
        $params = func_get_args();
        $result = new self;
        call_user_func_array( array( &$result, 'error' ), $params );
        $result->ok = false;
        return $result;
    }

    static function newGood( $value = null ) {
        $result = new self;
        $result->value = $value;
        return $result;
    }

    public function setResult( $ok, $value = null ) {
        $this->ok = $ok;
        $this->value = $value;
    }

    public function isGood() {
        return $this->ok && !$this->errors;
    }

    public function isOK() {
        return $this->ok;
    }

    public function warning( $message /*, parameters... */ ) {
        $params = array_slice( func_get_args(), 1 );
        $this->errors[] = array(
            'type' => 'warning',
            'message' => $message,
            'params' => $params );
    }

    public function error( $message /*, parameters... */ ) {
        $params = array_slice( func_get_args(), 1 );
        $this->errors[] = array(
            'type' => 'error',
            'message' => $message,
            'params' => $params );
    }

    public function fatal( $message /*, parameters... */ ) {
        $params = array_slice( func_get_args(), 1 );
        $this->errors[] = array(
            'type' => 'error',
            'message' => $message,
            'params' => $params );
        $this->ok = false;
    }

    public function __wakeup() {
        $this->cleanCallback = false;
    }

    protected function cleanParams( $params ) {
        if ( !$this->cleanCallback ) {
            return $params;
        }
        $cleanParams = array();
        foreach ( $params as $i => $param ) {
            $cleanParams[$i] = call_user_func( $this->cleanCallback, $param );
        }
        return $cleanParams;
    }

    public function getWikiText( $shortContext = false, $longContext = false ) {
        if ( count( $this->errors ) == 0 ) {
            if ( $this->ok ) {
                $this->fatal( 'internalerror_info',
                    __METHOD__ . " called for a good result, this is incorrect\n" );
            } else {
                $this->fatal( 'internalerror_info',
                    __METHOD__ . ": Invalid result object: no error text but not OK\n" );
            }
        }
        if ( count( $this->errors ) == 1 ) {
            $s = $this->getErrorMessage( $this->errors[0] )->plain();
            if ( $shortContext ) {
                $s = wfMessage( $shortContext, $s )->plain();
            } elseif ( $longContext ) {
                $s = wfMessage( $longContext, "* $s\n" )->plain();
            }
        } else {
            $errors = $this->getErrorMessageArray( $this->errors );
            foreach ( $errors as &$error ) {
                $error = $error->plain();
            }
            $s = '* ' . implode( "\n* ", $errors ) . "\n";
            if ( $longContext ) {
                $s = wfMessage( $longContext, $s )->plain();
            } elseif ( $shortContext ) {
                $s = wfMessage( $shortContext, "\n$s\n" )->plain();
            }
        }
        return $s;
    }

    public function getMessage( $shortContext = false, $longContext = false ) {
        if ( count( $this->errors ) == 0 ) {
            if ( $this->ok ) {
                $this->fatal( 'internalerror_info',
                    __METHOD__ . " called for a good result, this is incorrect\n" );
            } else {
                $this->fatal( 'internalerror_info',
                    __METHOD__ . ": Invalid result object: no error text but not OK\n" );
            }
        }
        if ( count( $this->errors ) == 1 ) {
            $s = $this->getErrorMessage( $this->errors[0] );
            if ( $shortContext ) {
                $s = wfMessage( $shortContext, $s );
            } elseif ( $longContext ) {
                $wrapper = new RawMessage( "* \$1\n" );
                $wrapper->params( $s )->parse();
                $s = wfMessage( $longContext, $wrapper );
            }
        } else {
            $msgs = $this->getErrorMessageArray( $this->errors );
            $msgCount = count( $msgs );

            if ( $shortContext ) {
                $msgCount++;
            }

            $s = new RawMessage( '* $' . implode( "\n* \$", range( 1, $msgCount ) ) );
            $s->params( $msgs )->parse();

            if ( $longContext ) {
                $s = wfMessage( $longContext, $s );
            } elseif ( $shortContext ) {
                $wrapper = new RawMessage( "\n\$1\n", $s );
                $wrapper->parse();
                $s = wfMessage( $shortContext, $wrapper );
            }
        }

        return $s;
    }

    protected function getErrorMessage( $error ) {
        if ( is_array( $error ) ) {
            if ( isset( $error['message'] ) && $error['message'] instanceof Message ) {
                $msg = $error['message'];
            } elseif ( isset( $error['message'] ) && isset( $error['params'] ) ) {
                $msg = wfMessage( $error['message'],
                    array_map( 'wfEscapeWikiText', $this->cleanParams( $error['params'] ) ) );
            } else {
                $msgName = array_shift( $error );
                $msg = wfMessage( $msgName,
                    array_map( 'wfEscapeWikiText', $this->cleanParams( $error ) ) );
            }
        } else {
            $msg = wfMessage( $error );
        }
        return $msg;
    }

    public function getHTML( $shortContext = false, $longContext = false ) {
        $text = $this->getWikiText( $shortContext, $longContext );
        $out = MessageCache::singleton()->parse( $text, null, true, true );
        return $out instanceof ParserOutput ? $out->getText() : $out;
    }

    protected function getErrorMessageArray( $errors ) {
        return array_map( array( $this, 'getErrorMessage' ), $errors );
    }

    public function merge( $other, $overwriteValue = false ) {
        $this->errors = array_merge( $this->errors, $other->errors );
        $this->ok = $this->ok && $other->ok;
        if ( $overwriteValue ) {
            $this->value = $other->value;
        }
        $this->successCount += $other->successCount;
        $this->failCount += $other->failCount;
    }

    public function getErrorsArray() {
        return $this->getStatusArray( "error" );
    }

    public function getWarningsArray() {
        return $this->getStatusArray( "warning" );
    }

    protected function getStatusArray( $type ) {
        $result = array();
        foreach ( $this->errors as $error ) {
            if ( $error['type'] === $type ) {
                if ( $error['message'] instanceof Message ) {
                    $result[] = array_merge(
                        array( $error['message']->getKey() ),
                        $error['message']->getParams()
                    );
                } elseif ( $error['params'] ) {
                    $result[] = array_merge( array( $error['message'] ), $error['params'] );
                } else {
                    $result[] = array( $error['message'] );
                }
            }
        }

        return $result;
    }

    public function getErrorsByType( $type ) {
        $result = array();
        foreach ( $this->errors as $error ) {
            if ( $error['type'] === $type ) {
                $result[] = $error;
            }
        }
        return $result;
    }

    public function hasMessage( $message ) {
        if ( $message instanceof Message ) {
            $message = $message->getKey();
        }
        foreach ( $this->errors as $error ) {
            if ( $error['message'] instanceof Message
                && $error['message']->getKey() === $message
            ) {
                return true;
            } elseif ( $error['message'] === $message ) {
                return true;
            }
        }
        return false;
    }

    public function replaceMessage( $source, $dest ) {
        $replaced = false;
        foreach ( $this->errors as $index => $error ) {
            if ( $error['message'] === $source ) {
                $this->errors[$index]['message'] = $dest;
                $replaced = true;
            }
        }
        return $replaced;
    }

    public function getValue() {
        return $this->value;
    }
}