255 lines
8.9 KiB
Python
255 lines
8.9 KiB
Python
###
|
|
# Copyright (c) 2025, Stormux
|
|
#
|
|
# This plugin is licensed under the same terms as Limnoria itself.
|
|
###
|
|
|
|
import supybot.utils as utils
|
|
from supybot.commands import *
|
|
import supybot.plugins as plugins
|
|
import supybot.ircutils as ircutils
|
|
import supybot.callbacks as callbacks
|
|
import supybot.world as world
|
|
import supybot.schedule as schedule
|
|
import supybot.conf as conf
|
|
import supybot.ircmsgs as ircmsgs
|
|
import time
|
|
import re
|
|
|
|
class Greet(callbacks.Plugin):
|
|
"""
|
|
A plugin to greet users when they join a channel.
|
|
Features flood protection and timeout between greetings.
|
|
"""
|
|
|
|
def __init__(self, irc):
|
|
self.__parent = super(Greet, self)
|
|
self.__parent.__init__(irc)
|
|
|
|
# Dictionary to store last greeting times per user
|
|
self.lastGreetTime = {}
|
|
|
|
# Default cooldown between greetings for the same user (in seconds)
|
|
self.userCooldown = 300 # 5 minutes
|
|
|
|
# Debug mode
|
|
self.debugMode = False
|
|
|
|
def doJoin(self, irc, msg):
|
|
"""
|
|
Called when someone joins a channel.
|
|
"""
|
|
channel = msg.args[0]
|
|
nick = msg.nick
|
|
|
|
# Log event for debugging
|
|
if self.debugMode:
|
|
self._logDebug(irc, f"JOIN event detected: {nick} joined {channel}")
|
|
|
|
# Don't greet ourselves
|
|
if nick == irc.nick:
|
|
if self.debugMode:
|
|
self._logDebug(irc, f"Not greeting self (bot)")
|
|
return
|
|
|
|
# Check if greetings are enabled for this channel
|
|
if not self.registryValue('enabled', channel):
|
|
if self.debugMode:
|
|
self._logDebug(irc, f"Greetings disabled for {channel}")
|
|
return
|
|
|
|
# Get the greeting message for this channel
|
|
greeting = self.registryValue('message', channel)
|
|
if not greeting:
|
|
if self.debugMode:
|
|
self._logDebug(irc, f"No greeting message set for {channel}")
|
|
return
|
|
|
|
# Check if this user was greeted recently
|
|
userKey = f"{nick.lower()}@{channel}"
|
|
now = time.time()
|
|
if userKey in self.lastGreetTime:
|
|
lastTime = self.lastGreetTime[userKey]
|
|
if now - lastTime < self.userCooldown:
|
|
if self.debugMode:
|
|
self._logDebug(irc, f"User {nick} was greeted too recently")
|
|
return
|
|
|
|
# Get the timeout
|
|
timeout = self.registryValue('timeout', channel) or 3
|
|
|
|
if self.debugMode:
|
|
self._logDebug(irc, f"Will greet in {channel} after {timeout}s: {greeting}")
|
|
|
|
# Update last greet time for this user
|
|
self.lastGreetTime[userKey] = now
|
|
|
|
# Use a closure to capture the current values
|
|
def sendGreeting(channelToGreet=channel, greetingMsg=greeting):
|
|
if self.debugMode:
|
|
self._logDebug(irc, f"Sending greeting in {channelToGreet}: {greetingMsg}")
|
|
try:
|
|
# Make sure the channel is still valid when we send the message
|
|
if channelToGreet in irc.state.channels:
|
|
irc.queueMsg(ircmsgs.privmsg(channelToGreet, greetingMsg))
|
|
except Exception as e:
|
|
if self.debugMode:
|
|
self._logDebug(irc, f"Error sending greeting: {str(e)}")
|
|
|
|
# Schedule the greeting
|
|
schedule.addEvent(sendGreeting, time.time() + timeout)
|
|
|
|
def _logDebug(self, irc, message):
|
|
"""Send debug messages to the first available channel"""
|
|
try:
|
|
# Send to the owner via private message instead of to a channel
|
|
for owner in self.registryValue('owners') or []:
|
|
irc.queueMsg(ircmsgs.privmsg(owner, f"[GREET-DEBUG] {message}"))
|
|
return
|
|
|
|
# Fallback: send to the first available channel
|
|
for channel in list(irc.state.channels):
|
|
try:
|
|
irc.queueMsg(ircmsgs.privmsg(channel, f"[GREET-DEBUG] {message}"))
|
|
break
|
|
except:
|
|
continue
|
|
except Exception as e:
|
|
# Last resort, log to Supybot's logs
|
|
self.log.error(f"Debug logging error: {str(e)}")
|
|
|
|
@wrap(['channel'])
|
|
def greettest(self, irc, msg, args, channel):
|
|
"""[<channel>]
|
|
|
|
Test the greeting by sending it immediately.
|
|
"""
|
|
greeting = self.registryValue('message', channel)
|
|
if greeting:
|
|
irc.queueMsg(ircmsgs.privmsg(channel, greeting))
|
|
irc.replySuccess("Greeting test sent")
|
|
else:
|
|
irc.error("No greeting message is set for this channel")
|
|
|
|
@wrap(['owner', 'channel'])
|
|
def greettrigger(self, irc, msg, args, channel):
|
|
"""[<channel>]
|
|
|
|
Simulates a join event with timeout (owner only).
|
|
"""
|
|
greeting = self.registryValue('message', channel)
|
|
if not greeting:
|
|
irc.error(f"No greeting message is set for {channel}")
|
|
return
|
|
|
|
# Get the timeout
|
|
timeout = self.registryValue('timeout', channel) or 3
|
|
|
|
irc.replySuccess(f"Simulating join event with {timeout}s delay")
|
|
|
|
# Schedule the greeting
|
|
def sendGreeting():
|
|
irc.queueMsg(ircmsgs.privmsg(channel, greeting))
|
|
|
|
schedule.addEvent(sendGreeting, time.time() + timeout)
|
|
|
|
@wrap(['owner', 'boolean'])
|
|
def greetdebug(self, irc, msg, args, enable):
|
|
"""<on|off>
|
|
|
|
Enables or disables debug mode (owner only).
|
|
"""
|
|
self.debugMode = enable
|
|
if enable:
|
|
irc.replySuccess("Debug mode enabled")
|
|
else:
|
|
irc.replySuccess("Debug mode disabled")
|
|
|
|
@wrap(['channel'])
|
|
def greeton(self, irc, msg, args, channel):
|
|
"""[<channel>]
|
|
|
|
Enables greetings for a channel.
|
|
"""
|
|
self.setRegistryValue('enabled', True, channel)
|
|
greeting = self.registryValue('message', channel)
|
|
if greeting:
|
|
irc.replySuccess(f"Greetings enabled for {channel}. Current greeting: \"{greeting}\"")
|
|
else:
|
|
irc.error(f"Greetings enabled for {channel}, but no greeting message is set.")
|
|
|
|
@wrap(['channel'])
|
|
def greetoff(self, irc, msg, args, channel):
|
|
"""[<channel>]
|
|
|
|
Disables greetings for a channel.
|
|
"""
|
|
self.setRegistryValue('enabled', False, channel)
|
|
irc.replySuccess(f"Greetings disabled for {channel}.")
|
|
|
|
@wrap(['channel'])
|
|
def greetclear(self, irc, msg, args, channel):
|
|
"""[<channel>]
|
|
|
|
Removes the greeting message for a channel.
|
|
"""
|
|
self.setRegistryValue('message', '', channel)
|
|
self.setRegistryValue('enabled', False, channel)
|
|
irc.replySuccess(f"Greeting message cleared and disabled for {channel}.")
|
|
|
|
@wrap(['channel'])
|
|
def greetstatus(self, irc, msg, args, channel):
|
|
"""[<channel>]
|
|
|
|
Shows the current greeting status and message for a channel.
|
|
"""
|
|
enabled = self.registryValue('enabled', channel)
|
|
message = self.registryValue('message', channel)
|
|
timeout = self.registryValue('timeout', channel) or 3
|
|
|
|
if enabled and message:
|
|
irc.reply(f"Greetings are enabled for {channel}. Timeout: {timeout} seconds. Message: \"{message}\"")
|
|
elif enabled and not message:
|
|
irc.reply(f"Greetings are enabled for {channel}, but no message is set.")
|
|
else:
|
|
irc.reply(f"Greetings are disabled for {channel}. Message: \"{message or 'None'}\"")
|
|
|
|
@wrap(['channel', 'positiveInt'])
|
|
def greettimeout(self, irc, msg, args, channel, seconds):
|
|
"""[<channel>] <seconds>
|
|
|
|
Sets the timeout in seconds between joins before sending a greeting.
|
|
Default is 3 seconds.
|
|
"""
|
|
self.setRegistryValue('timeout', seconds, channel)
|
|
irc.replySuccess(f"Greeting timeout for {channel} set to {seconds} seconds.")
|
|
|
|
@wrap(['channel', 'text'])
|
|
def greet(self, irc, msg, args, channel, text):
|
|
"""[<channel>] <message>
|
|
|
|
Sets the greeting message for a channel.
|
|
The greeting will be sent when users join the channel, with flood
|
|
protection.
|
|
|
|
To manage greetings, use the other commands:
|
|
greeton - Enables greetings for the channel
|
|
greetoff - Disables greetings for the channel
|
|
greetclear - Removes the greeting message for the channel
|
|
greetdebug on|off - Enables/disables debug mode (owner only)
|
|
greettest - Immediately sends the greeting to test the message
|
|
greettrigger - Simulates a join event with timeout (owner only)
|
|
greetstatus - Shows current status and message
|
|
greettimeout <seconds> - Sets delay before greeting
|
|
|
|
Examples:
|
|
greet #channel Welcome to our channel!
|
|
"""
|
|
self.setRegistryValue('message', text, channel)
|
|
self.setRegistryValue('enabled', True, channel)
|
|
irc.replySuccess(f"Greeting message for {channel} set to: \"{text}\"")
|
|
|
|
Class = Greet
|
|
|
|
# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
|