view release on metacpan or  search on metacpan

lib/App/RoboBot/Plugin/Bot/Autoreply.pm  view on Meta::CPAN

            $message->response->push(
                $reply->{'response'}->evaluate($check_message, {})
            );
        }
    }
}

sub autoreply_create {
    my ($self, $message, $command, $rpl, $name, $condition, $response) = @_;

    unless (defined $name && defined $condition && defined $response) {
        $message->response->raise('Must provide an autoreplier name, condition expression, and response expression.');
        return;
    }

    if (blessed($name) && $name->can('evaluate')) {
        $name = $name->evaluate($message, $rpl);

        if (ref($name)) {
            $message->response->raise('Autoreplier name expression must evaluate to a string.');
            return;
        }
    } else {
        $name = "$name";
    }

    if (ref($name) || $name !~ m{\w+}) {
        $message->response->raise('Must provide an autoreplier name.');
        return;
    }

    unless (blessed($condition) && $condition->can('evaluate')) {
        $message->response->raise('Must provide an expression for the autoreply condition.');
        return;
    }

    unless (blessed($response) && $response->can('evaluate')) {
        $message->response->raise('Must provide an expression for the autoreply response.');
        return;
    }

    $condition->quoted(0);
    $response->quoted(0);

    $self->log->debug(sprintf('Attempting to update autoreplier with name %s in %s on network %s.',
        $name, $message->channel->name, $message->network->name));

    my $res = $self->bot->config->db->do(q{
        update autoreply_autoreplies set ??? where channel_id = ? and name = ? returning *
    }, {
        condition  => $condition->flatten,
        response   => $response->flatten,
        created_by => $message->sender->id,
        created_at => 'now',
    }, $message->channel->id, $name);

    if ($res && $res->next) {
        $self->log->debug('Autoreplier update successful.');

        $message->response->push(sprintf('Autoreply %s has been updated.', $name));
    } else {
        $self->log->debug(sprintf('No existing autoreplier to update. Creating new record.'));

        $res = $self->bot->config->db->do(q{
            insert into autoreply_autoreplies ??? returning *
        }, {
            channel_id  => $message->channel->id,
            name        => lc($name),
            condition   => $condition->flatten,
            response    => $response->flatten,
            created_by  => $message->sender->id,
        });

        if ($res && $res->next) {
            $message->response->push(sprintf('Autoreply %s has been added.', $name));
        } else {
            $self->log->error(sprintf('Could not create autoreplier record: %s', $res->error));

            $message->response->raise('Could not create the autoresponse. Please check your arguments and try again.');
            return;
        }
    }

    $self->log->debug(sprintf('Caching new/updated autoreplier %s.', $name));

    $self->reply_cache->{$message->channel->id}{lc($name)} = {
        condition   => $condition,
        response    => $response,
    };

    return;
}

sub autoreply_list {
    my ($self, $message, $command, $rpl) = @_;

    unless ($message->has_channel) {
        $message->response->raise('Autoreplies may only be used in channels.');
        return;
    }

    my $res = $self->bot->config->db->do(q{
        select name from autoreply_autoreplies where channel_id = ? order by name asc
    }, $message->channel->id);

    my @replies;

    if ($res) {
        while ($res->next) {
            push(@replies, $res->[0]);
        }
    }

    if (@replies > 0) {
        return @replies;
    } else {
        $message->response->raise('There are no autoreplies configured for this channel. Use (autoreply) to create one.');
        return;
    }
}

sub autoreply_delete {
    my ($self, $message, $command, $rpl, $name) = @_;

    unless (defined $name && $name =~ m{\w+}) {
        $message->response->raise('Must provide the name of an autoreply to display.');
        return;
    }

    unless ($message->has_channel) {
        $message->response->raise('Autoreplies may only be used in channels.');
        return;
    }

    my $res = $self->bot->config->db->do(q{
        delete from autoreply_autoreplies where channel_id = ? and lower(name) = lower(?) returning *
    }, $message->channel->id, $name);

    if ($res && $res->next) {
        $message->response->push(sprintf('The autoreply %s has been deleted from this channel.', $name));
    } else {
        $message->response->raise('There was no autoreply named %s configured for this channel for me to delete.', $name);
    }