File Coverage

blib/lib/Bot/Cobalt/Plugin/Alarmclock.pm

Criterion	Covered	Total	%
statement	12	14	85.7
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	17	19	89.4

package Bot::Cobalt::Plugin::Alarmclock;
$Bot::Cobalt::Plugin::Alarmclock::VERSION = '0.021001';
use strictures 2;
use v5.10;

use File::Spec ();

use Bot::Cobalt;
use Bot::Cobalt::DB;
use Bot::Cobalt::Utils 'timestr_to_secs';

use Object::Pluggable::Constants ':ALL';


sub new {
  bless +{
    # $self->timers->{$timerid} = [ $context, $username ]
    _timers => +{},
    _db     => undef,
  }, shift
}

sub timers        { shift->{_timers} }
sub clear_timers  { shift->{_timers} = +{} }

sub _init_from_db {
  my ($self) = @_;
  my $db = $self->{_db};
  unless ($db->dbopen) {
    logger->error("dbopen failure for alarmclock db in _init_from_db");
    logger->error("persistent alarms may be broken!");
    return
  }
  my $count = 0;
  ID: for my $id ($db->dbkeys) {
    my $alarm = $db->get($id);
    unless ($alarm && ref $alarm eq 'HASH') {
      logger->warn(
        defined $alarm ?
            "Alarm '$id' not a HASH; alarmclock db may be broken!"
          : "Could not retrieve alarm '$id'; alarmclock db may be broken!"
      );
      next ID
    }
    my $expires_at = $alarm->{At};
    unless ($expires_at) {
      logger->warn("No 'At' expiry for timer id '$id', removing");
      $db->del($id);
      next ID
    }
    if ($expires_at <= time) {
      logger->debug("Expiring stale alarmclock '$id'");
      $db->del($id);
      next ID
    }
    $alarm->{Alias} = plugin_alias($self);
    my $secs = $expires_at - time;
    my $new_id = core->timer_set( $secs, $alarm );
    if ($new_id) {
      $self->timers->{$new_id} = [ $alarm->{Context}, $alarm->{User} ];
      $db->put($new_id => $alarm);
      $db->del($id);
      ++$count
    } else {
      logger->warn("Failed to readd alarmclock timer '$id'");
    }
  }
  $db->dbclose;
  $count
}

sub _delete_alarm {
  my ($self, $id) = @_;
  my $db = $self->{_db};
  unless ($db->dbopen) {
    logger->error("dbopen failure for alarmclock db in _delete_alarm");
    logger->error("persistent alarms may be broken!");
  }
  my $ret = $db->del($id);
  unless ($ret) {
    logger->warn("attempted to delete nonexistant alarm ID '$id'");
  }
  $db->dbclose;
  $ret
}


sub Cobalt_register {
  my ($self, $core) = splice @_, 0, 2;

  # FIXME config option for persistent alarms?
  my $dbpath = File::Spec->catfile( $core->var, 'alarmclock.db' );
  $self->{_db} = Bot::Cobalt::DB->new(
    file => $dbpath,
  );
  my $count = $self->_init_from_db;

  register( $self, SERVER => qw/
    public_cmd_alarmclock
    public_cmd_alarmdelete
    public_cmd_alarmdel
    public_cmd_alarmclear
    executed_timer
  / );

  logger->info("Loaded alarm clock ($count existing alarms loaded)");

  PLUGIN_EAT_NONE
}

sub Cobalt_unregister {
  my ($self, $core) = splice @_, 0, 2;
  logger->info("Unregistering core IRC plugin");
  core->timer_del_alias( core->get_plugin_alias($self) );
  $self->clear_timers;
  PLUGIN_EAT_NONE
}

sub Bot_deleted_timer { Bot_executed_timer(@_) }

sub Bot_executed_timer {
  my ($self, $core) = splice @_, 0, 2;
  my $timerid = ${$_[0]};

  return PLUGIN_EAT_NONE
    unless exists $self->timers->{$timerid};

  logger->debug("clearing timer state for $timerid")
    if core->debug > 1;

  delete $self->timers->{$timerid};
  $self->_delete_alarm($timerid);

  PLUGIN_EAT_NONE
}

sub Bot_public_cmd_alarmclear {
  my ($self, $core) = splice @_, 0, 2;
  my $msg = ${ $_[0] };

  my $context = $msg->context;
  my $nick    = $msg->src_nick;

  my $auth_usr = core->auth->username($context, $nick);
  return PLUGIN_EAT_NONE unless $auth_usr
    and core->auth->has_flag($context, $nick, 'SUPERUSER');

  my $target_ctxt = $msg->message_array->[0];

  logger->info(
    "Clearing all alarms"
    . ($target_ctxt ? " for context $target_ctxt" : "")
    . " per $nick ($auth_usr)"
  );

  my $count = 0;
  DELETE: for my $timerid (keys %{ $self->timers }) {
    if ($target_ctxt) {
      my $ctxt_set = $self->timers->{$timerid}->[0];
      next DELETE unless $target_ctxt eq $ctxt_set;
    }
    core->timer_del($timerid);
    delete $self->timers->{$timerid};
    $self->_delete_alarm($timerid);
    ++$count
  }

  broadcast( 'message', $context, $msg->channel,
    core->rpl( q{ALARMCLOCK_DELETED},
      nick    => $nick,
      timerid => (
        $target_ctxt ? "ALL [$target_ctxt] ($count)" : "ALL ($count)"
      ),
    )
  );

  PLUGIN_EAT_ALL
}

sub Bot_public_cmd_alarmdelete { Bot_public_cmd_alarmdel(@_) }

sub Bot_public_cmd_alarmdel {
  my ($self, $core) = splice @_, 0, 2;
  my $msg = ${$_[0]};

  my $context = $msg->context;
  my $nick    = $msg->src_nick;

  my $auth_usr = core->auth->username($context, $nick);
  return PLUGIN_EAT_NONE unless $auth_usr;

  my $timerid = $msg->message_array->[0];
  return PLUGIN_EAT_ALL unless $timerid;

  my $channel = $msg->channel;

  unless (exists $self->timers->{$timerid}) {
    broadcast( 'message', $context, $channel,
      core->rpl( q{ALARMCLOCK_NOSUCH},
        nick    => $nick,
        timerid => $timerid,
      )
    );

    return PLUGIN_EAT_ALL
  }

  my $thistimer = $self->timers->{$timerid};
  my ($ctxt_set, $ctxt_by) = @$thistimer;
  ## did this user set this timer?
  ## original user may've been undef if LevelRequired == 0
  unless ($ctxt_set eq $context && defined $ctxt_by && $auth_usr eq $ctxt_by) {
    my $auth_lev = core->auth->level($context, $nick);
    ## superusers can override:
    unless ($auth_lev == 9999) {
      broadcast( 'message', $context, $channel,
        core->rpl( q{ALARMCLOCK_NOTYOURS},
          nick    => $nick,
          timerid => $timerid,
        )
      );
      return PLUGIN_EAT_ALL
    }
  }

  core->timer_del($timerid);
  delete $self->timers->{$timerid};
  $self->_delete_alarm($timerid);

  broadcast( 'message', $context, $channel,
    core->rpl( q{ALARMCLOCK_DELETED},
      nick    => $nick,
      timerid => $timerid,
    )
  );

  PLUGIN_EAT_ALL
}


sub Bot_public_cmd_alarmclock {
  my ($self, $core) = splice @_, 0, 2;
  my $msg     = ${$_[0]};

  my $context = $msg->context;
  my $setter  = $msg->src_nick;

  my $cfg = plugin_cfg( $self );

  my $minlevel = $cfg->{LevelRequired} // 1;

  ## quietly do nothing for unauthorized users
  unless (core->auth->level($context, $setter) >= $minlevel) {
    logger->debug(
      "ignoring unauthorized alarmclock from '$setter' on '$context'"
    );
    return PLUGIN_EAT_NONE
  }

  ## undef if $minlevel == 0
  my $auth_usr = core->auth->username($context, $setter);

  ## This is the array of (format-stripped) args to the _public_cmd_
  my $args = $msg->message_array;
  ## -> f.ex.:  split ' ', !alarmclock 1h10m things and stuff
  my $timestr = shift @$args;
  ## the rest of this string is the alarm text:
  my $txtstr  = join ' ', @$args;

  $txtstr = "$setter: ALARMCLOCK: ".$txtstr ;

  ## set a timer
  my $secs = timestr_to_secs($timestr) || 1;
  my $channel = $msg->channel;

  my $alarm = +{
    Type    => 'msg',
    User    => $auth_usr,
    Context => $context,
    Target  => $channel,
    Text    => $txtstr,
    Alias   => plugin_alias($self),
    At      => time + $secs,
  };
  my $id = core->timer_set( $secs, $alarm );

  my $resp;
  if ($id) {
    $self->timers->{$id} = [ $context, $auth_usr ];
    $resp = core->rpl( q{ALARMCLOCK_SET},
        nick => $setter,
        secs => $secs,
        timerid => $id,
        timestr => $timestr,
    );
    my $db = $self->{_db};
    if ($db->dbopen) {
      $db->put($id => $alarm);
      $db->dbclose;
    } else {
      logger->error("dbopen failure for alarmclock db during add");
    }
  } else {
    $resp = core->rpl( q{RPL_TIMER_ERR} );
  }

  if ($resp) {
    broadcast( 'message', $context, $channel, $resp );
  }

  PLUGIN_EAT_ALL
}

1;
__END__