forked from sch/Slixfeed
f65be8b5c8
Add http proxy support. Add more functionality to handle bookmarks. Split into more modules. Remove callback function initdb. Tasked status messages are broken.
757 lines
32 KiB
Python
757 lines
32 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
|
|
TODO
|
|
|
|
1) Deprecate "add" (see above) and make it interactive.
|
|
Slixfeed: Do you still want to add this URL to subscription list?
|
|
See: case _ if message_lowercase.startswith("add"):
|
|
|
|
2) If subscription is inadequate (see state.request), send a message that says so.
|
|
|
|
elif not self.client_roster[jid]["to"]:
|
|
breakpoint()
|
|
message.reply("Share online status to activate bot.").send()
|
|
return
|
|
|
|
"""
|
|
|
|
import os
|
|
from slixfeed.config import (
|
|
add_to_list,
|
|
get_default_dbdir,
|
|
get_value,
|
|
get_pathname_to_database,
|
|
remove_from_list)
|
|
from slixfeed.datetime import current_time
|
|
import slixfeed.fetch as fetcher
|
|
import slixfeed.sqlite as sqlite
|
|
import slixfeed.task as task
|
|
import slixfeed.utility as utility
|
|
import slixfeed.url as uri
|
|
import slixfeed.xmpp.bookmark as bookmark
|
|
import slixfeed.xmpp.compose as compose
|
|
import slixfeed.xmpp.muc as groupchat
|
|
import slixfeed.xmpp.status as status
|
|
import slixfeed.xmpp.text as text
|
|
|
|
|
|
async def event(self, event):
|
|
"""
|
|
Process the session_start event.
|
|
|
|
Typical actions for the session_start event are
|
|
requesting the roster and broadcasting an initial
|
|
presence stanza.
|
|
|
|
Arguments:
|
|
event -- An empty dictionary. The session_start
|
|
event does not provide any additional
|
|
data.
|
|
"""
|
|
self.send_presence()
|
|
await self.get_roster()
|
|
|
|
# for task in main_task:
|
|
# task.cancel()
|
|
|
|
# Deprecated in favour of event "presence_available"
|
|
# if not main_task:
|
|
# await select_file()
|
|
|
|
|
|
async def 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.
|
|
"""
|
|
# print("message")
|
|
# print(message)
|
|
if message["type"] in ("chat", "groupchat", "normal"):
|
|
jid = message["from"].bare
|
|
if message["type"] == "groupchat":
|
|
# nick = message["from"][message["from"].index("/")+1:]
|
|
nick = str(message["from"])
|
|
nick = nick[nick.index("/")+1:]
|
|
if (message['muc']['nick'] == self.nick or
|
|
not message["body"].startswith("!")):
|
|
return
|
|
# token = await initdb(
|
|
# jid,
|
|
# get_settings_value,
|
|
# "token"
|
|
# )
|
|
# if token == "accepted":
|
|
# operator = await initdb(
|
|
# jid,
|
|
# get_settings_value,
|
|
# "masters"
|
|
# )
|
|
# if operator:
|
|
# if nick not in operator:
|
|
# return
|
|
# approved = False
|
|
jid_full = str(message["from"])
|
|
role = self.plugin['xep_0045'].get_jid_property(
|
|
jid,
|
|
jid_full[jid_full.index("/")+1:],
|
|
"role")
|
|
if role != "moderator":
|
|
return
|
|
# if role == "moderator":
|
|
# approved = True
|
|
# TODO Implement a list of temporary operators
|
|
# Once an operator is appointed, the control would last
|
|
# untile the participant has been disconnected from MUC
|
|
# An operator is a function to appoint non moderators.
|
|
# Changing nickname is fine and consist of no problem.
|
|
# if not approved:
|
|
# operator = await initdb(
|
|
# jid,
|
|
# get_settings_value,
|
|
# "masters"
|
|
# )
|
|
# if operator:
|
|
# if nick in operator:
|
|
# approved = True
|
|
# if not approved:
|
|
# return
|
|
|
|
# # Begin processing new JID
|
|
# # Deprecated in favour of event "presence_available"
|
|
# db_dir = get_default_dbdir()
|
|
# os.chdir(db_dir)
|
|
# if jid + ".db" not in os.listdir():
|
|
# await task_jid(jid)
|
|
|
|
# await compose.message(self, jid, message)
|
|
|
|
message_text = " ".join(message["body"].split())
|
|
if message["type"] == "groupchat":
|
|
message_text = message_text[1:]
|
|
message_lowercase = message_text.lower()
|
|
|
|
print(current_time(), "ACCOUNT: " + str(message["from"]))
|
|
print(current_time(), "COMMAND:", message_text)
|
|
|
|
match message_lowercase:
|
|
case "breakpoint":
|
|
breakpoint()
|
|
case "commands":
|
|
response = text.print_cmd()
|
|
send_reply_message(self, message, response)
|
|
case "help":
|
|
response = text.print_help()
|
|
send_reply_message(self, message, response)
|
|
case "info":
|
|
response = text.print_info()
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase in [
|
|
"greetings", "hallo", "hello", "hey",
|
|
"hi", "hola", "holla", "hollo"]:
|
|
response = (
|
|
"Greeting!\n"
|
|
"I'm Slixfeed, an RSS News Bot!\n"
|
|
"Send \"help\" for instructions.\n"
|
|
)
|
|
send_reply_message(self, message, response)
|
|
# print("task_manager[jid]")
|
|
# print(task_manager[jid])
|
|
await self.get_roster()
|
|
print("roster 1")
|
|
print(self.client_roster)
|
|
print("roster 2")
|
|
print(self.client_roster.keys())
|
|
print("jid")
|
|
print(jid)
|
|
|
|
# case _ if message_lowercase.startswith("activate"):
|
|
# if message["type"] == "groupchat":
|
|
# acode = message[9:]
|
|
# token = await initdb(
|
|
# jid,
|
|
# get_settings_value,
|
|
# "token"
|
|
# )
|
|
# if int(acode) == token:
|
|
# await initdb(
|
|
# jid,
|
|
# set_settings_value,
|
|
# ["masters", nick]
|
|
# )
|
|
# await initdb(
|
|
# jid,
|
|
# set_settings_value,
|
|
# ["token", "accepted"]
|
|
# )
|
|
# response = "{}, your are in command.".format(nick)
|
|
# else:
|
|
# response = "Activation code is not valid."
|
|
# else:
|
|
# response = "This command is valid for groupchat only."
|
|
case _ if message_lowercase.startswith("add"):
|
|
message_text = message_text[4:]
|
|
url = message_text.split(" ")[0]
|
|
title = " ".join(message_text.split(" ")[1:])
|
|
if url.startswith("http"):
|
|
db_file = get_pathname_to_database(jid)
|
|
response = await fetcher.add_feed_no_check(db_file, [url, title])
|
|
old = await sqlite.get_settings_value(db_file, "old")
|
|
if old:
|
|
await task.clean_tasks_xmpp(jid, ["status"])
|
|
# await send_status(jid)
|
|
await task.start_tasks_xmpp(self, jid, ["status"])
|
|
else:
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.mark_source_as_read(db_file, url)
|
|
else:
|
|
response = "Missing URL."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("allow +"):
|
|
key = "filter-" + message_text[:5]
|
|
val = message_text[7:]
|
|
if val:
|
|
db_file = get_pathname_to_database(jid)
|
|
keywords = await sqlite.get_filters_value(db_file, key)
|
|
val = await add_to_list(val, keywords)
|
|
await sqlite.set_filters_value(db_file, [key, val])
|
|
response = (
|
|
"Approved keywords\n"
|
|
"```\n{}\n```"
|
|
).format(val)
|
|
else:
|
|
response = "Missing keywords."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("allow -"):
|
|
key = "filter-" + message_text[:5]
|
|
val = message_text[7:]
|
|
if val:
|
|
db_file = get_pathname_to_database(jid)
|
|
keywords = await sqlite.get_filters_value(db_file, key)
|
|
val = await remove_from_list(val, keywords)
|
|
await sqlite.set_filters_value(db_file, [key, val])
|
|
response = (
|
|
"Approved keywords\n"
|
|
"```\n{}\n```"
|
|
).format(val)
|
|
else:
|
|
response = "Missing keywords."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("archive"):
|
|
key = message_text[:7]
|
|
val = message_text[8:]
|
|
if val:
|
|
try:
|
|
if int(val) > 500:
|
|
response = "Value may not be greater than 500."
|
|
else:
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.set_settings_value(db_file, [key, val])
|
|
response = (
|
|
"Maximum archived items has been set to {}."
|
|
).format(val)
|
|
except:
|
|
response = "Enter a numeric value only."
|
|
else:
|
|
response = "Missing value."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("bookmark - "):
|
|
if jid == get_value("accounts", "XMPP", "operator"):
|
|
muc_jid = message_text[11:]
|
|
await bookmark.remove(self, muc_jid)
|
|
response = (
|
|
"Groupchat {} has been removed from bookmarks."
|
|
).format(muc_jid)
|
|
else:
|
|
response = (
|
|
"This response is restricted. "
|
|
"Type: removing bookmarks."
|
|
)
|
|
send_reply_message(self, message, response)
|
|
case "bookmarks":
|
|
response = await compose.list_bookmarks(self)
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("deny +"):
|
|
key = "filter-" + message_text[:4]
|
|
val = message_text[6:]
|
|
if val:
|
|
db_file = get_pathname_to_database(jid)
|
|
keywords = await sqlite.get_filters_value(db_file, key)
|
|
val = await add_to_list(val, keywords)
|
|
await sqlite.set_filters_value(db_file, [key, val])
|
|
response = (
|
|
"Rejected keywords\n"
|
|
"```\n{}\n```"
|
|
).format(val)
|
|
else:
|
|
response = "Missing keywords."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("deny -"):
|
|
key = "filter-" + message_text[:4]
|
|
val = message_text[6:]
|
|
if val:
|
|
db_file = get_pathname_to_database(jid)
|
|
keywords = await sqlite.get_filters_value(db_file, key)
|
|
val = await remove_from_list(val, keywords)
|
|
await sqlite.set_filters_value(db_file, [key, val])
|
|
response = (
|
|
"Rejected keywords\n"
|
|
"```\n{}\n```"
|
|
).format(val)
|
|
else:
|
|
response = "Missing keywords."
|
|
send_reply_message(self, message, response)
|
|
case _ if (message_lowercase.startswith("gemini") or
|
|
message_lowercase.startswith("gopher:")):
|
|
response = "Gemini and Gopher are not supported yet."
|
|
send_reply_message(self, message, response)
|
|
case _ if (message_lowercase.startswith("http") or
|
|
message_lowercase.startswith("feed:")):
|
|
url = message_text
|
|
await task.clean_tasks_xmpp(jid, ["status"])
|
|
status_type = "dnd"
|
|
status_message = (
|
|
"📫️ Processing request to fetch data from {}"
|
|
).format(url)
|
|
send_status_message(self, jid, status_type, status_message)
|
|
send_reply_message(self, message, response)
|
|
if url.startswith("feed:"):
|
|
url = uri.feed_to_http(url)
|
|
# url_alt = await uri.replace_hostname(url, "feed")
|
|
# if url_alt:
|
|
# url = url_alt
|
|
url = (uri.replace_hostname(url, "feed")) or url
|
|
db_file = get_pathname_to_database(jid)
|
|
response = await fetcher.add_feed(db_file, url)
|
|
await task.start_tasks_xmpp(self, jid, ["status"])
|
|
# response = "> " + message + "\n" + response
|
|
# FIXME Make the taskhandler to update status message
|
|
# await refresh_task(
|
|
# self,
|
|
# jid,
|
|
# send_status,
|
|
# "status",
|
|
# 20
|
|
# )
|
|
# NOTE This would show the number of new unread entries
|
|
old = await sqlite.get_settings_value(db_file, "old")
|
|
if old:
|
|
await task.clean_tasks_xmpp(jid, ["status"])
|
|
# await send_status(jid)
|
|
await task.start_tasks_xmpp(self, jid, ["status"])
|
|
else:
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.mark_source_as_read(db_file, url)
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("feeds"):
|
|
query = message_text[6:]
|
|
if query:
|
|
if len(query) > 3:
|
|
db_file = get_pathname_to_database(jid)
|
|
result = await sqlite.search_feeds(db_file, query)
|
|
response = compose.list_feeds_by_query(query, result)
|
|
else:
|
|
response = (
|
|
"Enter at least 4 characters to search"
|
|
)
|
|
else:
|
|
db_file = get_pathname_to_database(jid)
|
|
result = await sqlite.get_feeds(db_file)
|
|
response = compose.list_feeds(result)
|
|
send_reply_message(self, message, response)
|
|
case "goodbye":
|
|
if message["type"] == "groupchat":
|
|
await groupchat.leave(self, jid)
|
|
else:
|
|
response = "This command is valid for groupchat only."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("interval"):
|
|
# FIXME
|
|
# The following error occurs only upon first attempt to set interval.
|
|
# /usr/lib/python3.11/asyncio/events.py:73: RuntimeWarning: coroutine 'Slixfeed.send_update' was never awaited
|
|
# self._args = None
|
|
# RuntimeWarning: Enable tracemalloc to get the object allocation traceback
|
|
key = message_text[:8]
|
|
val = message_text[9:]
|
|
if val:
|
|
# response = (
|
|
# "Updates will be sent every {} minutes."
|
|
# ).format(response)
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.set_settings_value(db_file, [key, val])
|
|
# NOTE Perhaps this should be replaced
|
|
# by functions clean and start
|
|
await task.refresh_task(
|
|
self, jid, task.send_update, key, val)
|
|
response = (
|
|
"Updates will be sent every {} minutes."
|
|
).format(val)
|
|
else:
|
|
response = "Missing value."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("join"):
|
|
muc_jid = uri.check_xmpp_uri(message_text[5:])
|
|
if muc_jid:
|
|
# TODO probe JID and confirm it's a groupchat
|
|
await groupchat.join(self, jid, muc_jid)
|
|
response = (
|
|
"Joined groupchat {}"
|
|
).format(message_text)
|
|
else:
|
|
response = (
|
|
"> {}\nXMPP URI is not valid."
|
|
).format(message_text)
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("length"):
|
|
key = message_text[:6]
|
|
val = message_text[7:]
|
|
if val:
|
|
try:
|
|
val = int(val)
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.set_settings_value(db_file, [key, val])
|
|
if val == 0:
|
|
response = (
|
|
"Summary length limit is disabled."
|
|
)
|
|
else:
|
|
response = (
|
|
"Summary maximum length "
|
|
"is set to {} characters."
|
|
).format(val)
|
|
except:
|
|
response = "Enter a numeric value only."
|
|
else:
|
|
response = "Missing value."
|
|
# case _ if message_lowercase.startswith("mastership"):
|
|
# key = message_text[:7]
|
|
# val = message_text[11:]
|
|
# if val:
|
|
# names = await initdb(
|
|
# jid,
|
|
# get_settings_value,
|
|
# key
|
|
# )
|
|
# val = await add_to_list(
|
|
# val,
|
|
# names
|
|
# )
|
|
# await initdb(
|
|
# jid,
|
|
# set_settings_value,
|
|
# [key, val]
|
|
# )
|
|
# response = (
|
|
# "Operators\n"
|
|
# "```\n{}\n```"
|
|
# ).format(val)
|
|
# else:
|
|
# response = "Missing value."
|
|
send_reply_message(self, message, response)
|
|
case "new":
|
|
db_file = get_pathname_to_database(jid)
|
|
sqlite.set_settings_value(db_file, ["old", 0])
|
|
response = (
|
|
"Only new items of newly added feeds will be sent."
|
|
)
|
|
send_reply_message(self, message, response)
|
|
# TODO Will you add support for number of messages?
|
|
case "next":
|
|
# num = message_text[5:]
|
|
await task.clean_tasks_xmpp(jid, ["interval", "status"])
|
|
await task.start_tasks_xmpp(self, jid, ["interval", "status"])
|
|
# await refresh_task(
|
|
# self,
|
|
# jid,
|
|
# send_update,
|
|
# "interval",
|
|
# num
|
|
# )
|
|
# await refresh_task(
|
|
# self,
|
|
# jid,
|
|
# send_status,
|
|
# "status",
|
|
# 20
|
|
# )
|
|
# await refresh_task(jid, key, val)
|
|
case "old":
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.set_settings_value(db_file, ["old", 1])
|
|
response = (
|
|
"All items of newly added feeds will be sent."
|
|
)
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("quantum"):
|
|
key = message_text[:7]
|
|
val = message_text[8:]
|
|
if val:
|
|
try:
|
|
val = int(val)
|
|
# response = (
|
|
# "Every update will contain {} news items."
|
|
# ).format(response)
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.set_settings_value(db_file, [key, val])
|
|
response = (
|
|
"Next update will contain {} news items."
|
|
).format(val)
|
|
except:
|
|
response = "Enter a numeric value only."
|
|
else:
|
|
response = "Missing value."
|
|
send_reply_message(self, message, response)
|
|
case "random":
|
|
# TODO /questions/2279706/select-random-row-from-a-sqlite-table
|
|
# NOTE sqlitehandler.get_entry_unread
|
|
response = "Updates will be sent by random order."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("read"):
|
|
data = message_text[5:]
|
|
data = data.split()
|
|
url = data[0]
|
|
await task.clean_tasks_xmpp(jid, ["status"])
|
|
status_type = "dnd"
|
|
status_message = (
|
|
"📫️ Processing request to fetch data from {}"
|
|
).format(url)
|
|
send_status_message(self, jid, status_type, status_message)
|
|
if url.startswith("feed:"):
|
|
url = uri.feed_to_http(url)
|
|
url = (uri.replace_hostname(url, "feed")) or url
|
|
match len(data):
|
|
case 1:
|
|
if url.startswith("http"):
|
|
response = await fetcher.view_feed(url)
|
|
else:
|
|
response = "Missing URL."
|
|
case 2:
|
|
num = data[1]
|
|
if url.startswith("http"):
|
|
response = await fetcher.view_entry(url, num)
|
|
else:
|
|
response = "Missing URL."
|
|
case _:
|
|
response = (
|
|
"Enter command as follows:\n"
|
|
"`read <url>` or `read <url> <number>`\n"
|
|
"URL must not contain white space."
|
|
)
|
|
send_reply_message(self, message, response)
|
|
await task.start_tasks_xmpp(self, jid, ["status"])
|
|
case _ if message_lowercase.startswith("recent"):
|
|
num = message_text[7:]
|
|
if num:
|
|
try:
|
|
num = int(num)
|
|
if num < 1 or num > 50:
|
|
response = "Value must be ranged from 1 to 50."
|
|
else:
|
|
db_file = get_pathname_to_database(jid)
|
|
result = await sqlite.last_entries(db_file, num)
|
|
response = compose.list_last_entries(result, num)
|
|
except:
|
|
response = "Enter a numeric value only."
|
|
else:
|
|
response = "Missing value."
|
|
send_reply_message(self, message, response)
|
|
# NOTE Should people be asked for numeric value?
|
|
case _ if message_lowercase.startswith("remove"):
|
|
ix = message_text[7:]
|
|
if ix:
|
|
db_file = get_pathname_to_database(jid)
|
|
response = await sqlite.remove_feed(db_file, ix)
|
|
# await refresh_task(
|
|
# self,
|
|
# jid,
|
|
# send_status,
|
|
# "status",
|
|
# 20
|
|
# )
|
|
await task.clean_tasks_xmpp(jid, ["status"])
|
|
await task.start_tasks_xmpp(self, jid, ["status"])
|
|
else:
|
|
response = "Missing feed ID."
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("reset"):
|
|
source = message_text[6:]
|
|
await task.clean_tasks_xmpp(jid, ["status"])
|
|
status_type = "dnd"
|
|
status_message = "📫️ Marking entries as read..."
|
|
send_status_message(self, jid, status_type, status_message)
|
|
if source:
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.mark_source_as_read(db_file, source)
|
|
response = (
|
|
"All entries of {} have been "
|
|
"marked as read.".format(source)
|
|
)
|
|
else:
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.mark_all_as_read(db_file)
|
|
response = "All entries have been marked as read."
|
|
send_reply_message(self, message, response)
|
|
await task.start_tasks_xmpp(self, jid, ["status"])
|
|
case _ if message_lowercase.startswith("search"):
|
|
query = message_text[7:]
|
|
if query:
|
|
if len(query) > 1:
|
|
db_file = get_pathname_to_database(jid)
|
|
results = await sqlite.search_entries(db_file, query)
|
|
response = compose.list_search_results(query, results)
|
|
else:
|
|
response = (
|
|
"Enter at least 2 characters to search"
|
|
)
|
|
else:
|
|
response = "Missing search query."
|
|
send_reply_message(self, message, response)
|
|
case "start":
|
|
# response = "Updates are enabled."
|
|
key = "enabled"
|
|
val = 1
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.set_settings_value(db_file, [key, val])
|
|
# asyncio.create_task(task_jid(self, jid))
|
|
await task.start_tasks_xmpp(self, jid, ["interval", "status", "check"])
|
|
response = "Updates are enabled."
|
|
# print(current_time(), "task_manager[jid]")
|
|
# print(task_manager[jid])
|
|
send_reply_message(self, message, response)
|
|
case "stats":
|
|
db_file = get_pathname_to_database(jid)
|
|
result = await sqlite.statistics(db_file)
|
|
response = compose.list_statistics(result)
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("status "):
|
|
ix = message_text[7:]
|
|
db_file = get_pathname_to_database(jid)
|
|
response = await sqlite.toggle_status(db_file, ix)
|
|
send_reply_message(self, message, response)
|
|
case "stop":
|
|
# FIXME
|
|
# The following error occurs only upon first attempt to stop.
|
|
# /usr/lib/python3.11/asyncio/events.py:73: RuntimeWarning: coroutine 'Slixfeed.send_update' was never awaited
|
|
# self._args = None
|
|
# RuntimeWarning: Enable tracemalloc to get the object allocation traceback
|
|
# response = "Updates are disabled."
|
|
# try:
|
|
# # task_manager[jid]["check"].cancel()
|
|
# # task_manager[jid]["status"].cancel()
|
|
# task_manager[jid]["interval"].cancel()
|
|
# key = "enabled"
|
|
# val = 0
|
|
# response = await initdb(
|
|
# jid,
|
|
# set_settings_value,
|
|
# [key, val]
|
|
# )
|
|
# except:
|
|
# response = "Updates are already disabled."
|
|
# # print("Updates are already disabled. Nothing to do.")
|
|
# # await send_status(jid)
|
|
key = "enabled"
|
|
val = 0
|
|
db_file = get_pathname_to_database(jid)
|
|
await sqlite.set_settings_value(db_file, [key, val])
|
|
await task.clean_tasks_xmpp(jid, ["interval", "status"])
|
|
response = "Updates are disabled."
|
|
send_reply_message(self, message, response)
|
|
status_type = "xa"
|
|
status_message = "💡️ Send \"Start\" to receive Jabber updates"
|
|
send_status_message(self, jid, status_type, status_message)
|
|
case "support":
|
|
# TODO Send an invitation.
|
|
response = (
|
|
"Join xmpp:slixfeed@chat.woodpeckersnest.space?join")
|
|
send_reply_message(self, message, response)
|
|
case _ if message_lowercase.startswith("xmpp:"):
|
|
muc_jid = uri.check_xmpp_uri(message_text)
|
|
if muc_jid:
|
|
# TODO probe JID and confirm it's a groupchat
|
|
await groupchat.join(self, jid, muc_jid)
|
|
response = (
|
|
"Joined groupchat {}"
|
|
).format(message_text)
|
|
else:
|
|
response = (
|
|
"> {}\nXMPP URI is not valid."
|
|
).format(message_text)
|
|
send_reply_message(self, message, response)
|
|
case _:
|
|
response = (
|
|
"Unknown command. "
|
|
"Press \"help\" for list of commands"
|
|
)
|
|
send_reply_message(self, message, response)
|
|
# TODO Use message correction here
|
|
# NOTE This might not be a good idea if
|
|
# commands are sent one close to the next
|
|
# if response: message.reply(response).send()
|
|
|
|
log_dir = get_default_dbdir()
|
|
if not os.path.isdir(log_dir):
|
|
os.mkdir(log_dir)
|
|
utility.log_as_markdown(
|
|
current_time(), os.path.join(log_dir, jid),
|
|
jid, message_text)
|
|
utility.log_as_markdown(
|
|
current_time(), os.path.join(log_dir, jid),
|
|
self.boundjid.bare, response)
|
|
|
|
|
|
def send_status_message(self, jid, status_type, status_message):
|
|
self.send_presence(
|
|
pshow=status_type,
|
|
pstatus=status_message,
|
|
pto=jid)
|
|
|
|
|
|
def send_reply_message(self, message, response):
|
|
message.reply(response).send()
|
|
|
|
|
|
# def greet(self, jid, chat_type="chat"):
|
|
# messages = [
|
|
# "Greetings!",
|
|
# "I'm {}, the news anchor.".format(self.nick),
|
|
# "My job is to bring you the latest news "
|
|
# "from sources you provide me with.",
|
|
# "You may always reach me via "
|
|
# "xmpp:{}?message".format(self.boundjid.bare)
|
|
# ]
|
|
# for message in messages:
|
|
# self.send_message(
|
|
# mto=jid,
|
|
# mbody=message,
|
|
# mtype=chat_type
|
|
# )
|
|
|
|
|
|
def greet(self, jid, chat_type="chat"):
|
|
message = (
|
|
"Greetings!\n"
|
|
"I'm {}, the news anchor.\n"
|
|
"My job is to bring you the latest "
|
|
"news from sources you provide me with.\n"
|
|
"You may always reach me via xmpp:{}?message").format(
|
|
self.nick,
|
|
self.boundjid.bare
|
|
)
|
|
self.send_message(
|
|
mto=jid,
|
|
mbody=message,
|
|
mtype=chat_type
|
|
)
|
|
|