597 lines
30 KiB
Python
597 lines
30 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# from slixmpp import JID
|
|
from kaikout.database import Toml
|
|
from kaikout.log import Logger
|
|
from kaikout.utilities import Documentation
|
|
from kaikout.xmpp.commands import XmppCommands
|
|
from kaikout.xmpp.message import XmppMessage
|
|
from kaikout.xmpp.muc import XmppMuc
|
|
from kaikout.xmpp.status import XmppStatus
|
|
from kaikout.xmpp.utilities import XmppUtilities
|
|
import time
|
|
|
|
|
|
logger = Logger(__name__)
|
|
|
|
|
|
# for task in main_task:
|
|
# task.cancel()
|
|
|
|
# Deprecated in favour of event "presence_available"
|
|
# if not main_task:
|
|
# await select_file()
|
|
|
|
|
|
class XmppChat:
|
|
|
|
|
|
async def process_message(self, message):
|
|
"""
|
|
Process incoming message stanzas. Be aware that this also
|
|
includes MUC messages and error messages. It is usually
|
|
a good practice to check the messages's type before
|
|
processing or sending replies.
|
|
|
|
Parameters
|
|
----------
|
|
message : str
|
|
The received message stanza. See the documentation
|
|
for stanza objects and the Message stanza to see
|
|
how it may be used.
|
|
"""
|
|
# jid_bare = message['from'].bare
|
|
# jid_full = str(message['from'])
|
|
|
|
# Process commands.
|
|
message_type = message['type']
|
|
message_body = message['body']
|
|
jid = message['from']
|
|
jid_bare = jid.bare
|
|
if message_type == 'groupchat':
|
|
alias = message['mucnick']
|
|
room = message['mucroom']
|
|
alias_of_kaikout = XmppUtilities.get_self_alias(self, jid_bare)
|
|
if (message['mucnick'] == self.alias or
|
|
not XmppUtilities.is_moderator(self, room, alias) or
|
|
not message_body.startswith(alias_of_kaikout)):
|
|
return
|
|
alias_of_kaikout_length = len(alias_of_kaikout) + 1
|
|
command = message_body[alias_of_kaikout_length:].lstrip()
|
|
elif message_type in ('chat', 'normal'):
|
|
command = message_body
|
|
jid_full = jid.full
|
|
room = self.sessions[jid_bare] if jid_bare in self.sessions else message_body
|
|
status_mode,status_text, message_response = None, None, None
|
|
# Start a configuration session
|
|
if '@' in room:
|
|
if room in XmppMuc.get_joined_rooms(self):
|
|
if XmppUtilities.is_moderator(self, room, self.alias):
|
|
alias = await XmppUtilities.is_jid_of_moderators(
|
|
self, room, jid_full)
|
|
if jid_bare not in self.sessions:
|
|
if alias:
|
|
# alias = XmppMuc.get_alias(self, room, jid)
|
|
# if XmppUtilities.is_moderator(self, room, alias):
|
|
room_owners = await XmppMuc.get_affiliation_list(
|
|
self, room, 'owner')
|
|
if not room_owners:
|
|
present_participants = XmppMuc.get_roster(self, room)
|
|
present_owners_alias = []
|
|
for participant in present_participants:
|
|
affiliation = XmppMuc.get_affiliation(
|
|
self, room, participant)
|
|
if affiliation == 'owner':
|
|
present_owners_alias.append(participant)
|
|
present_owners = []
|
|
for owner_alias in present_owners_alias:
|
|
owner_jid_full = XmppMuc.get_full_jid(self, room, owner_alias)
|
|
owner_jid_bare = owner_jid_full.split('/')[0]
|
|
present_owners.append(owner_jid_bare)
|
|
if not present_owners:
|
|
# present_moderators = await XmppMuc.get_role_list(
|
|
# self, room, 'moderator')
|
|
# moderators = []
|
|
# [moderators.append(moderator) for moderator in present_moderators if moderator not in moderators]
|
|
room_admins = await XmppMuc.get_affiliation_list(
|
|
self, room, 'admin')
|
|
# NOTE: Consideration, when there is no access
|
|
# to the list of owners from groupchat configuration
|
|
# then send a message to the groupchat - use alias
|
|
# instead of a Jabber ID.
|
|
jids_to_notify = room_owners or present_owners or room_admins
|
|
self.sessions[jid_bare] = room
|
|
message_response = (
|
|
'A session to configure groupchat {} has been '
|
|
'established.'.format(room))
|
|
status_mode = 'chat'
|
|
status_text = 'Session is opened: {}'.format(room)
|
|
for jid in jids_to_notify:
|
|
message_notification = (
|
|
'A session for groupchat {} has been '
|
|
'activated by moderator {}'
|
|
.format(room, jid_bare))
|
|
XmppMessage.send(
|
|
self, jid, message_notification, 'chat')
|
|
else:
|
|
message_response = (
|
|
'You do not appear to be a moderator of '
|
|
'groupchat {}'.format(room))
|
|
status_mode = 'available'
|
|
status_text = (
|
|
'Type the desired groupchat - in which you '
|
|
'are a moderator at - to configure')
|
|
moderators = await XmppMuc.get_role_list(
|
|
self, room, 'moderator')
|
|
message_notification = (
|
|
'An unauthorized attempt to establish a '
|
|
'session for groupchat {} has been made by {}'
|
|
.format(room, jid_bare))
|
|
for moderator in moderators:
|
|
jid_full = XmppMuc.get_full_jid(self, room,
|
|
moderator)
|
|
XmppMessage.send(
|
|
self, jid_full, message_notification, 'chat')
|
|
elif not alias:
|
|
del self.sessions[jid_bare]
|
|
message_response = (
|
|
'The session has been ended, because you are no '
|
|
'longer a moderator at groupchat {}'.format(room))
|
|
status_mode = 'away'
|
|
status_text = 'Session is closed: {}'.format(room)
|
|
moderators = await XmppMuc.get_role_list(
|
|
self, room, 'moderator')
|
|
message_notification = (
|
|
'The session for groupchat {} with former '
|
|
'moderator {} has been terminated.\n'
|
|
'A termination message has been sent to {}'
|
|
.format(room, jid_bare, jid_bare))
|
|
for moderator in moderators:
|
|
jid_full = XmppMuc.get_full_jid(self, room,
|
|
moderator)
|
|
XmppMessage.send(
|
|
self, jid_full, message_notification, 'chat')
|
|
else:
|
|
room = self.sessions[jid_bare]
|
|
else:
|
|
message_response = (
|
|
'KaikOut must be a moderator at groupchat "{}".'
|
|
.format(room))
|
|
else:
|
|
message_response = (
|
|
'Invite KaikOut to groupchat "{}" and try again.\n'
|
|
'A session will not begin if KaikOut is not present '
|
|
'in groupchat.'.format(room))
|
|
else:
|
|
message_response = ('The text "{}" does not appear to be a '
|
|
'valid groupchat Jabber ID.'.format(room))
|
|
if status_mode and status_text:
|
|
XmppStatus.send_status_message(self, jid_full, status_mode,
|
|
status_text)
|
|
if message_response:
|
|
XmppMessage.send_reply(self, message, message_response)
|
|
return
|
|
else:
|
|
print('AN UNKNOWN MESSAGE')
|
|
print(message)
|
|
return
|
|
|
|
db_file = Toml.instantiate(self, room)
|
|
|
|
# # Support private message via groupchat
|
|
# # See https://codeberg.org/poezio/slixmpp/issues/3506
|
|
# if message_type == 'chat' and message.get_plugin('muc', check=True):
|
|
# # jid_bare = message['from'].bare
|
|
# if (jid_bare == jid_full[:jid_full.index('/')]):
|
|
# # TODO Count and alert of MUC-PM attempts
|
|
# return
|
|
|
|
command_time_start = time.time()
|
|
|
|
command_lowercase = command.lower()
|
|
|
|
# if not self.settings[room]['enabled']:
|
|
# if not command_lowercase.startswith('start'):
|
|
# return
|
|
|
|
response = None
|
|
match command_lowercase:
|
|
case _ if command_lowercase.startswith('blacklist +'):
|
|
value = command[11:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'jid_blacklist', True)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing Jabber IDs.')
|
|
case _ if command_lowercase.startswith('blacklist -'):
|
|
value = command[11:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'jid_blacklist', False)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing Jabber IDs.')
|
|
case 'help':
|
|
command_list = XmppCommands.print_help()
|
|
response = ('Available command keys:\n'
|
|
'```\n{}\n```\n'
|
|
'Usage: `help <key>`'
|
|
.format(command_list))
|
|
case 'help all':
|
|
command_list = Documentation.manual('commands.toml',
|
|
section='all')
|
|
response = ('Complete list of commands:\n'
|
|
'```\n{}\n```'
|
|
.format(command_list))
|
|
case _ if command_lowercase.startswith('help'):
|
|
command = command[5:].lower()
|
|
command = command.split(' ')
|
|
if len(command) == 2:
|
|
command_root = command[0]
|
|
command_name = command[1]
|
|
command_list = Documentation.manual(
|
|
'commands.toml', section=command_root,
|
|
command=command_name)
|
|
if command_list:
|
|
command_list = ''.join(command_list)
|
|
response = (command_list)
|
|
else:
|
|
response = ('KeyError for {} {}'
|
|
.format(command_root, command_name))
|
|
elif len(command) == 1:
|
|
command = command[0]
|
|
command_list = Documentation.manual('commands.toml',
|
|
command)
|
|
if command_list:
|
|
command_list = ' '.join(command_list)
|
|
response = ('Available command `{}` keys:\n'
|
|
'```\n{}\n```\n'
|
|
'Usage: `help {} <command>`'
|
|
.format(command, command_list, command))
|
|
else:
|
|
response = 'KeyError for {}'.format(command)
|
|
else:
|
|
response = ('Invalid. Enter command key '
|
|
'or command key & name')
|
|
case 'info':
|
|
entries = XmppCommands.print_info_list()
|
|
response = ('Available command options:\n'
|
|
'```\n{}\n```\n'
|
|
'Usage: `info <option>`'
|
|
.format(entries))
|
|
case _ if command_lowercase.startswith('info'):
|
|
entry = command[5:].lower()
|
|
response = XmppCommands.print_info_specific(entry)
|
|
case _ if command_lowercase.startswith('action'):
|
|
value = command[6:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'action', value)
|
|
atype = 'ban' if value else 'devoice'
|
|
response = 'Action has been set to {} ({})'.format(
|
|
atype, value)
|
|
except:
|
|
response = 'Enter a numerical value.'
|
|
else:
|
|
response = str(self.settings[room]['action'])
|
|
case _ if command_lowercase.startswith('allow +'):
|
|
value = command[7:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'allow', True)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing keywords.')
|
|
case _ if command_lowercase.startswith('allow -'):
|
|
value = command[7:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'allow', False)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing keywords.')
|
|
case _ if command_lowercase.startswith('ban'):
|
|
if command[4:]:
|
|
value = command[4:].split()
|
|
alias = value[0]
|
|
reason = ' '.join(value[1:]) if len(value) > 1 else None
|
|
await XmppCommands.outcast(self, room, alias, reason)
|
|
case _ if command_lowercase.startswith('bookmark +'):
|
|
if XmppUtilities.is_operator(self, jid_bare):
|
|
muc_jid = command[11:]
|
|
response = await XmppCommands.bookmark_add(
|
|
self, muc_jid)
|
|
else:
|
|
response = ('This action is restricted. '
|
|
'Type: adding bookmarks.')
|
|
case _ if command_lowercase.startswith('bookmark -'):
|
|
if XmppUtilities.is_operator(self, jid_bare):
|
|
muc_jid = command[11:]
|
|
response = await XmppCommands.bookmark_del(
|
|
self, muc_jid)
|
|
else:
|
|
response = ('This action is restricted. '
|
|
'Type: removing bookmarks.')
|
|
case 'bookmarks':
|
|
if XmppUtilities.is_operator(self, jid_bare):
|
|
response = await XmppCommands.print_bookmarks(self)
|
|
else:
|
|
response = ('This action is restricted. '
|
|
'Type: viewing bookmarks.')
|
|
case _ if command_lowercase.startswith('clear'):
|
|
key = command[6:]
|
|
response = await XmppCommands.clear_filter(self, room, db_file,
|
|
key)
|
|
case _ if command_lowercase.startswith('count'):
|
|
value = command[5:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'count', value)
|
|
response = 'Count has been set to {}'.format(value)
|
|
except:
|
|
response = ('No action has been taken. '
|
|
'Enter a numerical value.')
|
|
else:
|
|
response = str(self.settings[room]['count'])
|
|
case _ if command_lowercase.startswith('default'):
|
|
key = command[8:]
|
|
if key:
|
|
response = await XmppCommands.restore_default(
|
|
self, room, db_file, key)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing key.')
|
|
case 'defaults':
|
|
response = await XmppCommands.restore_default(self, room,
|
|
db_file)
|
|
case _ if command_lowercase.startswith('deny +'):
|
|
value = command[6:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'deny', True)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing keywords.')
|
|
case _ if command_lowercase.startswith('deny -'):
|
|
value = command[6:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'deny', False)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing keywords.')
|
|
case 'finished off':
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'finished', 0)
|
|
response = 'Finished indicator has deactivated.'
|
|
case 'finished on':
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'finished', 1)
|
|
response = 'Finished indicator has activated.'
|
|
case _ if command_lowercase.startswith('frequency messages'):
|
|
value = command[18:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'frequency_messages', value)
|
|
response = ('Minimum allowed frequency for messages '
|
|
'has been set to {}'.format(value))
|
|
except:
|
|
response = 'Enter a numerical value.'
|
|
else:
|
|
response = str(self.settings[room]['frequency_messages'])
|
|
case _ if command_lowercase.startswith('frequency presence'):
|
|
value = command[18:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'frequency_presence', value)
|
|
response = ('Minimum allowed frequency for presence '
|
|
'has been set to {}'.format(value))
|
|
except:
|
|
response = 'Enter a numerical value.'
|
|
else:
|
|
response = str(self.settings[room]['frequency_presence'])
|
|
case 'goodbye':
|
|
if message_type == 'groupchat':
|
|
await XmppCommands.muc_leave(self, room)
|
|
else:
|
|
response = 'This command is valid in groupchat only.'
|
|
case _ if command_lowercase.startswith('ignore +'):
|
|
value = command[8:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'rtbl_ignore', True)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing Jabber IDs.')
|
|
case _ if command_lowercase.startswith('ignore -'):
|
|
value = command[8:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'rtbl_ignore', False)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing Jabber IDs.')
|
|
case 'inactivity off':
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'check_inactivity', 0)
|
|
response = 'Inactivity check has been deactivated.'
|
|
case 'inactivity on':
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'check_inactivity', 1)
|
|
response = 'Inactivity check has been activated.'
|
|
case _ if command_lowercase.startswith('inactivity span'):
|
|
value = command[15:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'inactivity_span', value)
|
|
response = ('The maximum allowed time of inactivity '
|
|
'has been set to {} days'.format(value))
|
|
except:
|
|
response = 'Enter a numerical value.'
|
|
else:
|
|
response = str(self.settings[room]['inactivity_span'])
|
|
case _ if command_lowercase.startswith('inactivity warn'):
|
|
value = command[15:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'inactivity_warn', value)
|
|
response = ('The time of inactivity to send a warning '
|
|
'upon before action has been set to {} '
|
|
'minutes'.format(value))
|
|
except:
|
|
response = 'Enter a numerical value.'
|
|
else:
|
|
response = str(self.settings[room]['inactivity_warn'])
|
|
case _ if command_lowercase.startswith('join'):
|
|
muc_jid = command[5:]
|
|
response = await XmppCommands.muc_join(self, muc_jid)
|
|
case 'options':
|
|
response = 'Options:\n```'
|
|
response += XmppCommands.print_options(self, room)
|
|
response += '\n```'
|
|
case _ if command_lowercase.startswith('kick'):
|
|
if command[5:]:
|
|
value = command[5:].split()
|
|
alias = value[0]
|
|
reason = ' '.join(value[1:]) if len(value) > 1 else None
|
|
await XmppCommands.kick(self, room, alias, reason)
|
|
case 'message off':
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'check_message', 0)
|
|
response = 'Message check has been deactivated.'
|
|
case 'message on':
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'check_message', 1)
|
|
response = 'Message check has been activated.'
|
|
case _ if command_lowercase.startswith('score messages'):
|
|
value = command[14:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'score_messages', value)
|
|
response = ('Score for messages has been set to {}'
|
|
.format(value))
|
|
except:
|
|
response = 'Enter a numerical value.'
|
|
else:
|
|
response = str(self.settings[room]['score_messages'])
|
|
case _ if command_lowercase.startswith('score presence'):
|
|
value = command[14:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'score_presence', value)
|
|
response = ('Score for presence has been set to {}'
|
|
.format(value))
|
|
except:
|
|
response = 'Enter a numerical value.'
|
|
else:
|
|
response = str(self.settings[room]['score_presence'])
|
|
case _ if command_lowercase.startswith('scores reset'):
|
|
jid_bare = command[12:].strip()
|
|
if jid_bare:
|
|
if jid_bare in self.settings[room]['scores']:
|
|
del self.settings[room]['scores'][jid_bare]
|
|
value = self.settings[room]['scores']
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'scores', value)
|
|
response = 'Score for {} has been reset'.format(jid_bare)
|
|
else:
|
|
response = 'Jabber ID {} is not known.'.format(jid_bare)
|
|
else:
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'scores', {})
|
|
response = 'All scores have been reset'
|
|
case _ if command_lowercase.startswith('scores'):
|
|
jid_bare = command[6:].strip()
|
|
if jid_bare:
|
|
if jid_bare in self.settings[room]['scores']:
|
|
response = str(self.settings[room]['scores'][jid_bare])
|
|
else:
|
|
response = 'Jabber ID {} is not known.'.format(jid_bare)
|
|
else:
|
|
response = str(self.settings[room]['scores'])
|
|
case 'start':
|
|
XmppCommands.update_setting_value(self, room, db_file,
|
|
'enabled', 1)
|
|
XmppStatus.send_status_message(self, room)
|
|
case 'stats':
|
|
response = XmppCommands.print_statistics(db_file)
|
|
case 'status off':
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'check_status', 0)
|
|
response = 'Status message check has been deactivated'
|
|
case 'status on':
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'check_status', 1)
|
|
response = 'Status message check has been activated'
|
|
case 'stop':
|
|
XmppCommands.update_setting_value(self, room, db_file,
|
|
'enabled', 0)
|
|
XmppStatus.send_status_message(self, room)
|
|
case 'support':
|
|
response = XmppCommands.print_support_jid()
|
|
await XmppCommands.invite_jid_to_muc(self, room)
|
|
case _ if command_lowercase.startswith('timer'):
|
|
value = command[5:].strip()
|
|
if value:
|
|
try:
|
|
value = int(value)
|
|
XmppCommands.update_setting_value(
|
|
self, room, db_file, 'timer', value)
|
|
response = ('Timer value for countdown before '
|
|
'committing an action has been set to {} '
|
|
'seconds'.format(value))
|
|
except:
|
|
response = 'Enter a numerical value.'
|
|
else:
|
|
response = str(self.settings[room]['timer'])
|
|
case 'version':
|
|
response = XmppCommands.print_version()
|
|
case _ if command_lowercase.startswith('whitelist +'):
|
|
value = command[11:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'jid_whitelist', True)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing Jabber IDs.')
|
|
case _ if command_lowercase.startswith('whitelist -'):
|
|
value = command[11:].strip()
|
|
if value:
|
|
response = XmppCommands.set_filter(
|
|
self, room, db_file, value, 'jid_whitelist', False)
|
|
else:
|
|
response = ('No action has been taken. '
|
|
'Missing Jabber IDs.')
|
|
case _ if command_lowercase.startswith('xmpp:'):
|
|
response = await XmppCommands.muc_join(self, command)
|
|
case _:
|
|
response = XmppCommands.print_unknown()
|
|
|
|
command_time_finish = time.time()
|
|
command_time_total = command_time_finish - command_time_start
|
|
command_time_total = round(command_time_total, 3)
|
|
|
|
if response: XmppMessage.send_reply(self, message, response)
|
|
|
|
if room in self.settings and self.settings[room]['finished']:
|
|
response_finished = ('Finished. Total time: {}s'
|
|
.format(command_time_total))
|
|
XmppMessage.send_reply(self, message, response_finished)
|