2003-03-27 07:28:13 +01:00
|
|
|
#!/usr/bin/env python
|
|
|
|
|
|
|
|
###
|
|
|
|
# Copyright (c) 2002, Jeremiah Fincher
|
|
|
|
# All rights reserved.
|
|
|
|
#
|
|
|
|
# Redistribution and use in source and binary forms, with or without
|
|
|
|
# modification, are permitted provided that the following conditions are met:
|
|
|
|
#
|
|
|
|
# * Redistributions of source code must retain the above copyright notice,
|
|
|
|
# this list of conditions, and the following disclaimer.
|
|
|
|
# * Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
# this list of conditions, and the following disclaimer in the
|
|
|
|
# documentation and/or other materials provided with the distribution.
|
|
|
|
# * Neither the name of the author of this software nor the name of
|
|
|
|
# contributors to this software may be used to endorse or promote products
|
|
|
|
# derived from this software without specific prior written consent.
|
|
|
|
#
|
|
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
|
|
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
###
|
|
|
|
|
|
|
|
"""
|
2003-09-03 11:50:04 +02:00
|
|
|
Basic channel management commands. Many of these commands require their caller
|
|
|
|
to have the <channel>.op capability. This plugin is loaded by default.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
|
2003-11-25 18:33:58 +01:00
|
|
|
__revision__ = "$Id$"
|
|
|
|
|
|
|
|
import fix
|
|
|
|
|
2003-03-27 07:28:13 +01:00
|
|
|
import time
|
2003-11-15 05:37:04 +01:00
|
|
|
from itertools import imap
|
2003-03-27 07:28:13 +01:00
|
|
|
|
|
|
|
import conf
|
|
|
|
import ircdb
|
2003-11-05 18:22:38 +01:00
|
|
|
import utils
|
2003-03-27 07:28:13 +01:00
|
|
|
import ircmsgs
|
|
|
|
import schedule
|
|
|
|
import ircutils
|
|
|
|
import privmsgs
|
|
|
|
import callbacks
|
|
|
|
|
2003-10-21 08:03:57 +02:00
|
|
|
class Channel(callbacks.Privmsg):
|
2003-09-29 07:01:41 +02:00
|
|
|
def op(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>]
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will give you ops.
|
|
|
|
<channel> is only necessary if the message isn't sent in the channel
|
|
|
|
itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
2003-09-29 07:01:41 +02:00
|
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
|
|
irc.queueMsg(ircmsgs.op(channel, msg.nick))
|
2003-03-27 07:28:13 +01:00
|
|
|
else:
|
2003-09-29 07:01:41 +02:00
|
|
|
irc.error(msg, 'How can I op you? I\'m not opped!')
|
|
|
|
op = privmsgs.checkChannelCapability(op, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-09-29 07:01:41 +02:00
|
|
|
def halfop(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>]
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.halfop capability, this will give you halfops.
|
|
|
|
<channel> is only necessary if the message isn't sent in the channel
|
|
|
|
itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
2003-09-29 07:01:41 +02:00
|
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
|
|
irc.queueMsg(ircmsgs.halfop(channel, msg.nick))
|
2003-03-27 07:28:13 +01:00
|
|
|
else:
|
2003-09-29 07:01:41 +02:00
|
|
|
irc.error(msg, 'How can I halfop you? I\'m not opped!')
|
|
|
|
halfop = privmsgs.checkChannelCapability(halfop, 'halfop')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-09-29 07:01:41 +02:00
|
|
|
def voice(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>]
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.voice capability, this will give you voice.
|
|
|
|
<channel> is only necessary if the message isn't sent in the channel
|
|
|
|
itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
2003-09-29 07:01:41 +02:00
|
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
|
|
irc.queueMsg(ircmsgs.voice(channel, msg.nick))
|
2003-03-27 07:28:13 +01:00
|
|
|
else:
|
2003-09-29 07:01:41 +02:00
|
|
|
irc.error(msg, 'How can I voice you? I\'m not opped!')
|
|
|
|
voice = privmsgs.checkChannelCapability(voice, 'voice')
|
2003-12-03 21:27:42 +01:00
|
|
|
|
|
|
|
def deop(self, irc, msg, args, channel):
|
2003-12-04 17:27:03 +01:00
|
|
|
"""[<channel>] [<nick> ...]
|
2003-12-03 21:27:42 +01:00
|
|
|
|
|
|
|
If you have the #channel.op capability, this will remove operator
|
2003-12-04 17:27:03 +01:00
|
|
|
privileges from all the nicks given. If no nicks are given, removes
|
|
|
|
operator privileges from the person sending the message.
|
2003-12-03 21:27:42 +01:00
|
|
|
"""
|
2003-12-03 21:49:51 +01:00
|
|
|
if not args:
|
2003-12-04 17:27:03 +01:00
|
|
|
args.append(msg.nick)
|
2003-12-03 21:27:42 +01:00
|
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
|
|
irc.queueMsg(ircmsgs.deops(channel, args))
|
|
|
|
else:
|
|
|
|
irc.error(msg, 'How can I deop someone? I\'m not opped!')
|
|
|
|
deop = privmsgs.checkChannelCapability(deop, 'op')
|
|
|
|
|
|
|
|
def dehalfop(self, irc, msg, args, channel):
|
2003-12-04 17:27:03 +01:00
|
|
|
"""[<channel>] [<nick> ...]
|
2003-12-03 21:27:42 +01:00
|
|
|
|
|
|
|
If you have the #channel.op capability, this will remove half-operator
|
2003-12-04 17:27:03 +01:00
|
|
|
privileges from all the nicks given. If no nicks are given, removes
|
|
|
|
half-operator privileges from the person sending the message.
|
2003-12-03 21:27:42 +01:00
|
|
|
"""
|
2003-12-03 21:49:51 +01:00
|
|
|
if not args:
|
2003-12-04 17:27:03 +01:00
|
|
|
args.append(msg.nick)
|
2003-12-03 21:27:42 +01:00
|
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
|
|
irc.queueMsg(ircmsgs.dehalfops(channel, args))
|
|
|
|
else:
|
2003-12-03 21:52:05 +01:00
|
|
|
irc.error(msg, 'How can I dehalfop someone? I\'m not opped!')
|
2003-12-03 21:27:42 +01:00
|
|
|
dehalfop = privmsgs.checkChannelCapability(dehalfop, 'op')
|
|
|
|
|
|
|
|
def devoice(self, irc, msg, args, channel):
|
2003-12-04 17:27:03 +01:00
|
|
|
"""[<channel>] [<nick> ...]
|
2003-12-03 21:27:42 +01:00
|
|
|
|
|
|
|
If you have the #channel.op capability, this will remove voice from all
|
2003-12-04 17:27:03 +01:00
|
|
|
the nicks given. If no nicks are given, removes voice from the person
|
|
|
|
sending the message.
|
2003-12-03 21:27:42 +01:00
|
|
|
"""
|
2003-12-03 21:49:51 +01:00
|
|
|
if not args:
|
2003-12-04 17:27:03 +01:00
|
|
|
args.append(msg.nick)
|
2003-12-03 21:27:42 +01:00
|
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
|
|
irc.queueMsg(ircmsgs.devoices(channel, args))
|
|
|
|
else:
|
2003-12-03 21:52:05 +01:00
|
|
|
irc.error(msg, 'How can I devoice someone? I\'m not opped!')
|
2003-12-03 21:27:42 +01:00
|
|
|
devoice = privmsgs.checkChannelCapability(devoice, 'op')
|
2003-09-29 07:01:41 +02:00
|
|
|
|
|
|
|
def cycle(self, irc, msg, args, channel):
|
2003-10-13 05:58:37 +02:00
|
|
|
"""[<channel>] [<key>]
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will cause the bot to
|
|
|
|
"cycle", or PART and then JOIN the channel. If <key> is given, join
|
|
|
|
the channel using that key. <channel> is only necessary if the message
|
|
|
|
isn't sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
2003-11-11 14:20:06 +01:00
|
|
|
key = privmsgs.getArgs(args, required=0, optional=1)
|
2003-10-13 05:58:37 +02:00
|
|
|
if not key:
|
|
|
|
key = None
|
2003-09-29 07:01:41 +02:00
|
|
|
irc.queueMsg(ircmsgs.part(channel))
|
2003-10-13 05:58:37 +02:00
|
|
|
irc.queueMsg(ircmsgs.join(channel, key))
|
2003-09-29 07:01:41 +02:00
|
|
|
cycle = privmsgs.checkChannelCapability(cycle, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-12-03 21:49:51 +01:00
|
|
|
def kick(self, irc, msg, args, channel):
|
|
|
|
"""[<channel>] <nick> [<reason>]
|
|
|
|
|
|
|
|
Kicks <nick> from <channel> for <reason>. If <reason> isn't given,
|
|
|
|
uses the nick of the person making the command as the reason.
|
|
|
|
<channel> is only necessary if the message isn't sent in the channel
|
|
|
|
itself.
|
|
|
|
"""
|
2003-12-03 21:52:05 +01:00
|
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
|
|
(nick, reason) = privmsgs.getArgs(args, optional=1)
|
|
|
|
if not reason:
|
|
|
|
reason = msg.nick
|
|
|
|
irc.queueMsg(ircmsgs.kick(channel, nick, reason))
|
|
|
|
else:
|
|
|
|
irc.error(msg, 'How can I kick someone? I\'m not opped!')
|
2003-12-03 21:49:51 +01:00
|
|
|
kick = privmsgs.checkChannelCapability(kick, 'op')
|
|
|
|
|
2003-03-27 07:28:13 +01:00
|
|
|
def kban(self, irc, msg, args):
|
|
|
|
"""[<channel>] <nick> [<number of seconds to ban>]
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will kickban <nick> for
|
|
|
|
as many seconds as you specify, or else (if you specify 0 seconds or
|
|
|
|
don't specify a number of seconds) it will ban the person indefinitely.
|
|
|
|
<channel> is only necessary if the message isn't sent in the channel
|
|
|
|
itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
channel = privmsgs.getChannel(msg, args)
|
|
|
|
(bannedNick, length) = privmsgs.getArgs(args, optional=1)
|
2003-12-04 09:12:09 +01:00
|
|
|
# Check that they're not trying to make us kickban ourself.
|
2003-11-13 20:35:24 +01:00
|
|
|
if bannedNick == irc.nick:
|
2003-12-04 09:12:09 +01:00
|
|
|
self.log.warning('%r tried to make me kban myself.', msg.prefix)
|
2003-11-13 20:35:24 +01:00
|
|
|
irc.error(msg, 'I cowardly refuse to kickban myself.')
|
|
|
|
return
|
2003-03-27 07:28:13 +01:00
|
|
|
length = int(length or 0)
|
2003-11-13 20:01:40 +01:00
|
|
|
try:
|
|
|
|
bannedHostmask = irc.state.nickToHostmask(bannedNick)
|
|
|
|
except KeyError:
|
|
|
|
irc.error(msg, 'I haven\'t seen %s.' % bannedNick)
|
|
|
|
return
|
2003-03-27 07:28:13 +01:00
|
|
|
capability = ircdb.makeChannelCapability(channel, 'op')
|
|
|
|
banmask = ircutils.banmask(bannedHostmask)
|
2003-12-04 09:12:09 +01:00
|
|
|
# Check (again) that they're not trying to make us kickban ourself.
|
2003-11-13 20:35:24 +01:00
|
|
|
if ircutils.hostmaskPatternEqual(banmask, irc.prefix):
|
2003-12-04 09:12:09 +01:00
|
|
|
if ircutils.hostmaskPatternEqual(banmask, irc.prefix):
|
|
|
|
self.log.warning('%r tried to make me kban myself.',msg.prefix)
|
|
|
|
irc.error(msg, 'I cowardly refuse to ban myself.')
|
|
|
|
return
|
2003-09-25 09:52:03 +02:00
|
|
|
else:
|
2003-12-04 09:12:09 +01:00
|
|
|
banmask = bannedHostmask
|
|
|
|
# Check that we have ops.
|
|
|
|
if irc.nick not in irc.state.channels[channel].ops:
|
|
|
|
irc.error(msg, 'How can I kick or ban someone? I\'m not opped.')
|
|
|
|
return
|
|
|
|
# Now, let's actually get to it. Check to make sure they have
|
|
|
|
# #channel.op and the bannee doesn't have #channel.op; or that the
|
|
|
|
# bannee and the banner are both the same person.
|
|
|
|
def doBan():
|
|
|
|
irc.queueMsg(ircmsgs.ban(channel, banmask))
|
|
|
|
irc.queueMsg(ircmsgs.kick(channel, bannedNick, msg.nick))
|
|
|
|
if length > 0:
|
|
|
|
def f():
|
|
|
|
irc.queueMsg(ircmsgs.unban(channel, banmask))
|
|
|
|
schedule.addEvent(f, time.time() + length)
|
|
|
|
if bannedNick == msg.nick:
|
|
|
|
doBan()
|
|
|
|
elif ircdb.checkCapability(msg.prefix, capability):
|
|
|
|
if ircdb.checkCapability(bannedHostmask, capability):
|
|
|
|
self.log.warning('%r tried to ban %r, but both have %s',
|
|
|
|
msg.prefix, bannedHostmask, capability)
|
|
|
|
irc.error(msg, '%s has %s too, you can\'t ban him/her/it.' %
|
|
|
|
bannedNick, capability)
|
|
|
|
else:
|
|
|
|
doBan()
|
2003-03-27 07:28:13 +01:00
|
|
|
else:
|
2003-12-04 09:12:09 +01:00
|
|
|
self.log.warning('%r attempted kban without %s',
|
|
|
|
msg.prefix, capability)
|
2003-03-27 07:28:13 +01:00
|
|
|
irc.error(msg, conf.replyNoCapability % capability)
|
|
|
|
|
2003-10-15 06:46:19 +02:00
|
|
|
def unban(self, irc, msg, args, channel):
|
|
|
|
"""[<channel>] <hostmask>
|
|
|
|
|
|
|
|
Unbans <hostmask> on <channel>. Especially useful for unbanning
|
|
|
|
yourself when you get unexpectedly (or accidentally) banned from
|
|
|
|
the channel. <channel> is only necessary if the message isn't sent
|
|
|
|
in the channel itself.
|
|
|
|
"""
|
|
|
|
hostmask = privmsgs.getArgs(args)
|
|
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
|
|
irc.queueMsg(ircmsgs.unban(channel, hostmask))
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
|
|
|
else:
|
|
|
|
irc.error(msg, 'How can I unban someone? I\'m not opped.')
|
|
|
|
unban = privmsgs.checkChannelCapability(unban, 'op')
|
|
|
|
|
2003-09-29 07:01:41 +02:00
|
|
|
def lobotomize(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>]
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will "lobotomize" the
|
|
|
|
bot, making it silent and unanswering to all requests made in the
|
|
|
|
channel. <channel> is only necessary if the message isn't sent in the
|
|
|
|
channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
2003-09-29 07:01:41 +02:00
|
|
|
ircdb.channels.getChannel(channel).lobotomized = True
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
|
|
|
lobotomize = privmsgs.checkChannelCapability(lobotomize, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-09-29 07:01:41 +02:00
|
|
|
def unlobotomize(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>]
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will unlobotomize the bot,
|
|
|
|
making it respond to requests made in the channel again.
|
|
|
|
<channel> is only necessary if the message isn't sent in the channel
|
|
|
|
itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
2003-09-29 07:01:41 +02:00
|
|
|
ircdb.channels.getChannel(channel).lobotomized = False
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
|
|
|
unlobotomize = privmsgs.checkChannelCapability(unlobotomize, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-09-29 07:01:41 +02:00
|
|
|
def permban(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>] <nick|hostmask>
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will effect a permanent
|
|
|
|
(persistent) ban on the given <hostmask> (or the current hostmask
|
|
|
|
associated with <nick>. <channel> is only necessary if the message
|
|
|
|
isn't sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
arg = privmsgs.getArgs(args)
|
|
|
|
if ircutils.isNick(arg):
|
|
|
|
banmask = ircutils.banmask(irc.state.nickToHostmask(arg))
|
2003-09-29 07:01:41 +02:00
|
|
|
elif ircutils.isUserHostmask(arg):
|
2003-03-27 07:28:13 +01:00
|
|
|
banmask = arg
|
|
|
|
else:
|
2003-09-29 07:01:41 +02:00
|
|
|
irc.error(msg, 'That\'s not a valid nick or hostmask.')
|
|
|
|
return
|
|
|
|
c = ircdb.channels.getChannel(channel)
|
|
|
|
c.addBan(banmask)
|
|
|
|
ircdb.channels.setChannel(channel, c)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
|
|
|
permban = privmsgs.checkChannelCapability(permban, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-09-29 07:01:41 +02:00
|
|
|
def unpermban(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>] <hostmask>
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will remove the permanent
|
|
|
|
ban on <hostmask>. <channel> is only necessary if the message isn't
|
|
|
|
sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
banmask = privmsgs.getArgs(args)
|
2003-09-29 07:01:41 +02:00
|
|
|
c = ircdb.channels.getChannel(channel)
|
|
|
|
c.removeBan(banmask)
|
|
|
|
ircdb.channels.setChannel(channel, c)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
|
|
|
unpermban = privmsgs.checkChannelCapability(unpermban, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def ignore(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>] <nick|hostmask>
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will set a permanent
|
|
|
|
(persistent) ignore on <hostmask> or the hostmask currently associated
|
|
|
|
with <nick>. <channel> is only necessary if the message isn't sent in
|
|
|
|
the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
arg = privmsgs.getArgs(args)
|
|
|
|
if ircutils.isNick(arg):
|
|
|
|
banmask = ircutils.banmask(irc.state.nickToHostmask(arg))
|
2003-09-29 07:01:41 +02:00
|
|
|
elif ircutils.isUserHostmask(arg):
|
2003-03-27 07:28:13 +01:00
|
|
|
banmask = arg
|
|
|
|
else:
|
2003-09-29 07:01:41 +02:00
|
|
|
irc.error(msg, 'That\'s not a valid nick or hostmask.')
|
|
|
|
return
|
|
|
|
c = ircdb.channels.getChannel(channel)
|
|
|
|
c.addIgnore(banmask)
|
|
|
|
ircdb.channels.setChannel(channel, c)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
2003-11-09 15:11:15 +01:00
|
|
|
ignore = privmsgs.checkChannelCapability(ignore, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def unignore(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>] <hostmask>
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will remove the permanent
|
|
|
|
ignore on <hostmask> in the channel. <channel> is only necessary if the
|
|
|
|
message isn't sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
banmask = privmsgs.getArgs(args)
|
2003-09-29 07:01:41 +02:00
|
|
|
c = ircdb.channels.getChannel(channel)
|
|
|
|
c.removeIgnore(banmask)
|
|
|
|
ircdb.channels.setChannel(channel, c)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
2003-11-09 15:11:15 +01:00
|
|
|
unignore = privmsgs.checkChannelCapability(unignore, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def ignores(self, irc, msg, args, channel):
|
2003-11-05 18:22:38 +01:00
|
|
|
"""[<channel>]
|
|
|
|
|
|
|
|
Lists the hostmasks that the bot is ignoring on the given channel.
|
2003-11-19 09:13:19 +01:00
|
|
|
<channel> is only necessary if the message isn't sent in the channel
|
|
|
|
itself.
|
2003-11-05 18:22:38 +01:00
|
|
|
"""
|
2003-11-11 14:20:06 +01:00
|
|
|
channelarg = privmsgs.getArgs(args, required=0, optional=1)
|
2003-11-05 18:22:38 +01:00
|
|
|
channel = channelarg or channel
|
|
|
|
c = ircdb.channels.getChannel(channel)
|
|
|
|
if len(c.ignores) == 0:
|
2003-12-04 08:18:10 +01:00
|
|
|
s = 'I\'m not currently ignoring any hostmasks in %r' % channel
|
|
|
|
irc.reply(msg, s)
|
|
|
|
else:
|
|
|
|
L = c.ignores[:]
|
|
|
|
L.sort()
|
|
|
|
irc.reply(msg, utils.commaAndify(imap(repr, L)))
|
2003-11-09 15:11:15 +01:00
|
|
|
ignores = privmsgs.checkChannelCapability(ignores, 'op')
|
2003-11-05 18:22:38 +01:00
|
|
|
|
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def addcapability(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>] <name|hostmask> <capability>
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will give the user
|
|
|
|
currently identified as <name> (or the user to whom <hostmask> maps)
|
|
|
|
the capability <capability> in the channel. <channel> is only necessary
|
|
|
|
if the message isn't sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
(name, capability) = privmsgs.getArgs(args, 2)
|
|
|
|
capability = ircdb.makeChannelCapability(channel, capability)
|
2003-09-29 07:01:41 +02:00
|
|
|
try:
|
|
|
|
id = ircdb.users.getUserId(name)
|
|
|
|
user = ircdb.users.getUser(id)
|
|
|
|
user.addCapability(capability)
|
|
|
|
ircdb.users.setUser(id, user)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
|
|
|
except KeyError:
|
|
|
|
irc.error(msg, conf.replyNoUser)
|
2003-11-09 15:11:15 +01:00
|
|
|
addcapability = privmsgs.checkChannelCapability(addcapability,'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def removecapability(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>] <name|hostmask> <capability>
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will take from the user
|
|
|
|
currently identified as <name> (or the user to whom <hostmask> maps)
|
|
|
|
the capability <capability> in the channel. <channel> is only necessary
|
|
|
|
if the message isn't sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
(name, capability) = privmsgs.getArgs(args, 2)
|
|
|
|
capability = ircdb.makeChannelCapability(channel, capability)
|
2003-09-29 07:01:41 +02:00
|
|
|
try:
|
2003-12-04 09:12:09 +01:00
|
|
|
id = ircdb.users.getUserId(name)
|
2003-09-29 07:01:41 +02:00
|
|
|
user = ircdb.users.getUser(id)
|
|
|
|
user.removeCapability(capability)
|
|
|
|
ircdb.users.setUser(id, user)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
|
|
|
except KeyError:
|
|
|
|
irc.error(msg, conf.replyNoUser)
|
2003-11-09 15:11:15 +01:00
|
|
|
removecapability = privmsgs.checkChannelCapability(removecapability, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def setdefaultcapability(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<channel>] <default response to unknown capabilities> <True|False>
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will set the default
|
|
|
|
response to non-power-related (that is, not {op, halfop, voice}
|
|
|
|
capabilities to be the value you give. <channel> is only necessary if
|
|
|
|
the message isn't sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
|
|
|
v = privmsgs.getArgs(args)
|
2003-09-29 07:01:41 +02:00
|
|
|
v = v.capitalize()
|
2003-10-04 14:57:44 +02:00
|
|
|
c = ircdb.channels.getChannel(channel)
|
2003-09-29 07:01:41 +02:00
|
|
|
if v == 'True':
|
|
|
|
c.setDefaultCapability(True)
|
|
|
|
elif v == 'False':
|
|
|
|
c.setDefaultCapability(False)
|
2003-03-27 07:28:13 +01:00
|
|
|
else:
|
2003-09-29 07:01:41 +02:00
|
|
|
s = 'The default value must be either True or False.'
|
|
|
|
irc.error(msg, s)
|
|
|
|
return
|
|
|
|
ircdb.channels.setChannel(channel, c)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
2003-11-09 15:11:15 +01:00
|
|
|
setdefaultcapability = \
|
|
|
|
privmsgs.checkChannelCapability(setdefaultcapability, 'op')
|
2003-09-29 07:01:41 +02:00
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def setcapability(self, irc, msg, args, channel):
|
2003-04-02 13:08:34 +02:00
|
|
|
"""[<channel>] <capability>
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will add the channel
|
|
|
|
capability <capability> for all users in the channel. <channel> is
|
|
|
|
only necessary if the message isn't sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
2003-09-29 07:01:41 +02:00
|
|
|
capability = privmsgs.getArgs(args)
|
|
|
|
c = ircdb.channels.getChannel(channel)
|
|
|
|
c.addCapability(capability)
|
|
|
|
ircdb.channels.setChannel(channel, c)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
2003-11-09 15:11:15 +01:00
|
|
|
setcapability = privmsgs.checkChannelCapability(setcapability, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def unsetcapability(self, irc, msg, args, channel):
|
2003-03-27 07:28:13 +01:00
|
|
|
"""[<chanel>] <capability>
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
If you have the #channel.op capability, this will unset the channel
|
|
|
|
capability <capability> so each user's specific capability or the
|
|
|
|
channel default capability will take precedence. <channel> is only
|
|
|
|
necessary if the message isn't sent in the channel itself.
|
2003-03-27 07:28:13 +01:00
|
|
|
"""
|
2003-09-29 07:01:41 +02:00
|
|
|
capability = privmsgs.getArgs(args)
|
|
|
|
c = ircdb.channels.getChannel(channel)
|
|
|
|
c.removeCapability(capability)
|
|
|
|
ircdb.channels.setChannel(channel, c)
|
|
|
|
irc.reply(msg, conf.replySuccess)
|
2003-11-09 15:11:15 +01:00
|
|
|
unsetcapability = privmsgs.checkChannelCapability(unsetcapability, 'op')
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-11-09 15:11:15 +01:00
|
|
|
def capabilities(self, irc, msg, args):
|
2003-04-02 13:08:34 +02:00
|
|
|
"""[<channel>]
|
|
|
|
|
2003-11-19 09:13:19 +01:00
|
|
|
Returns the capabilities present on the <channel>. <channel> is only
|
|
|
|
necessary if the message isn't sent in the channel itself.
|
2003-04-02 13:08:34 +02:00
|
|
|
"""
|
|
|
|
channel = privmsgs.getChannel(msg, args)
|
|
|
|
c = ircdb.channels.getChannel(channel)
|
2003-12-04 08:15:14 +01:00
|
|
|
L = c.capabilities[:]
|
|
|
|
L.sort()
|
|
|
|
irc.reply(msg, '[%s]' % ', '.join(L))
|
2003-04-02 13:08:34 +02:00
|
|
|
|
2003-12-03 02:28:31 +01:00
|
|
|
def lobotomies(self, irc, msg, args):
|
|
|
|
"""takes no arguments
|
|
|
|
|
|
|
|
Returns the channels in which this bot is lobotomized.
|
|
|
|
"""
|
|
|
|
L = []
|
|
|
|
for (channel, c) in ircdb.channels.iteritems():
|
|
|
|
if c.lobotomized:
|
|
|
|
L.append(channel)
|
|
|
|
if L:
|
2003-12-04 08:18:10 +01:00
|
|
|
L.sort()
|
2003-12-03 02:28:31 +01:00
|
|
|
s = 'I\'m currently lobotomized in %s.' % utils.commaAndify(L)
|
|
|
|
irc.reply(msg, s)
|
|
|
|
else:
|
|
|
|
irc.reply(msg, 'I\'m not currently lobotomized in any channels.')
|
|
|
|
|
2003-03-27 07:28:13 +01:00
|
|
|
|
2003-10-21 08:03:57 +02:00
|
|
|
Class = Channel
|
2003-03-27 07:28:13 +01:00
|
|
|
|
|
|
|
# vim:set shiftwidth=4 tabstop=8 expandtab textwidth=78:
|