TranslateTasks.php

Go to the documentation of this file.

<?php
abstract class TranslateTask {
    protected $id = '__BUG__';

    // We need $id here because staticness prevents subclass overriding.
    public static function labelForTask( $id ) {
        return wfMessage( 'translate-task-' . $id )->text();
    }

    public function getId() {
        return $this->id;
    }

    public function plainOutput() {
        return false;
    }

    protected $group;

    protected $collection;

    protected $options;

    protected $nondefaults;

    protected $context;

    protected $offsets;

    final public function init( MessageGroup $group, array $options, array $nondefaults,
        IContextSource $context
    ) {
        $this->group = $group;
        $this->options = $options;
        $this->nondefaults = $nondefaults;
        $this->context = $context;
    }

    abstract protected function output();

    abstract protected function preinit();

    abstract protected function postinit();

    final public function execute() {
        $this->preinit();
        $this->doPaging();
        $this->postinit();

        return $this->output();
    }

    protected function doPaging() {
        $total = count( $this->collection );
        $offsets = $this->collection->slice(
            $this->options['offset'],
            $this->options['limit']
        );
        $left = count( $this->collection );

        $this->offsets = array(
            'backwardsOffset' => $offsets[0],
            'forwardsOffset' => $offsets[1],
            'start' => $offsets[2],
            'count' => $left,
            'total' => $total,
        );
    }

    public function isAllowedFor( User $user ) {
        return true;
    }
}

class CustomFilteredMessagesTask extends TranslateTask {
    protected $id = 'custom';

    protected function preinit() {
    }

    protected function postinit() {
    }

    protected function doPaging() {
    }

    protected function output() {
        $table = new TuxMessageTable( $this->context, $this->group, $this->options['language'] );

        return $table->fullTable();
    }
}

class ViewMessagesTask extends TranslateTask {
    protected $id = 'view';

    protected function preinit() {
        $code = $this->options['language'];
        $this->collection = $this->group->initCollection( $code );
        $this->collection->filter( 'ignored' );
        $this->collection->filter( 'optional' );
    }

    protected function postinit() {
        $this->collection->loadTranslations();
    }

    protected function output() {
        $table = MessageTable::newFromContext( $this->context, $this->collection, $this->group );
        $table->appendEditLinkParams( 'loadtask', $this->getId() );

        return $table->fullTable( $this->offsets, $this->nondefaults );
    }
}

class ReviewMessagesTask extends ViewMessagesTask {
    protected $id = 'review';

    protected function preinit() {
        $code = $this->options['language'];
        $this->collection = $this->group->initCollection( $code );
        $this->collection->filter( 'ignored' );
    }

    protected function output() {
        $table = MessageTable::newFromContext( $this->context, $this->collection, $this->group );
        $table->appendEditLinkParams( 'loadtask', $this->getId() );
        $table->setReviewMode();

        return $table->fullTable( $this->offsets, $this->nondefaults );
    }
}

class ViewUntranslatedTask extends ViewMessagesTask {
    protected $id = 'untranslated';

    protected function preinit() {
        $code = $this->options['language'];
        $this->collection = $this->group->initCollection( $code );
        $this->collection->filter( 'ignored' );
        $this->collection->filter( 'optional' );
        $this->collection->filter( 'translated' );
    }
}

class ViewOptionalTask extends ViewMessagesTask {
    protected $id = 'optional';

    protected function preinit() {
        $code = $this->options['language'];
        $this->collection = $this->group->initCollection( $code );
        $this->collection->filter( 'ignored' );
        $this->collection->filter( 'optional', false );
    }
}

class ReviewAllMessagesTask extends ReviewMessagesTask {
    protected $id = 'reviewall';

    protected function preinit() {
        parent::preinit();
        $this->collection->filter( 'ignored' );
        $this->collection->filter( 'hastranslation', false );
    }
}

class AcceptQueueMessagesTask extends ReviewMessagesTask {
    protected $id = 'acceptqueue';

    protected function preinit() {
        $user = $this->context->getUser();
        parent::preinit();
        $this->collection->filter( 'ignored' );
        $this->collection->filter( 'hastranslation', false );
        $this->collection->filter( 'fuzzy' );
        $this->collection->filter( 'reviewer', true, $user->getId() );
        $this->collection->filter( 'last-translator', true, $user->getId() );
    }

    public function isAllowedFor( User $user ) {
        return $user->isAllowed( 'translate-messagereview' );
    }
}

class ExportMessagesTask extends ViewMessagesTask {
    protected $id = 'export';

    protected function preinit() {
        $code = $this->options['language'];
        $this->collection = $this->group->initCollection( $code );
        // Don't export ignored, unless it is the source language
        // or message documentation
        global $wgTranslateDocumentationLanguageCode;
        if ( $code !== $wgTranslateDocumentationLanguageCode
            && $code !== $this->group->getSourceLanguage()
        ) {
            $this->collection->filter( 'ignored' );
        }
    }

    // No paging should be done.
    protected function doPaging() {
    }

    public function output() {
        if ( $this->group instanceof MessageGroupBase ) {
            $ffs = $this->group->getFFS();
            $data = $ffs->writeIntoVariable( $this->collection );
        } else {
            $writer = $this->group->getWriter();
            $data = $writer->webExport( $this->collection );
        }

        return Html::element( 'textarea', array( 'id' => 'wpTextbox1', 'rows' => '50' ), $data );
    }
}

class ExportToFileMessagesTask extends ExportMessagesTask {
    protected $id = 'export-to-file';

    public function plainOutput() {
        return true;
    }

    public function output() {
        if ( !$this->group instanceof FileBasedMessageGroup ) {
            return 'Not supported';
        }

        $ffs = $this->group->getFFS();
        $data = $ffs->writeIntoVariable( $this->collection );

        $filename = basename( $this->group->getSourceFilePath( $this->collection->getLanguage() ) );
        header( "Content-Disposition: attachment; filename=\"$filename\"" );

        return $data;
    }
}

class ExportAsPoMessagesTask extends ExportMessagesTask {
    protected $id = 'export-as-po';

    public function plainOutput() {
        return true;
    }

    public function output() {
        if ( MessageGroups::isDynamic( $this->group ) ) {
            return 'Not supported';
        }

        $ffs = null;
        if ( $this->group instanceof FileBasedMessageGroup ) {
            $ffs = $this->group->getFFS();
        }

        if ( !$ffs instanceof GettextFFS ) {
            $group = FileBasedMessageGroup::newFromMessageGroup( $this->group );
            $ffs = new GettextFFS( $group );
        }

        $ffs->setOfflineMode( 'true' );

        $code = $this->options['language'];
        $id = $this->group->getID();
        $filename = "${id}_$code.po";
        header( "Content-Disposition: attachment; filename=\"$filename\"" );

        return $ffs->writeIntoVariable( $this->collection );
    }
}

class TranslateTasks {
    public static function getTasks( $pageTranslation = false ) {
        global $wgTranslateTasks;

        // Tasks not to be available in page translation.
        $filterTasks = array(
            'optional',
            'export-to-file',
        );

        $allTasks = array_keys( $wgTranslateTasks );

        if ( $pageTranslation ) {
            $allTasks = array_diff( $allTasks, $filterTasks );
        }

        return $allTasks;
    }

    public static function getTask( $id ) {
        global $wgTranslateTasks;

        if ( array_key_exists( $id, $wgTranslateTasks ) ) {
            if ( is_callable( $wgTranslateTasks[$id] ) ) {
                return call_user_func( $wgTranslateTasks[$id], $id );
            }

            return new $wgTranslateTasks[$id];
        }

        return null;
    }
}