File Coverage

blib/lib/MediaWiki/Bot/Plugin/Admin.pm

Criterion	Covered	Total	%
statement	15	198	7.5
branch	0	66	0.0
condition	0	36	0.0
subroutine	5	18	27.7
pod	13	13	100.0
total	33	331	9.9

package MediaWiki::Bot::Plugin::Admin;
# ABSTRACT: A plugin to MediaWiki::Bot providing admin functions

use strict;
use warnings;
#use diagnostics;
use Carp;
use List::Compare;

our $VERSION = '3.004000'; # VERSION


use Exporter qw(import);
our @EXPORT = qw(
    rollback
    delete undelete delete_archived_image
    block unblock
    protect unprotect
    transwiki_import xml_import
    set_usergroups add_usergroups remove_usergroups
);


sub rollback {
    my $self      = shift;
    my $page      = shift;
    my $user      = shift;
    my $summary   = shift;
    my $markbot   = shift;

    my $res = $self->{api}->edit({
        action  => 'rollback',
        title   => $page,
        user    => $user,
        summary => $summary,
        markbot => $markbot,
    });
    return $self->_handle_api_error() unless $res;

    return $res;
}


sub delete {
    my $self    = shift;
    my $page    = shift;
    my $summary = shift || 'BOT: deleted page by command';

    my $res = $self->{api}->api({
        action  => 'query',
        titles  => $page,
        prop    => 'info|revisions',
        intoken => 'delete'
    });
    my $data = [ %{ $res->{query}->{pages} } ]->[1];
    my $edittoken = $data->{deletetoken};

    $res = $self->{api}->api({
        action => 'delete',
        title  => $page,
        token  => $edittoken,
        reason => $summary
    });
    return $self->_handle_api_error() unless $res;

    return $res;
}


sub undelete {
    my $self    = shift;
    my $page    = shift;
    my $summary = shift || 'BOT: undeleting page by command';

    # http://meta.wikimedia.org/w/api.php?action=query&list=deletedrevs&titles=User:Mike.lifeguard/sandbox&drprop=token&drlimit=1
    my $token_results = $self->{api}->api({
        action  => 'query',
        list    => 'deletedrevs',
        titles  => $page,
        drlimit => 1,
        drprop  => 'token',
    });
    my $token = $token_results->{query}->{deletedrevs}->[0]->{token};

    my $res = $self->{api}->api({
        action  => 'undelete',
        title   => $page,
        reason  => $summary,
        token   => $token,
    });
    return $self->_handle_api_error() unless $res;

    return $res;
}


sub delete_archived_image {
    my $self    = shift;
    my $archive = shift;
    my $summary = shift || 'BOT: deleting old version of image by command';

    my $file = [ split m/!/, $archive ]->[1];

    my ($token) = $self->_get_edittoken($file);

    my $res = $self->{api}->api({
        action   => 'delete',
        title    => "File:$file",
        token    => $token,
        reason   => $summary,
        oldimage => $archive,
    });
    return $self->_handle_api_error() unless $res;

    return $res;

}


sub block {
    my $self = shift;
    my $user;
    my $length;
    my $summary;
    my $anononly;
    my $autoblock;
    my $blockac;
    my $blockemail;
    my $blocktalk;
    if (ref $_[0] eq 'HASH') {
        $user       = $_[0]->{user};
        $length     = $_[0]->{length};
        $summary    = $_[0]->{summary};
        $anononly   = $_[0]->{anononly};
        $autoblock  = $_[0]->{autoblock};
        $blockac    = $_[0]->{blockac};
        $blockemail = $_[0]->{blockemail};
        $blocktalk  = $_[0]->{blocktalk};
    }
    else {
        $user       = shift;
        $length     = shift;
        $summary    = shift;
        $anononly   = shift;
        $autoblock  = shift;
        $blockac    = shift;
        $blockemail = shift;
        $blocktalk  = shift;
    }

    my $res;
    my $edittoken;

    if ($self->{blocktoken}) {
        $edittoken = $self->{blocktoken};
    }
    else {
        $res = $self->{api}->api({
            action  => 'query',
            titles  => 'Main_Page',
            prop    => 'info|revisions',
            intoken => 'block'
        });
        my $data = [ %{ $res->{query}->{pages} } ]->[1];
        $edittoken = $data->{blocktoken};
        $self->{blocktoken} = $edittoken;
    }
    my $hash = {
        action => 'block',
        user   => $user,
        token  => $edittoken,
        expiry => $length,
        reason => $summary
    };
    $hash->{anononly}      = $anononly   if ($anononly);
    $hash->{autoblock}     = $autoblock  if ($autoblock);
    $hash->{nocreate}      = $blockac    if ($blockac);
    $hash->{noemail}       = $blockemail if ($blockemail);
    $hash->{allowusertalk} = 1           if (!$blocktalk);

    $res = $self->{api}->api($hash);
    if (!$res) {
        return $self->_handle_api_error();
    }

    return $res;
}


sub unblock {
    my $self    = shift;
    my $user    = shift;
    my $summary = shift;

    my $res;
    my $edittoken;
    if ($self->{unblocktoken}) {
        $edittoken = $self->{unblocktoken};
    }
    else {
        $res = $self->{api}->api({
            action  => 'query',
            titles  => 'Main_Page',
            prop    => 'info|revisions',
            intoken => 'unblock',
        });
        my $data = [ %{ $res->{query}->{pages} } ]->[1];
        $edittoken = $data->{unblocktoken};
        $self->{unblocktoken} = $edittoken;
    }

    my $hash = {
        action => 'unblock',
        user   => $user,
        token  => $edittoken,
        reason => $summary,
    };
    $res = $self->{api}->api($hash);
    return $self->_handle_api_error() unless $res;

    return $res;
}


sub unprotect { # A convenience function
    my $self   = shift;
    my $page   = shift;
    my $reason = shift;

    return $self->protect($page, $reason, 'all', 'all');
}


sub protect {
    my $self    = shift;
    my $page    = shift;
    my $reason  = shift;
    my $editlvl = defined($_[0]) ? shift : 'sysop';
    my $movelvl = defined($_[0]) ? shift : 'sysop';
    my $time    = shift || 'infinite';
    my $cascade = shift;

    $editlvl = 'all' if $editlvl eq '';
    $movelvl = 'all' if $movelvl eq '';

    if ($cascade and ($editlvl ne 'sysop' or $movelvl ne 'sysop')) {
        carp "Can't set cascading unless both editlvl and movelvl are sysop." if $self->{debug};
    }
    my $res = $self->{api}->api({
        action  => 'query',
        titles  => $page,
        prop    => 'info|revisions',
        intoken => 'protect'
    });

    my $data = [ %{ $res->{query}->{pages} } ]->[1];
    my $edittoken = $data->{protecttoken};

    $res = $self->{api}->api({
        action      => 'protect',
        title       => $page,
        token       => $edittoken,
        reason      => $reason,
        protections => "edit=$editlvl|move=$movelvl",
        expiry      => $time,
        cascade     => $cascade,
    });
    return $self->_handle_api_error() unless $res;

    return $res;
}

sub transwiki_import {
    my $self = shift;
    my $prefix      = $_[0]->{prefix} || 'w';
    my $page        = $_[0]->{page};
    my $namespace   = $_[0]->{ns} || 0;
    my $history     = defined($_[0]->{history}) ? $_[0]->{history} : 1;
    my $templates   = defined($_[0]->{templates}) ? $_[0]->{templates} : 0;

    my $res = $self->{api}->api({
        action  => 'query',
        prop    => 'info',
        titles  => 'Main Page',
        intoken => 'import',
    });
    return $self->_handle_api_error() unless $res;

    my $data = [ %{ $res->{query}->{pages} } ]->[1];
    my $importtoken = $data->{importtoken};

    $res = $self->{api}->api({
        action          => 'import',
        token           => $importtoken,
        interwikisource => $prefix,
        interwikipage   => $page,
        fullhistory     => $history,
        namespace       => $namespace,
        templates       => $templates,
    });
    return $self->_handle_api_error() unless $res;

    return $res;
}


sub xml_import {
    my $self     = shift;
    my $filename = shift or die 'No filename given';

    my $success = $self->{api}->edit({
        action  => 'import',
        xml     => [ $filename ],
    });
    return $self->_handle_api_error() unless $success;
    return $success;
}


sub set_usergroups {
    my $self    = shift;
    my $user    = shift;
    my $rights  = shift;
    my $summary = shift;

    $user =~ s/^User://;

    unless (
        exists $self->{userrightscache}
        and $self->{userrightscache}
        and $self->{userrightscache}->{user} eq $user
    ) {
        $self->usergroups($user);
    }
    my $compare = List::Compare->new({
        lists => [ $self->{userrightscache}->{groups}, $rights ],
        unsorted    => 1,
    });
    my %add    = map { $_ => 1 } $compare->get_complement;
    my %remove = map { $_ => 1 } $compare->get_unique;
    delete $add{ $_ }    for qw(* user autoconfirmed);
    delete $remove{ $_ } for qw(* user autoconfirmed);

    my $hash = {
        action  => 'userrights',
        user    => $user,
        add     => join('|', keys %add),
        remove  => join('|', keys %remove),
        reason  => $summary,
        token   => $self->{userrightscache}->{token},
    };
    my $res = $self->{api}->api($hash);
    return $self->_handle_api_error() unless $res;

    my %new_usergroups = map { $_ => 1 } @{ $self->{userrightscache}->{groups} };
    delete $new_usergroups{ $_ } for @{ $res->{userrights}->{removed} };
    $new_usergroups{ $_ } = 1 for @{ $res->{userrights}->{added} };
    delete $self->{userrightscache};
    return keys %new_usergroups;
}


sub add_usergroups {
    my $self    = shift;
    my $user    = shift;
    my $rights  = shift;
    my $summary = shift;

    $user =~ s/^User://;

    unless (
        exists $self->{userrightscache}
        and exists $self->{userrightscache}->{user}
        and $self->{userrightscache}->{user} eq $user
    ) {
        $self->usergroups($user);
    }

    my $res = $self->{api}->api({
        action  => 'userrights',
        user    => $user,
        add     => @$rights,
        reason  => $summary,
        token   => $self->{userrightscache}->{token},
    });
    return $self->_handle_api_error() unless $res;

    delete $self->{userrightscache};
    return @{ $res->{userrights}->{added} };
}



sub remove_usergroups {
    my $self    = shift;
    my $user    = shift;
    my $rights  = shift;
    my $summary = shift;

    $user =~ s/^User://;

    unless (
        exists $self->{userrightscache}
        and exists $self->{userrightscache}->{user}
        and $self->{userrightscache}->{user} eq $user
    ) {
        $self->usergroups($user);
    }

    my $res = $self->{api}->api({
        action  => 'userrights',
        user    => $user,
        remove  => @$rights,
        reason  => $summary,
        token   => $self->{userrightscache}->{token},
    });
    return $self->_handle_api_error() unless $res;

    delete $self->{userrightscache};
    return @{ $res->{userrights}->{removed} };
}

1;

__END__