forked from sch/Slixfeed
Compare commits
9 commits
Author | SHA1 | Date | |
---|---|---|---|
|
4642aa694b | ||
|
21cb7df160 | ||
|
bd058ebf73 | ||
|
9c068ad600 | ||
|
6714089bdd | ||
|
51943b5b0c | ||
|
f9a1c683cd | ||
|
5e20b2830d | ||
|
37444c9d4e |
|
@ -20,14 +20,15 @@ Slixfeed is primarily designed for XMPP (aka Jabber), yet it is built to be exte
|
|||
|
||||
## Features
|
||||
|
||||
- **Visual interface** - Interactive interface for XMPP using Ad-Hoc Commands,
|
||||
- **Ease** - Slixfeed automatically scans (i.e. crawls) for syndication feeds of given URL.
|
||||
- **Encryption** - Messages are encrypted with the OMEMO standard.
|
||||
- **Export** - Download articles as ePUB, HTML, Markdown and PDF.
|
||||
- **Filtering** - Filter news items using lists of allow and deny.
|
||||
- **Multimedia** - Display audios pictures and videos inline.
|
||||
- **Privacy** - Redirect to alternative back-ends, such as Invidious, Librarian, Nitter, for increased privacy, productivity and security.
|
||||
- **Portable** - Export and import feeds with a standard OPML file.
|
||||
- **Simultaneous** - Slixfeed is designed to handle multiple contacts, including groupchats, Simultaneously.
|
||||
- **Visual interface** - Interactive interface for XMPP using Ad-Hoc Commands,
|
||||
|
||||
## Preview
|
||||
|
||||
|
@ -56,7 +57,7 @@ It is possible to install Slixfeed using pip and pipx.
|
|||
```
|
||||
$ python3 -m venv .venv
|
||||
$ source .venv/bin/activate
|
||||
$ pip install git+https://gitgud.io/sjehuda/slixfeed
|
||||
$ pip install git+https://git.xmpp-it.net/sch/Slixfeed
|
||||
```
|
||||
|
||||
#### pipx
|
||||
|
@ -64,14 +65,14 @@ $ pip install git+https://gitgud.io/sjehuda/slixfeed
|
|||
##### Install
|
||||
|
||||
```
|
||||
$ pipx install git+https://gitgud.io/sjehuda/slixfeed
|
||||
$ pipx install git+https://git.xmpp-it.net/sch/Slixfeed
|
||||
```
|
||||
|
||||
##### Update
|
||||
|
||||
```
|
||||
$ pipx uninstall slixfeed
|
||||
$ pipx install git+https://gitgud.io/sjehuda/slixfeed
|
||||
$ pipx install git+https://git.xmpp-it.net/sch/Slixfeed
|
||||
```
|
||||
|
||||
### Start
|
||||
|
|
|
@ -39,16 +39,22 @@ keywords = [
|
|||
]
|
||||
# urls = {Homepage = "https://gitgud.io/sjehuda/slixfeed"}
|
||||
dependencies = [
|
||||
"aiofiles",
|
||||
"aiohttp",
|
||||
# "daemonize",
|
||||
"feedparser",
|
||||
"lxml",
|
||||
"omemo", # OMEMO
|
||||
# "pysocks",
|
||||
"protobuf==3.20.3", # OMEMO
|
||||
"python-dateutil",
|
||||
"requests",
|
||||
"slixmpp",
|
||||
"slixmpp-omemo", # OMEMO
|
||||
"tomli", # Python 3.10
|
||||
"tomli_w",
|
||||
"X3DH", # OMEMO
|
||||
"XEdDSA", # OMEMO
|
||||
]
|
||||
|
||||
[project.urls]
|
||||
|
|
|
@ -11,6 +11,7 @@ interval = 300 # Update interval (Minimum value 10)
|
|||
length = 300 # Maximum length of summary (Value 0 to disable)
|
||||
media = 0 # Display media (audio, image, video) when available
|
||||
old = 0 # Mark entries of newly added entries as unread
|
||||
omemo = 1 # Encrypt messages with OMEMO
|
||||
quantum = 3 # Amount of entries per update
|
||||
random = 0 # Pick random item from database
|
||||
|
||||
|
|
|
@ -51,27 +51,31 @@ logger = Logger(__name__)
|
|||
# setting_jid.setting_key has value, otherwise resort to setting_default.setting_key.
|
||||
class Config:
|
||||
|
||||
def add_settings_default(settings):
|
||||
def add_settings_default(self):
|
||||
settings_default = get_values('settings.toml', 'settings')
|
||||
settings['default'] = settings_default
|
||||
self.defaults = settings_default
|
||||
|
||||
# TODO Open SQLite file once
|
||||
def add_settings_jid(settings, jid_bare, db_file):
|
||||
settings[jid_bare] = {}
|
||||
for key in ('archive', 'enabled', 'filter', 'formatting', 'interval',
|
||||
'length', 'media', 'old', 'quantum'):
|
||||
def add_settings_jid(self, jid_bare, db_file):
|
||||
self.settings[jid_bare] = {}
|
||||
for key in self.defaults['default']:
|
||||
value = sqlite.get_setting_value(db_file, key)
|
||||
if value: settings[jid_bare][key] = value[0]
|
||||
if value:
|
||||
self.settings[jid_bare][key] = value[0]
|
||||
elif key not in ('check', 'formatting'):
|
||||
# NOTE This might neglects the need for
|
||||
# self.defaults of get_setting_value
|
||||
self.settings[jid_bare][key] = self.defaults['default'][key]
|
||||
|
||||
def get_settings_xmpp(key=None):
|
||||
result = get_values('accounts.toml', 'xmpp')
|
||||
result = result[key] if key else result
|
||||
return result
|
||||
|
||||
async def set_setting_value(settings, jid_bare, db_file, key, val):
|
||||
async def set_setting_value(self, jid_bare, db_file, key, val):
|
||||
key = key.lower()
|
||||
key_val = [key, val]
|
||||
settings[jid_bare][key] = val
|
||||
self.settings[jid_bare][key] = val
|
||||
if sqlite.is_setting_key(db_file, key):
|
||||
await sqlite.update_setting_value(db_file, key_val)
|
||||
else:
|
||||
|
@ -79,11 +83,11 @@ class Config:
|
|||
|
||||
# TODO Segregate Jabber ID settings from Slixfeed wide settings.
|
||||
# self.settings, self.settings_xmpp, self.settings_irc etc.
|
||||
def get_setting_value(settings, jid_bare, key):
|
||||
if jid_bare in settings and key in settings[jid_bare]:
|
||||
value = settings[jid_bare][key]
|
||||
def get_setting_value(self, jid_bare, key):
|
||||
if jid_bare in self.settings and key in self.settings[jid_bare]:
|
||||
value = self.settings[jid_bare][key]
|
||||
else:
|
||||
value = settings['default'][key]
|
||||
value = self.defaults['default'][key]
|
||||
return value
|
||||
|
||||
class ConfigNetwork:
|
||||
|
@ -105,6 +109,71 @@ class ConfigJabberID:
|
|||
settings[jid_bare][key] = value
|
||||
|
||||
|
||||
class Data:
|
||||
|
||||
|
||||
def get_default_data_directory():
|
||||
"""
|
||||
Determine the directory path where dbfile will be stored.
|
||||
|
||||
* If $XDG_DATA_HOME is defined, use it;
|
||||
* else if $HOME exists, use it;
|
||||
* else if the platform is Windows, use %APPDATA%;
|
||||
* else use the current directory.
|
||||
|
||||
Returns
|
||||
-------
|
||||
str
|
||||
Path to database file.
|
||||
|
||||
Note
|
||||
----
|
||||
This function was taken from project buku.
|
||||
|
||||
See https://github.com/jarun/buku
|
||||
|
||||
* Arun Prakash Jana (jarun)
|
||||
* Dmitry Marakasov (AMDmi3)
|
||||
"""
|
||||
# data_home = xdg.BaseDirectory.xdg_data_home
|
||||
data_home = os.environ.get('XDG_DATA_HOME')
|
||||
if data_home is None:
|
||||
if os.environ.get('HOME') is None:
|
||||
if sys.platform == 'win32':
|
||||
data_home = os.environ.get('APPDATA')
|
||||
if data_home is None:
|
||||
return os.path.abspath('.slixfeed/data')
|
||||
else:
|
||||
return os.path.abspath('.slixfeed/data')
|
||||
else:
|
||||
data_home = os.path.join(
|
||||
os.environ.get('HOME'), '.local', 'share'
|
||||
)
|
||||
return os.path.join(data_home, 'slixfeed')
|
||||
|
||||
|
||||
def get_pathname_to_omemo_directory():
|
||||
"""
|
||||
Get OMEMO directory.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
None
|
||||
|
||||
Returns
|
||||
-------
|
||||
object
|
||||
Coroutine object.
|
||||
"""
|
||||
db_dir = get_default_data_directory()
|
||||
if not os.path.isdir(db_dir):
|
||||
os.mkdir(db_dir)
|
||||
if not os.path.isdir(db_dir + "/omemo"):
|
||||
os.mkdir(db_dir + "/omemo")
|
||||
omemo_dir = os.path.join(db_dir, "omemo")
|
||||
return omemo_dir
|
||||
|
||||
|
||||
def get_values(filename, key=None):
|
||||
config_dir = get_default_config_directory()
|
||||
if not os.path.isdir(config_dir):
|
||||
|
|
|
@ -36,6 +36,7 @@ NOTE
|
|||
|
||||
"""
|
||||
|
||||
import aiofiles
|
||||
from aiohttp import ClientError, ClientSession, ClientTimeout
|
||||
from asyncio import TimeoutError
|
||||
# from asyncio.exceptions import IncompleteReadError
|
||||
|
@ -45,6 +46,8 @@ from asyncio import TimeoutError
|
|||
import requests
|
||||
import slixfeed.config as config
|
||||
from slixfeed.log import Logger
|
||||
# import urllib.request
|
||||
# from urllib.error import HTTPError
|
||||
|
||||
logger = Logger(__name__)
|
||||
|
||||
|
@ -55,7 +58,6 @@ except:
|
|||
"Package magnet2torrent was not found.\n"
|
||||
"BitTorrent is disabled.")
|
||||
|
||||
|
||||
# class Dat:
|
||||
# async def dat():
|
||||
|
||||
|
@ -68,52 +70,154 @@ except:
|
|||
# class Gopher:
|
||||
# async def gopher():
|
||||
|
||||
# class Http:
|
||||
# async def http():
|
||||
|
||||
# class Ipfs:
|
||||
# async def ipfs():
|
||||
|
||||
|
||||
def http_response(url):
|
||||
"""
|
||||
Download response headers.
|
||||
class Http:
|
||||
|
||||
Parameters
|
||||
----------
|
||||
url : str
|
||||
URL.
|
||||
|
||||
Returns
|
||||
-------
|
||||
response: requests.models.Response
|
||||
HTTP Header Response.
|
||||
# def fetch_media(url, pathname):
|
||||
# try:
|
||||
# urllib.request.urlretrieve(url, pathname)
|
||||
# status = 1
|
||||
# except HTTPError as e:
|
||||
# logger.error(e)
|
||||
# status = 0
|
||||
# return status
|
||||
|
||||
Result would contain these:
|
||||
response.encoding
|
||||
response.headers
|
||||
response.history
|
||||
response.reason
|
||||
response.status_code
|
||||
response.url
|
||||
"""
|
||||
user_agent = (
|
||||
config.get_value(
|
||||
"settings", "Network", "user_agent")
|
||||
) or 'Slixfeed/0.1'
|
||||
headers = {
|
||||
"User-Agent": user_agent
|
||||
}
|
||||
try:
|
||||
# Do not use HEAD request because it appears that too many sites would
|
||||
# deny it.
|
||||
# response = requests.head(url, headers=headers, allow_redirects=True)
|
||||
response = requests.get(url, headers=headers, allow_redirects=True)
|
||||
except Exception as e:
|
||||
logger.warning('Error in HTTP response')
|
||||
logger.error(e)
|
||||
response = None
|
||||
return response
|
||||
|
||||
async def fetch_headers(url):
|
||||
network_settings = config.get_values('settings.toml', 'network')
|
||||
user_agent = (network_settings['user_agent'] or 'Slixfeed/0.1')
|
||||
headers = {'User-Agent': user_agent}
|
||||
proxy = (network_settings['http_proxy'] or None)
|
||||
timeout = ClientTimeout(total=10)
|
||||
async with ClientSession(headers=headers) as session:
|
||||
async with session.get(url, proxy=proxy,
|
||||
# proxy_auth=(proxy_username, proxy_password),
|
||||
timeout=timeout
|
||||
) as response:
|
||||
headers = response.headers
|
||||
return headers
|
||||
# print("Headers for URL:", url)
|
||||
# for header_name, header_value in headers.items():
|
||||
# print(f"{header_name}: {header_value}")
|
||||
|
||||
|
||||
# TODO Write file to disk. Consider aiofiles
|
||||
async def fetch_media(url, pathname):
|
||||
"""
|
||||
Download media content of given URL.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
url : str
|
||||
URL.
|
||||
pathname : list
|
||||
Pathname (including filename) to save content to.
|
||||
|
||||
Returns
|
||||
-------
|
||||
msg: list or str
|
||||
Document or error message.
|
||||
"""
|
||||
network_settings = config.get_values('settings.toml', 'network')
|
||||
user_agent = (network_settings['user_agent'] or 'Slixfeed/0.1')
|
||||
headers = {'User-Agent': user_agent}
|
||||
proxy = (network_settings['http_proxy'] or None)
|
||||
timeout = ClientTimeout(total=10)
|
||||
async with ClientSession(headers=headers) as session:
|
||||
# async with ClientSession(trust_env=True) as session:
|
||||
try:
|
||||
async with session.get(url, proxy=proxy,
|
||||
# proxy_auth=(proxy_username, proxy_password),
|
||||
timeout=timeout
|
||||
) as response:
|
||||
status = response.status
|
||||
if status in (200, 201):
|
||||
f = await aiofiles.open(pathname, mode='wb')
|
||||
await f.write(await response.read())
|
||||
await f.close()
|
||||
try:
|
||||
result = {'charset': response.charset,
|
||||
'content_length': response.content_length,
|
||||
'content_type': response.content_type,
|
||||
'error': False,
|
||||
'message': None,
|
||||
'original_url': url,
|
||||
'status_code': status,
|
||||
'response_url': response.url}
|
||||
except:
|
||||
result = {'error': True,
|
||||
'message': 'Could not get document.',
|
||||
'original_url': url,
|
||||
'status_code': status,
|
||||
'response_url': response.url}
|
||||
else:
|
||||
result = {'error': True,
|
||||
'message': 'HTTP Error:' + str(status),
|
||||
'original_url': url,
|
||||
'status_code': status,
|
||||
'response_url': response.url}
|
||||
except ClientError as e:
|
||||
result = {'error': True,
|
||||
'message': 'Error:' + str(e) if e else 'ClientError',
|
||||
'original_url': url,
|
||||
'status_code': None}
|
||||
except TimeoutError as e:
|
||||
result = {'error': True,
|
||||
'message': 'Timeout:' + str(e) if e else 'TimeoutError',
|
||||
'original_url': url,
|
||||
'status_code': None}
|
||||
except Exception as e:
|
||||
logger.error(e)
|
||||
result = {'error': True,
|
||||
'message': 'Error:' + str(e) if e else 'Error',
|
||||
'original_url': url,
|
||||
'status_code': None}
|
||||
return result
|
||||
|
||||
|
||||
def http_response(url):
|
||||
"""
|
||||
Download response headers.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
url : str
|
||||
URL.
|
||||
|
||||
Returns
|
||||
-------
|
||||
response: requests.models.Response
|
||||
HTTP Header Response.
|
||||
|
||||
Result would contain these:
|
||||
response.encoding
|
||||
response.headers
|
||||
response.history
|
||||
response.reason
|
||||
response.status_code
|
||||
response.url
|
||||
"""
|
||||
user_agent = (
|
||||
config.get_value(
|
||||
"settings", "Network", "user_agent")
|
||||
) or 'Slixfeed/0.1'
|
||||
headers = {
|
||||
"User-Agent": user_agent
|
||||
}
|
||||
try:
|
||||
# Do not use HEAD request because it appears that too many sites would
|
||||
# deny it.
|
||||
# response = requests.head(url, headers=headers, allow_redirects=True)
|
||||
response = requests.get(url, headers=headers, allow_redirects=True)
|
||||
except Exception as e:
|
||||
logger.warning('Error in HTTP response')
|
||||
logger.error(e)
|
||||
response = None
|
||||
return response
|
||||
|
||||
|
||||
async def http(url):
|
||||
|
|
|
@ -2762,6 +2762,39 @@ def get_active_feeds_url(db_file):
|
|||
return result
|
||||
|
||||
|
||||
def get_active_feeds_url_sorted_by_last_scanned(db_file):
|
||||
"""
|
||||
Query table feeds for active URLs and sort them by last scanned time.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db_file : str
|
||||
Path to database file.
|
||||
|
||||
Returns
|
||||
-------
|
||||
result : tuple
|
||||
URLs of active feeds.
|
||||
"""
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: db_file: {}'
|
||||
.format(function_name, db_file))
|
||||
with create_connection(db_file) as conn:
|
||||
cur = conn.cursor()
|
||||
sql = (
|
||||
"""
|
||||
SELECT feeds_properties.url
|
||||
FROM feeds_properties
|
||||
INNER JOIN feeds_preferences ON feeds_properties.id = feeds_preferences.feed_id
|
||||
INNER JOIN feeds_state ON feeds_properties.id = feeds_state.feed_id
|
||||
WHERE feeds_preferences.enabled = 1
|
||||
ORDER BY feeds_state.scanned
|
||||
"""
|
||||
)
|
||||
result = cur.execute(sql).fetchall()
|
||||
return result
|
||||
|
||||
|
||||
def get_tags(db_file):
|
||||
"""
|
||||
Query table tags and list items.
|
||||
|
|
|
@ -348,7 +348,7 @@ class Feed:
|
|||
if new_entries:
|
||||
await sqlite.add_entries_and_update_feed_state(
|
||||
db_file, feed_id, new_entries)
|
||||
old = Config.get_setting_value(self.settings, jid_bare, 'old')
|
||||
old = Config.get_setting_value(self, jid_bare, 'old')
|
||||
if not old: await sqlite.mark_feed_as_read(db_file, feed_id)
|
||||
result_final = {'link' : url,
|
||||
'index' : feed_id,
|
||||
|
@ -1276,7 +1276,7 @@ class FeedTask:
|
|||
logger.info('Scanning for updates for JID {}'.format(jid_bare))
|
||||
while True:
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
urls = sqlite.get_active_feeds_url(db_file)
|
||||
urls = sqlite.get_active_feeds_url_sorted_by_last_scanned(db_file)
|
||||
for url in urls:
|
||||
Message.printer('Scanning updates for URL {} ...'.format(url))
|
||||
url = url[0]
|
||||
|
@ -1335,7 +1335,7 @@ class FeedTask:
|
|||
new_entries.extend([new_entry])
|
||||
if new_entries:
|
||||
await sqlite.add_entries_and_update_feed_state(db_file, feed_id, new_entries)
|
||||
limit = Config.get_setting_value(self.settings, jid_bare, 'archive')
|
||||
limit = Config.get_setting_value(self, jid_bare, 'archive')
|
||||
ixs = sqlite.get_entries_id_of_feed(db_file, feed_id)
|
||||
ixs_invalid = {}
|
||||
for ix in ixs:
|
||||
|
@ -1360,8 +1360,8 @@ class FeedTask:
|
|||
# TODO return number of archived entries and add if statement to run archive maintainence function
|
||||
await sqlite.maintain_archive(db_file, limit)
|
||||
# await sqlite.process_invalid_entries(db_file, ixs)
|
||||
await asyncio.sleep(50)
|
||||
val = Config.get_setting_value(self.settings, jid_bare, 'check')
|
||||
await asyncio.sleep(60 * 2)
|
||||
val = Config.get_setting_value(self, jid_bare, 'check')
|
||||
await asyncio.sleep(60 * float(val))
|
||||
# Schedule to call this function again in 90 minutes
|
||||
# loop.call_at(
|
||||
|
|
|
@ -67,6 +67,107 @@ except:
|
|||
logger = Logger(__name__)
|
||||
|
||||
|
||||
class Config:
|
||||
|
||||
|
||||
def get_default_data_directory():
|
||||
if os.environ.get('HOME'):
|
||||
data_home = os.path.join(os.environ.get('HOME'), '.local', 'share')
|
||||
return os.path.join(data_home, 'kaikout')
|
||||
elif sys.platform == 'win32':
|
||||
data_home = os.environ.get('APPDATA')
|
||||
if data_home is None:
|
||||
return os.path.join(
|
||||
os.path.dirname(__file__) + '/kaikout_data')
|
||||
else:
|
||||
return os.path.join(os.path.dirname(__file__) + '/kaikout_data')
|
||||
|
||||
|
||||
def get_default_config_directory():
|
||||
"""
|
||||
Determine the directory path where configuration will be stored.
|
||||
|
||||
* If $XDG_CONFIG_HOME is defined, use it;
|
||||
* else if $HOME exists, use it;
|
||||
* else if the platform is Windows, use %APPDATA%;
|
||||
* else use the current directory.
|
||||
|
||||
Returns
|
||||
-------
|
||||
str
|
||||
Path to configuration directory.
|
||||
"""
|
||||
# config_home = xdg.BaseDirectory.xdg_config_home
|
||||
config_home = os.environ.get('XDG_CONFIG_HOME')
|
||||
if config_home is None:
|
||||
if os.environ.get('HOME') is None:
|
||||
if sys.platform == 'win32':
|
||||
config_home = os.environ.get('APPDATA')
|
||||
if config_home is None:
|
||||
return os.path.abspath('.')
|
||||
else:
|
||||
return os.path.abspath('.')
|
||||
else:
|
||||
config_home = os.path.join(
|
||||
os.environ.get('HOME'), '.config'
|
||||
)
|
||||
return os.path.join(config_home, 'kaikout')
|
||||
|
||||
|
||||
def get_setting_value(db_file, key):
|
||||
value = sqlite.get_setting_value(db_file, key)
|
||||
if value:
|
||||
value = value[0]
|
||||
else:
|
||||
value = Config.get_value('settings', 'Settings', key)
|
||||
return value
|
||||
|
||||
|
||||
def get_values(filename, key=None):
|
||||
config_dir = Config.get_default_config_directory()
|
||||
if not os.path.isdir(config_dir):
|
||||
config_dir = '/usr/share/slixfeed/'
|
||||
if not os.path.isdir(config_dir):
|
||||
config_dir = os.path.dirname(__file__) + "/assets"
|
||||
config_file = os.path.join(config_dir, filename)
|
||||
with open(config_file, mode="rb") as defaults:
|
||||
result = tomllib.load(defaults)
|
||||
values = result[key] if key else result
|
||||
return values
|
||||
|
||||
|
||||
class Database:
|
||||
|
||||
|
||||
def instantiate(jid_bare):
|
||||
"""
|
||||
Callback function to instantiate action on database.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
jid_file : str
|
||||
Filename.
|
||||
callback : ?
|
||||
Function name.
|
||||
message : str, optional
|
||||
Optional kwarg when a message is a part or
|
||||
required argument. The default is None.
|
||||
|
||||
Returns
|
||||
-------
|
||||
object
|
||||
Coroutine object.
|
||||
"""
|
||||
db_dir = Config.get_default_data_directory()
|
||||
if not os.path.isdir(db_dir):
|
||||
os.mkdir(db_dir)
|
||||
if not os.path.isdir(db_dir + "/sqlite"):
|
||||
os.mkdir(db_dir + "/sqlite")
|
||||
db_file = os.path.join(db_dir, "sqlite", r"{}.db".format(jid_bare))
|
||||
sqlite.create_tables(db_file)
|
||||
return db_file
|
||||
|
||||
|
||||
class DateAndTime:
|
||||
|
||||
#https://feedparser.readthedocs.io/en/latest/date-parsing.html
|
||||
|
@ -226,6 +327,7 @@ class Html:
|
|||
'//img[not('
|
||||
'contains(@src, "avatar") or '
|
||||
'contains(@src, "cc-by-sa") or '
|
||||
'contains(@src, "data:image/") or '
|
||||
'contains(@src, "emoji") or '
|
||||
'contains(@src, "icon") or '
|
||||
'contains(@src, "logo") or '
|
||||
|
|
|
@ -1,2 +1,2 @@
|
|||
__version__ = '0.1.85'
|
||||
__version_info__ = (0, 1, 85)
|
||||
__version__ = '0.1.92'
|
||||
__version_info__ = (0, 1, 92)
|
||||
|
|
|
@ -24,21 +24,29 @@ TODO
|
|||
"""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
from pathlib import Path
|
||||
from random import randrange # pending_tasks: Use a list and read the first index (i.e. index 0).
|
||||
import slixfeed.config as config
|
||||
from slixfeed.config import Config
|
||||
import slixfeed.fetch as fetch
|
||||
from slixfeed.fetch import Http
|
||||
from slixfeed.log import Logger
|
||||
import slixfeed.sqlite as sqlite
|
||||
from slixfeed.syndication import FeedTask
|
||||
from slixfeed.utilities import Documentation, Html, MD, Task, Url
|
||||
from slixfeed.xmpp.commands import XmppCommands
|
||||
from slixfeed.xmpp.encryption import XmppOmemo
|
||||
from slixfeed.xmpp.message import XmppMessage
|
||||
from slixfeed.xmpp.presence import XmppPresence
|
||||
from slixfeed.xmpp.status import XmppStatusTask
|
||||
from slixfeed.xmpp.upload import XmppUpload
|
||||
from slixfeed.xmpp.utilities import XmppUtilities
|
||||
from slixmpp import JID
|
||||
from slixmpp.stanza import Message
|
||||
import sys
|
||||
import time
|
||||
from typing import Optional
|
||||
|
||||
|
||||
logger = Logger(__name__)
|
||||
|
@ -55,7 +63,7 @@ logger = Logger(__name__)
|
|||
class XmppChat:
|
||||
|
||||
|
||||
async def process_message(self, message):
|
||||
async def process_message(self, message: Message, allow_untrusted: bool = False) -> None:
|
||||
"""
|
||||
Process incoming message stanzas. Be aware that this also
|
||||
includes MUC messages and error messages. It is usually
|
||||
|
@ -69,25 +77,27 @@ class XmppChat:
|
|||
for stanza objects and the Message stanza to see
|
||||
how it may be used.
|
||||
"""
|
||||
if message['type'] in ('chat', 'groupchat', 'normal'):
|
||||
jid_bare = message['from'].bare
|
||||
message_from = message['from']
|
||||
message_type = message['type']
|
||||
if message_type in ('chat', 'groupchat', 'normal'):
|
||||
jid_bare = message_from.bare
|
||||
command = ' '.join(message['body'].split())
|
||||
command_time_start = time.time()
|
||||
|
||||
# if (message['type'] == 'groupchat' and
|
||||
# if (message_type == 'groupchat' and
|
||||
# message['muc']['nick'] == self.alias):
|
||||
# return
|
||||
|
||||
# FIXME Code repetition. See below.
|
||||
# TODO Check alias by nickname associated with conference
|
||||
if message['type'] == 'groupchat':
|
||||
if message_type == 'groupchat':
|
||||
if (message['muc']['nick'] == self.alias):
|
||||
return
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message_from.full
|
||||
if not XmppUtilities.is_moderator(self, jid_bare, jid_full):
|
||||
return
|
||||
|
||||
if message['type'] == 'groupchat':
|
||||
if message_type == 'groupchat':
|
||||
# nick = message['from'][message['from'].index('/')+1:]
|
||||
# nick = str(message['from'])
|
||||
# nick = nick[nick.index('/')+1:]
|
||||
|
@ -109,7 +119,7 @@ class XmppChat:
|
|||
# if nick not in operator:
|
||||
# return
|
||||
# approved = False
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message_from.full
|
||||
if not XmppUtilities.is_moderator(self, jid_bare, jid_full):
|
||||
return
|
||||
# if role == 'moderator':
|
||||
|
@ -140,17 +150,27 @@ class XmppChat:
|
|||
|
||||
# await compose.message(self, jid_bare, message)
|
||||
|
||||
if message['type'] == 'groupchat':
|
||||
if self['xep_0384'].is_encrypted(message):
|
||||
allow_untrusted=True # Temporary fix. This should be handled by "retry""
|
||||
command, omemo_decrypted, retry = await XmppOmemo.decrypt(
|
||||
self, message, allow_untrusted)
|
||||
if retry:
|
||||
command, omemo_decrypted, retry = await XmppOmemo.decrypt(
|
||||
self, message, allow_untrusted=True)
|
||||
else:
|
||||
omemo_decrypted = None
|
||||
|
||||
if message_type == 'groupchat':
|
||||
command = command[1:]
|
||||
command_lowercase = command.lower()
|
||||
|
||||
logger.debug([str(message['from']), ':', command])
|
||||
logger.debug([message_from.full, ':', command])
|
||||
|
||||
# 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
|
||||
jid_full = str(message['from'])
|
||||
if message_type == 'chat' and message.get_plugin('muc', check=True):
|
||||
# jid_bare = message_from.bare
|
||||
jid_full = message_from.full
|
||||
if (jid_bare == jid_full[:jid_full.index('/')]):
|
||||
# TODO Count and alert of MUC-PM attempts
|
||||
return
|
||||
|
@ -217,7 +237,7 @@ class XmppChat:
|
|||
command = command[4:]
|
||||
url = command.split(' ')[0]
|
||||
title = ' '.join(command.split(' ')[1:])
|
||||
response = XmppCommands.feed_add(
|
||||
response = await XmppCommands.feed_add(
|
||||
url, db_file, jid_bare, title)
|
||||
case _ if command_lowercase.startswith('allow +'):
|
||||
val = command[7:]
|
||||
|
@ -327,15 +347,25 @@ class XmppChat:
|
|||
# self.pending_tasks[jid_bare][self.pending_tasks_counter] = status_message
|
||||
XmppPresence.send(self, jid_bare, status_message,
|
||||
status_type=status_type)
|
||||
filename, response = XmppCommands.export_feeds(
|
||||
pathname, response = XmppCommands.export_feeds(
|
||||
jid_bare, ext)
|
||||
url = await XmppUpload.start(self, jid_bare, filename)
|
||||
encrypt_omemo = Config.get_setting_value(self, jid_bare, 'omemo')
|
||||
encrypted = True if encrypt_omemo else False
|
||||
url = await XmppUpload.start(self, jid_bare, Path(pathname), encrypted=encrypted)
|
||||
# response = (
|
||||
# 'Feeds exported successfully to {}.\n{}'
|
||||
# ).format(ex, url)
|
||||
# XmppMessage.send_oob_reply_message(message, url, response)
|
||||
chat_type = await XmppUtilities.get_chat_type(self, jid_bare)
|
||||
XmppMessage.send_oob(self, jid_bare, url, chat_type)
|
||||
if url:
|
||||
chat_type = await XmppUtilities.get_chat_type(self, jid_bare)
|
||||
if encrypted:
|
||||
url_encrypted, omemo_encrypted = await XmppOmemo.encrypt(
|
||||
self, message_from, url)
|
||||
XmppMessage.send_omemo_oob(self, message_from, url_encrypted, chat_type)
|
||||
else:
|
||||
XmppMessage.send_oob(self, jid_bare, url, chat_type)
|
||||
else:
|
||||
response = 'OPML file export has been failed.'
|
||||
del self.pending_tasks[jid_bare][pending_tasks_num]
|
||||
# del self.pending_tasks[jid_bare][self.pending_tasks_counter]
|
||||
XmppStatusTask.restart_task(self, jid_bare)
|
||||
|
@ -353,7 +383,7 @@ class XmppChat:
|
|||
response = (first_line + result +
|
||||
'\n```\nTotal of {} feeds'.format(number))
|
||||
case 'goodbye':
|
||||
if message['type'] == 'groupchat':
|
||||
if message_type == 'groupchat':
|
||||
await XmppCommands.muc_leave(self, jid_bare)
|
||||
else:
|
||||
response = 'This command is valid in groupchat only.'
|
||||
|
@ -378,18 +408,18 @@ class XmppChat:
|
|||
# del self.pending_tasks[jid_bare][self.pending_tasks_counter]
|
||||
XmppStatusTask.restart_task(self, jid_bare)
|
||||
case _ if command_lowercase.startswith('pubsub list'):
|
||||
jid = command[12:]
|
||||
response = 'List of nodes for {}:\n```\n'.format(jid)
|
||||
response = await XmppCommands.pubsub_list(self, jid)
|
||||
jid_full_pubsub = command[12:]
|
||||
response = 'List of nodes for {}:\n```\n'.format(jid_full_pubsub)
|
||||
response = await XmppCommands.pubsub_list(self, jid_full_pubsub)
|
||||
response += '```'
|
||||
case _ if command_lowercase.startswith('pubsub send'):
|
||||
if XmppUtilities.is_operator(self, jid_bare):
|
||||
info = command[12:]
|
||||
info = info.split(' ')
|
||||
jid = info[0]
|
||||
jid_full_pubsub = info[0]
|
||||
# num = int(info[1])
|
||||
if jid:
|
||||
response = XmppCommands.pubsub_send(self, info, jid)
|
||||
if jid_full_pubsub:
|
||||
response = XmppCommands.pubsub_send(self, info, jid_full_pubsub)
|
||||
else:
|
||||
response = ('This action is restricted. '
|
||||
'Type: sending news to PubSub.')
|
||||
|
@ -453,6 +483,13 @@ class XmppChat:
|
|||
self, jid_bare, db_file)
|
||||
case _ if command_lowercase.startswith('next'):
|
||||
num = command[5:]
|
||||
if num:
|
||||
try:
|
||||
int(num)
|
||||
except:
|
||||
# NOTE Show this text as a status message
|
||||
# response = 'Argument for command "next" must be an integer.'
|
||||
num = None
|
||||
await XmppChatAction.send_unread_items(self, jid_bare, num)
|
||||
XmppStatusTask.restart_task(self, jid_bare)
|
||||
case _ if command_lowercase.startswith('node delete'):
|
||||
|
@ -474,6 +511,12 @@ class XmppChat:
|
|||
case 'old':
|
||||
response = await XmppCommands.set_old_on(
|
||||
self, jid_bare, db_file)
|
||||
case 'omemo off':
|
||||
response = await XmppCommands.set_omemo_off(
|
||||
self, jid_bare, db_file)
|
||||
case 'omemo on':
|
||||
response = await XmppCommands.set_omemo_on(
|
||||
self, jid_bare, db_file)
|
||||
case 'options':
|
||||
response = 'Options:\n```'
|
||||
response += XmppCommands.print_options(self, jid_bare)
|
||||
|
@ -552,9 +595,9 @@ class XmppChat:
|
|||
XmppPresence.send(self, jid_bare, status_message,
|
||||
status_type=status_type)
|
||||
await asyncio.sleep(5)
|
||||
tasks = (FeedTask, XmppChatTask, XmppStatusTask)
|
||||
callbacks = (FeedTask, XmppChatTask, XmppStatusTask)
|
||||
response = await XmppCommands.scheduler_start(
|
||||
self, db_file, jid_bare, tasks)
|
||||
self, db_file, jid_bare, callbacks)
|
||||
case 'stats':
|
||||
response = XmppCommands.print_statistics(db_file)
|
||||
case 'stop':
|
||||
|
@ -581,8 +624,20 @@ class XmppChat:
|
|||
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 Config.get_setting_value(self.settings, jid_bare, 'finished'):
|
||||
if response:
|
||||
encrypt_omemo = Config.get_setting_value(self, jid_bare, 'omemo')
|
||||
encrypted = True if encrypt_omemo else False
|
||||
if encrypted and self['xep_0384'].is_encrypted(message):
|
||||
response_encrypted, omemo_encrypted = await XmppOmemo.encrypt(
|
||||
self, message_from, response)
|
||||
if omemo_decrypted and omemo_encrypted:
|
||||
# message_from = message['from']
|
||||
# message_type = message['type']
|
||||
XmppMessage.send_omemo(self, message_from, message_type, response_encrypted)
|
||||
# XmppMessage.send_omemo_reply(self, message, response_encrypted)
|
||||
else:
|
||||
XmppMessage.send_reply(self, message, response)
|
||||
if Config.get_setting_value(self, jid_bare, 'finished'):
|
||||
response_finished = 'Finished. Total time: {}s'.format(command_time_total)
|
||||
XmppMessage.send_reply(self, message, response_finished)
|
||||
|
||||
|
@ -610,13 +665,13 @@ class XmppChat:
|
|||
class XmppChatAction:
|
||||
|
||||
|
||||
async def send_unread_items(self, jid_bare, num=None):
|
||||
async def send_unread_items(self, jid_bare, num: Optional[int] = None):
|
||||
"""
|
||||
Send news items as messages.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
jid : str
|
||||
jid_bare : str
|
||||
Jabber ID.
|
||||
num : str, optional
|
||||
Number. The default is None.
|
||||
|
@ -624,14 +679,17 @@ class XmppChatAction:
|
|||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid: {} num: {}'.format(function_name, jid_bare, num))
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
show_media = Config.get_setting_value(self.settings, jid_bare, 'media')
|
||||
encrypt_omemo = Config.get_setting_value(self, jid_bare, 'omemo')
|
||||
encrypted = True if encrypt_omemo else False
|
||||
jid = JID(jid_bare)
|
||||
show_media = Config.get_setting_value(self, jid_bare, 'media')
|
||||
if not num:
|
||||
num = Config.get_setting_value(self.settings, jid_bare, 'quantum')
|
||||
num = Config.get_setting_value(self, jid_bare, 'quantum')
|
||||
else:
|
||||
num = int(num)
|
||||
results = sqlite.get_unread_entries(db_file, num)
|
||||
news_digest = ''
|
||||
media = None
|
||||
media_url = None
|
||||
chat_type = await XmppUtilities.get_chat_type(self, jid_bare)
|
||||
for result in results:
|
||||
ix = result[0]
|
||||
|
@ -658,20 +716,92 @@ class XmppChatAction:
|
|||
# elif enclosure:
|
||||
if show_media:
|
||||
if enclosure:
|
||||
media = enclosure
|
||||
media_url = enclosure
|
||||
else:
|
||||
media = await Html.extract_image_from_html(url)
|
||||
media_url = await Html.extract_image_from_html(url)
|
||||
try:
|
||||
http_headers = await Http.fetch_headers(media_url)
|
||||
if ('Content-Length' in http_headers):
|
||||
if int(http_headers['Content-Length']) < 100000:
|
||||
media_url = None
|
||||
else:
|
||||
media_url = None
|
||||
except Exception as e:
|
||||
print(media_url)
|
||||
logger.error(e)
|
||||
media_url = None
|
||||
|
||||
if media and news_digest:
|
||||
# Send textual message
|
||||
XmppMessage.send(self, jid_bare, news_digest, chat_type)
|
||||
if media_url and news_digest:
|
||||
if encrypt_omemo:
|
||||
news_digest_encrypted, omemo_encrypted = await XmppOmemo.encrypt(
|
||||
self, jid, news_digest)
|
||||
if encrypt_omemo and omemo_encrypted:
|
||||
XmppMessage.send_omemo(self, jid, chat_type, news_digest_encrypted)
|
||||
else:
|
||||
# Send textual message
|
||||
XmppMessage.send(self, jid_bare, news_digest, chat_type)
|
||||
news_digest = ''
|
||||
# Send media
|
||||
XmppMessage.send_oob(self, jid_bare, media, chat_type)
|
||||
media = None
|
||||
if encrypt_omemo:
|
||||
cache_dir = config.get_default_cache_directory()
|
||||
# if not media_url.startswith('data:'):
|
||||
filename = media_url.split('/').pop().split('?')[0]
|
||||
if not filename: breakpoint()
|
||||
pathname = os.path.join(cache_dir, filename)
|
||||
# http_response = await Http.response(media_url)
|
||||
http_headers = await Http.fetch_headers(media_url)
|
||||
if ('Content-Length' in http_headers and
|
||||
int(http_headers['Content-Length']) < 3000000):
|
||||
status = await Http.fetch_media(media_url, pathname)
|
||||
if status:
|
||||
filesize = os.path.getsize(pathname)
|
||||
media_url_new = await XmppUpload.start(
|
||||
self, jid_bare, Path(pathname), filesize, encrypted=encrypted)
|
||||
else:
|
||||
media_url_new = media_url
|
||||
else:
|
||||
media_url_new = media_url
|
||||
# else:
|
||||
# import io, base64
|
||||
# from PIL import Image
|
||||
# file_content = media_url.split(',').pop()
|
||||
# file_extension = media_url.split(';')[0].split(':').pop().split('/').pop()
|
||||
# img = Image.open(io.BytesIO(base64.decodebytes(bytes(file_content, "utf-8"))))
|
||||
# filename = 'image.' + file_extension
|
||||
# pathname = os.path.join(cache_dir, filename)
|
||||
# img.save(pathname)
|
||||
# filesize = os.path.getsize(pathname)
|
||||
# media_url_new = await XmppUpload.start(
|
||||
# self, jid_bare, Path(pathname), filesize, encrypted=encrypted)
|
||||
media_url_new_encrypted, omemo_encrypted = await XmppOmemo.encrypt(
|
||||
self, jid, media_url_new)
|
||||
if media_url_new_encrypted and omemo_encrypted:
|
||||
# NOTE Tested against Gajim.
|
||||
# FIXME This only works with aesgcm URLs, and it does
|
||||
# not work with http URLs.
|
||||
# url = saxutils.escape(url)
|
||||
# AttributeError: 'Encrypted' object has no attribute 'replace'
|
||||
XmppMessage.send_omemo_oob(self, jid, media_url_new_encrypted, chat_type)
|
||||
else:
|
||||
# NOTE Tested against Gajim.
|
||||
# FIXME Jandle data: URIs.
|
||||
if not media_url.startswith('data:'):
|
||||
http_headers = await Http.fetch_headers(media_url)
|
||||
if ('Content-Length' in http_headers and
|
||||
int(http_headers['Content-Length']) > 100000):
|
||||
print(http_headers['Content-Length'])
|
||||
XmppMessage.send_oob(self, jid_bare, media_url, chat_type)
|
||||
else:
|
||||
XmppMessage.send_oob(self, jid_bare, media_url, chat_type)
|
||||
media_url = None
|
||||
|
||||
if news_digest:
|
||||
XmppMessage.send(self, jid_bare, news_digest, chat_type)
|
||||
if encrypt_omemo: news_digest_encrypted, omemo_encrypted = await XmppOmemo.encrypt(
|
||||
self, jid, news_digest)
|
||||
if encrypt_omemo and omemo_encrypted:
|
||||
XmppMessage.send_omemo(self, jid, chat_type, news_digest_encrypted)
|
||||
else:
|
||||
XmppMessage.send(self, jid_bare, news_digest, chat_type)
|
||||
# TODO Add while loop to assure delivery.
|
||||
# print(await current_time(), ">>> ACT send_message",jid)
|
||||
# NOTE Do we need "if statement"? See NOTE at is_muc.
|
||||
|
@ -756,7 +886,7 @@ class XmppChatAction:
|
|||
summary = summary.replace(' ', ' ')
|
||||
# summary = summary.replace(' ', ' ')
|
||||
summary = ' '.join(summary.split())
|
||||
length = Config.get_setting_value(self.settings, jid, 'length')
|
||||
length = Config.get_setting_value(self, jid, 'length')
|
||||
length = int(length)
|
||||
summary = summary[:length] + " […]"
|
||||
# summary = summary.strip().split('\n')
|
||||
|
@ -770,7 +900,7 @@ class XmppChatAction:
|
|||
feed_id = result[4]
|
||||
# news_item = ("\n{}\n{}\n{} [{}]\n").format(str(title), str(link),
|
||||
# str(feed_title), str(ix))
|
||||
formatting = Config.get_setting_value(self.settings, jid, 'formatting')
|
||||
formatting = Config.get_setting_value(self, jid, 'formatting')
|
||||
news_item = formatting.format(feed_title=feed_title,
|
||||
title=title,
|
||||
summary=summary,
|
||||
|
@ -787,9 +917,9 @@ class XmppChatTask:
|
|||
async def task_message(self, jid_bare):
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
if jid_bare not in self.settings:
|
||||
Config.add_settings_jid(self.settings, jid_bare, db_file)
|
||||
Config.add_settings_jid(self, jid_bare, db_file)
|
||||
while True:
|
||||
update_interval = Config.get_setting_value(self.settings, jid_bare, 'interval')
|
||||
update_interval = Config.get_setting_value(self, jid_bare, 'interval')
|
||||
update_interval = 60 * int(update_interval)
|
||||
last_update_time = sqlite.get_last_update_time(db_file)
|
||||
if last_update_time:
|
||||
|
|
|
@ -31,8 +31,9 @@ NOTE
|
|||
|
||||
import asyncio
|
||||
from datetime import datetime
|
||||
import os
|
||||
from feedparser import parse
|
||||
import os
|
||||
from pathlib import Path
|
||||
import slixmpp
|
||||
# from slixmpp.plugins.xep_0363.http_upload import FileTooBig, HTTPError, UploadServiceNotFound
|
||||
# from slixmpp.plugins.xep_0402 import BookmarkStorage, Conference
|
||||
|
@ -43,7 +44,7 @@ import slixmpp
|
|||
# from lxml import etree
|
||||
|
||||
import slixfeed.config as config
|
||||
from slixfeed.config import Config
|
||||
from slixfeed.config import Config, Data
|
||||
import slixfeed.fetch as fetch
|
||||
from slixfeed.log import Logger
|
||||
import slixfeed.sqlite as sqlite
|
||||
|
@ -53,11 +54,12 @@ from slixfeed.version import __version__
|
|||
from slixfeed.xmpp.bookmark import XmppBookmark
|
||||
from slixfeed.xmpp.chat import XmppChat, XmppChatTask
|
||||
from slixfeed.xmpp.connect import XmppConnect, XmppConnectTask
|
||||
from slixfeed.xmpp.encryption import XmppOmemo
|
||||
from slixfeed.xmpp.groupchat import XmppGroupchat
|
||||
from slixfeed.xmpp.ipc import XmppIpcServer
|
||||
from slixfeed.xmpp.iq import XmppIQ
|
||||
from slixfeed.xmpp.message import XmppMessage
|
||||
from slixfeed.xmpp.muc import XmppMuc
|
||||
from slixfeed.xmpp.groupchat import XmppGroupchat
|
||||
from slixfeed.xmpp.presence import XmppPresence
|
||||
import slixfeed.xmpp.profile as profile
|
||||
from slixfeed.xmpp.publish import XmppPubsub, XmppPubsubAction, XmppPubsubTask
|
||||
|
@ -66,6 +68,9 @@ from slixfeed.xmpp.roster import XmppRoster
|
|||
from slixfeed.xmpp.status import XmppStatusTask
|
||||
from slixfeed.xmpp.upload import XmppUpload
|
||||
from slixfeed.xmpp.utilities import XmppUtilities
|
||||
from slixmpp import JID
|
||||
import slixmpp_omemo
|
||||
from slixmpp_omemo import PluginCouldNotLoad
|
||||
import sys
|
||||
import time
|
||||
|
||||
|
@ -112,14 +117,16 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
# Handler for ping
|
||||
self.task_ping_instance = {}
|
||||
|
||||
# Handler for default configuration
|
||||
self.defaults = config.get_values('settings.toml')
|
||||
# Handler for configuration
|
||||
self.settings = config.get_values('settings.toml')
|
||||
self.settings = {}
|
||||
# Handler for operators
|
||||
self.operators = config.get_values('accounts.toml', 'xmpp')['operators']
|
||||
|
||||
# self.settings = {}
|
||||
# # Populate dict handler
|
||||
# Config.add_settings_default(self.settings)
|
||||
# Config.add_settings_default(self)
|
||||
|
||||
# Handlers for connection events
|
||||
self.connection_attempts = 0
|
||||
|
@ -147,6 +154,21 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
self.register_plugin('xep_0363') # HTTP File Upload
|
||||
self.register_plugin('xep_0402') # PEP Native Bookmarks
|
||||
self.register_plugin('xep_0444') # Message Reactions
|
||||
try:
|
||||
self.register_plugin(
|
||||
'xep_0384',
|
||||
{
|
||||
'data_dir': Data.get_pathname_to_omemo_directory(),
|
||||
},
|
||||
module=slixmpp_omemo,) # OMEMO Encryption
|
||||
except (PluginCouldNotLoad,):
|
||||
logger.error('An error has occured when loading the OMEMO plugin.')
|
||||
sys.exit(1)
|
||||
try:
|
||||
self.register_plugin('xep_0454')
|
||||
except slixmpp.plugins.base.PluginNotFound:
|
||||
logger.error('Could not load xep_0454. Ensure you have '
|
||||
'\'cryptography\' from extras_require installed.')
|
||||
|
||||
# proxy_enabled = config.get_value('accounts', 'XMPP', 'proxy_enabled')
|
||||
# if proxy_enabled == '1':
|
||||
|
@ -230,7 +252,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
# TODO Test
|
||||
async def on_groupchat_invite(self, message):
|
||||
time_begin = time.time()
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -268,7 +290,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
# NOTE Tested with Gajim and Psi
|
||||
async def on_groupchat_direct_invite(self, message):
|
||||
time_begin = time.time()
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -333,12 +355,12 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
# jid_bare = result['jid']
|
||||
# if jid_bare not in self.settings:
|
||||
# db_file = config.get_pathname_to_database(jid_bare)
|
||||
# Config.add_settings_jid(self.settings, jid_bare, db_file)
|
||||
# Config.add_settings_jid(self, jid_bare, db_file)
|
||||
# await FeedTask.check_updates(self, jid_bare)
|
||||
# XmppPubsubTask.task_publish(self, jid_bare)
|
||||
bookmarks = await XmppBookmark.get_bookmarks(self)
|
||||
await XmppGroupchat.autojoin(self, bookmarks)
|
||||
if 'ipc' in self.settings and self.settings['ipc']['bsd']:
|
||||
if 'ipc' in self.defaults and self.defaults['ipc']['bsd']:
|
||||
# Start Inter-Process Communication
|
||||
print('POSIX sockets: Initiating IPC server...')
|
||||
self.ipc = asyncio.create_task(XmppIpcServer.ipc(self))
|
||||
|
@ -366,7 +388,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
async def on_disco_info(self, DiscoInfo):
|
||||
time_begin = time.time()
|
||||
jid_full = str(DiscoInfo['from'])
|
||||
jid_full = DiscoInfo['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -381,14 +403,14 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
async def on_message(self, message):
|
||||
time_begin = time.time()
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
jid_bare = message['from'].bare
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
if jid_bare not in self.settings:
|
||||
Config.add_settings_jid(self.settings, jid_bare, db_file)
|
||||
Config.add_settings_jid(self, jid_bare, db_file)
|
||||
if jid_bare == self.boundjid.bare:
|
||||
status_type = 'dnd'
|
||||
status_message = ('Slixfeed is not designed to receive messages '
|
||||
|
@ -427,7 +449,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
async def on_changed_status(self, presence):
|
||||
time_begin = time.time()
|
||||
jid_full = str(presence['from'])
|
||||
jid_full = presence['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -452,7 +474,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
async def on_presence_subscribe(self, presence):
|
||||
time_begin = time.time()
|
||||
jid_full = str(presence['from'])
|
||||
jid_full = presence['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -475,7 +497,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
def on_presence_subscribed(self, presence):
|
||||
time_begin = time.time()
|
||||
jid_full = str(presence['from'])
|
||||
jid_full = presence['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -497,7 +519,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
async def on_presence_available(self, presence):
|
||||
time_begin = time.time()
|
||||
jid_full = str(presence['from'])
|
||||
jid_full = presence['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -521,7 +543,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
def on_presence_unsubscribed(self, presence):
|
||||
time_begin = time.time()
|
||||
jid_full = str(presence['from'])
|
||||
jid_full = presence['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -542,7 +564,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
def on_presence_unavailable(self, presence):
|
||||
time_begin = time.time()
|
||||
jid_full = str(presence['from'])
|
||||
jid_full = presence['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -570,7 +592,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
# If bookmarks, remove groupchat JID into file
|
||||
def on_presence_error(self, presence):
|
||||
time_begin = time.time()
|
||||
jid_full = str(presence['from'])
|
||||
jid_full = presence['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -590,7 +612,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
async def on_chatstate_active(self, message):
|
||||
time_begin = time.time()
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -613,7 +635,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
async def on_chatstate_composing(self, message):
|
||||
# print('on_chatstate_composing START')
|
||||
time_begin = time.time()
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -636,7 +658,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
def on_chatstate_gone(self, message):
|
||||
time_begin = time.time()
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -653,7 +675,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
def on_chatstate_inactive(self, message):
|
||||
time_begin = time.time()
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -670,7 +692,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
def on_chatstate_paused(self, message):
|
||||
time_begin = time.time()
|
||||
jid_full = str(message['from'])
|
||||
jid_full = message['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
message_log = '{}: jid_full: {}'
|
||||
logger.debug(message_log.format(function_name, jid_full))
|
||||
|
@ -832,7 +854,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
# http://jabber.org/protocol/commands#actions
|
||||
|
||||
async def _handle_publish(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -873,7 +895,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
return session
|
||||
|
||||
async def _handle_publish_action(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -981,7 +1003,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
return session
|
||||
|
||||
async def _handle_publish_db_preview(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1089,7 +1111,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_publish_url_preview(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1281,14 +1303,14 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
return session
|
||||
|
||||
async def _handle_profile(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
jid_bare = session['from'].bare
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
if jid_bare not in self.settings:
|
||||
Config.add_settings_jid(self.settings, jid_bare, db_file)
|
||||
Config.add_settings_jid(self, jid_bare, db_file)
|
||||
form = self['xep_0004'].make_form('form', 'Profile')
|
||||
form['instructions'] = ('Displaying information\nJabber ID {}'
|
||||
.format(jid_bare))
|
||||
|
@ -1312,42 +1334,42 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
value=unread)
|
||||
form.add_field(ftype='fixed',
|
||||
label='Options')
|
||||
key_archive = Config.get_setting_value(self.settings, jid_bare, 'archive')
|
||||
key_archive = Config.get_setting_value(self, jid_bare, 'archive')
|
||||
key_archive = str(key_archive)
|
||||
form.add_field(label='Archive',
|
||||
ftype='text-single',
|
||||
value=key_archive)
|
||||
key_enabled = Config.get_setting_value(self.settings, jid_bare, 'enabled')
|
||||
key_enabled = Config.get_setting_value(self, jid_bare, 'enabled')
|
||||
key_enabled = str(key_enabled)
|
||||
form.add_field(label='Enabled',
|
||||
ftype='text-single',
|
||||
value=key_enabled)
|
||||
key_interval = Config.get_setting_value(self.settings, jid_bare, 'interval')
|
||||
key_interval = Config.get_setting_value(self, jid_bare, 'interval')
|
||||
key_interval = str(key_interval)
|
||||
form.add_field(label='Interval',
|
||||
ftype='text-single',
|
||||
value=key_interval)
|
||||
key_length = Config.get_setting_value(self.settings, jid_bare, 'length')
|
||||
key_length = Config.get_setting_value(self, jid_bare, 'length')
|
||||
key_length = str(key_length)
|
||||
form.add_field(label='Length',
|
||||
ftype='text-single',
|
||||
value=key_length)
|
||||
key_media = Config.get_setting_value(self.settings, jid_bare, 'media')
|
||||
key_media = Config.get_setting_value(self, jid_bare, 'media')
|
||||
key_media = str(key_media)
|
||||
form.add_field(label='Media',
|
||||
ftype='text-single',
|
||||
value=key_media)
|
||||
key_old = Config.get_setting_value(self.settings, jid_bare, 'old')
|
||||
key_old = Config.get_setting_value(self, jid_bare, 'old')
|
||||
key_old = str(key_old)
|
||||
form.add_field(label='Old',
|
||||
ftype='text-single',
|
||||
value=key_old)
|
||||
key_quantum = Config.get_setting_value(self.settings, jid_bare, 'quantum')
|
||||
key_quantum = Config.get_setting_value(self, jid_bare, 'quantum')
|
||||
key_quantum = str(key_quantum)
|
||||
form.add_field(label='Quantum',
|
||||
ftype='text-single',
|
||||
value=key_quantum)
|
||||
update_interval = Config.get_setting_value(self.settings, jid_bare, 'interval')
|
||||
update_interval = Config.get_setting_value(self, jid_bare, 'interval')
|
||||
update_interval = str(update_interval)
|
||||
update_interval = 60 * int(update_interval)
|
||||
last_update_time = sqlite.get_last_update_time(db_file)
|
||||
|
@ -1383,7 +1405,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
return session
|
||||
|
||||
async def _handle_filters(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1456,7 +1478,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
session. Additional, custom data may be saved
|
||||
here to persist across handler callbacks.
|
||||
"""
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1492,7 +1514,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscription_add(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1555,7 +1577,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_recent(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1606,7 +1628,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_recent_result(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1663,7 +1685,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
# FIXME
|
||||
async def _handle_recent_select(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1736,7 +1758,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscription_new(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1940,7 +1962,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscription_toggle(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1965,7 +1987,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscription_del_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -1993,7 +2015,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
def _handle_cancel(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2006,7 +2028,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_discover(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2044,7 +2066,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
def _handle_discover_type(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2100,7 +2122,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_discover_category(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2130,7 +2152,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscriptions(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2195,7 +2217,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscriptions_result(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2289,7 +2311,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscription_tag(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2327,7 +2349,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscription_edit(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2424,7 +2446,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
# TODO Create a new form. Do not "recycle" the last form.
|
||||
async def _handle_subscription_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2490,7 +2512,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_advanced(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2532,7 +2554,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_advanced_result(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2679,7 +2701,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_about(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2704,7 +2726,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_about_result(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2768,7 +2790,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_motd(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2781,7 +2803,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_help(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2822,7 +2844,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_import_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -2863,12 +2885,11 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_export_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
form = self['xep_0004'].make_form('result', 'Done')
|
||||
form['instructions'] = 'Export has been completed successfully!'
|
||||
# form['type'] = 'result'
|
||||
values = payload['values']
|
||||
jid_bare = session['from'].bare
|
||||
|
@ -2880,17 +2901,30 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
exts = values['filetype']
|
||||
for ext in exts:
|
||||
filename = Feed.export_feeds(jid_bare, ext)
|
||||
url = await XmppUpload.start(self, jid_bare, filename)
|
||||
chat_type = await XmppUtilities.get_chat_type(self, jid_bare)
|
||||
XmppMessage.send_oob(self, jid_bare, url, chat_type)
|
||||
url_field = form.add_field(var=ext.upper(),
|
||||
ftype='text-single',
|
||||
label=ext,
|
||||
value=url)
|
||||
url_field['validate']['datatype'] = 'xs:anyURI'
|
||||
session["has_next"] = False
|
||||
session['next'] = None
|
||||
session['payload'] = form
|
||||
encrypt_omemo = Config.get_setting_value(self, jid_bare, 'omemo')
|
||||
encrypted = True if encrypt_omemo else False
|
||||
url = await XmppUpload.start(
|
||||
self, jid_bare, Path(filename), encrypted=encrypted)
|
||||
if url:
|
||||
form['instructions'] = 'Export has been completed successfully!'
|
||||
chat_type = await XmppUtilities.get_chat_type(self, jid_bare)
|
||||
if encrypted:
|
||||
url_encrypted, omemo_encrypted = await XmppOmemo.encrypt(
|
||||
self, JID(jid_bare), url)
|
||||
XmppMessage.send_omemo_oob(self, JID(jid_bare), url_encrypted, chat_type)
|
||||
else:
|
||||
XmppMessage.send_oob(self, jid_bare, url, chat_type)
|
||||
url_field = form.add_field(var=ext.upper(),
|
||||
ftype='text-single',
|
||||
label=ext,
|
||||
value=url)
|
||||
url_field['validate']['datatype'] = 'xs:anyURI'
|
||||
session["has_next"] = False
|
||||
session['next'] = None
|
||||
session['payload'] = form
|
||||
else:
|
||||
text_warn = 'OPML file export has been failed.'
|
||||
session['notes'] = [['warn', text_warn]]
|
||||
return session
|
||||
|
||||
|
||||
|
@ -2898,12 +2932,12 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
# TODO Attempt to look up for feeds of hostname of JID (i.e. scan
|
||||
# jabber.de for feeds for juliet@jabber.de)
|
||||
async def _handle_promoted(self, iq, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
jid_bare = session['from'].bare
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
chat_type = await XmppUtilities.get_chat_type(self, jid_bare)
|
||||
if XmppUtilities.is_access(self, jid_bare, jid_full, chat_type):
|
||||
form = self['xep_0004'].make_form('form', 'Subscribe')
|
||||
|
@ -2971,7 +3005,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_admin_action(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3047,7 +3081,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
form['instructions'] = ('Select a Publish-Subscribe service '
|
||||
'of which nodes you want to list.')
|
||||
# jid_bare = self.boundjid.bare
|
||||
# enabled_state = Config.get_setting_value(self.settings, jid_bare, 'enabled')
|
||||
# enabled_state = Config.get_setting_value(self, jid_bare, 'enabled')
|
||||
|
||||
results = await XmppPubsub.get_pubsub_services(self)
|
||||
options = form.add_field(desc='Select a PubSub service.',
|
||||
|
@ -3072,7 +3106,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
ftype='fixed',
|
||||
label='Jabber ID')
|
||||
# jid_bare = self.boundjid.bare
|
||||
# enabled_state = Config.get_setting_value(self.settings, jid_bare, 'enabled')
|
||||
# enabled_state = Config.get_setting_value(self, jid_bare, 'enabled')
|
||||
|
||||
results = await XmppPubsub.get_pubsub_services(self)
|
||||
for result in results + [{'jid' : self.boundjid.bare,
|
||||
|
@ -3080,7 +3114,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
jid_bare = result['jid']
|
||||
name = result['name']
|
||||
enabled_state = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'enabled')
|
||||
self, jid_bare, 'enabled')
|
||||
form.add_field(desc=jid_bare,
|
||||
ftype='boolean',
|
||||
label=name,
|
||||
|
@ -3096,7 +3130,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
def _handle_nodes(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3124,7 +3158,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_nodes_action(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3183,7 +3217,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_node_browse(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3214,7 +3248,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_item_view(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3250,7 +3284,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
# FIXME Undefined name 'jid_bare'
|
||||
async def _handle_node_edit(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3303,7 +3337,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_nodes_purge(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3321,7 +3355,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_nodes_delete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3339,7 +3373,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_pubsub_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3351,9 +3385,9 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
value = values[key]
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
if jid_bare not in self.settings:
|
||||
Config.add_settings_jid(self.settings, jid_bare, db_file)
|
||||
await Config.set_setting_value(self.settings, jid_bare,
|
||||
db_file, 'enabled', value)
|
||||
Config.add_settings_jid(self, jid_bare, db_file)
|
||||
await Config.set_setting_value(
|
||||
self, jid_bare, db_file, 'enabled', value)
|
||||
print(self.settings)
|
||||
text_note = 'Done.'
|
||||
session['has_next'] = False
|
||||
|
@ -3364,7 +3398,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_subscribers_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3412,7 +3446,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_contact_action(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3480,7 +3514,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
def _handle_contacts_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3504,7 +3538,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_bookmarks_edit(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3569,7 +3603,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_bookmarks_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3604,7 +3638,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
session. Additional, custom data may be saved
|
||||
here to persist across handler callbacks.
|
||||
"""
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
|
@ -3613,10 +3647,10 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
if XmppUtilities.is_access(self, jid_bare, jid_full, chat_type):
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
if jid_bare not in self.settings:
|
||||
Config.add_settings_jid(self.settings, jid_bare, db_file)
|
||||
Config.add_settings_jid(self, jid_bare, db_file)
|
||||
form = self['xep_0004'].make_form('form', 'Settings')
|
||||
form['instructions'] = 'Editing settings of {}'.format(jid_bare)
|
||||
value = Config.get_setting_value(self.settings, jid_bare, 'enabled')
|
||||
value = Config.get_setting_value(self, jid_bare, 'enabled')
|
||||
value = str(value)
|
||||
value = int(value)
|
||||
if value:
|
||||
|
@ -3628,7 +3662,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
label='Enabled',
|
||||
value=value,
|
||||
var='enabled')
|
||||
value = Config.get_setting_value(self.settings, jid_bare, 'media')
|
||||
value = Config.get_setting_value(self, jid_bare, 'media')
|
||||
value = str(value)
|
||||
value = int(value)
|
||||
if value:
|
||||
|
@ -3640,7 +3674,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
label='Display media',
|
||||
value=value,
|
||||
var='media')
|
||||
value = Config.get_setting_value(self.settings, jid_bare, 'old')
|
||||
value = Config.get_setting_value(self, jid_bare, 'old')
|
||||
value = str(value)
|
||||
value = int(value)
|
||||
if value:
|
||||
|
@ -3654,7 +3688,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
label='Include old news',
|
||||
value=value,
|
||||
var='old')
|
||||
value = Config.get_setting_value(self.settings, jid_bare, 'interval')
|
||||
value = Config.get_setting_value(self, jid_bare, 'interval')
|
||||
value = str(value)
|
||||
value = int(value)
|
||||
value = value/60
|
||||
|
@ -3675,7 +3709,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
i += 6
|
||||
else:
|
||||
i += 1
|
||||
value = Config.get_setting_value(self.settings, jid_bare, 'quantum')
|
||||
value = Config.get_setting_value(self, jid_bare, 'quantum')
|
||||
value = str(value)
|
||||
options = form.add_field(desc='Amount of items per update.',
|
||||
ftype='list-single',
|
||||
|
@ -3689,7 +3723,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
x = str(i)
|
||||
options.addOption(x, x)
|
||||
i += 1
|
||||
value = Config.get_setting_value(self.settings, jid_bare, 'archive')
|
||||
value = Config.get_setting_value(self, jid_bare, 'archive')
|
||||
value = str(value)
|
||||
options = form.add_field(desc='Number of news items to archive.',
|
||||
ftype='list-single',
|
||||
|
@ -3723,14 +3757,14 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
|
||||
|
||||
async def _handle_settings_complete(self, payload, session):
|
||||
jid_full = str(session['from'])
|
||||
jid_full = session['from'].full
|
||||
function_name = sys._getframe().f_code.co_name
|
||||
logger.debug('{}: jid_full: {}'
|
||||
.format(function_name, jid_full))
|
||||
jid_bare = session['from'].bare
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
if jid_bare not in self.settings:
|
||||
Config.add_settings_jid(self.settings, jid_bare, db_file)
|
||||
Config.add_settings_jid(self, jid_bare, db_file)
|
||||
# In this case (as is typical), the payload is a form
|
||||
values = payload['values']
|
||||
for key in values:
|
||||
|
@ -3749,7 +3783,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
if val < 1: val = 1
|
||||
val = val * 60
|
||||
|
||||
is_enabled = Config.get_setting_value(self.settings, jid_bare, 'enabled')
|
||||
is_enabled = Config.get_setting_value(self, jid_bare, 'enabled')
|
||||
|
||||
if (key == 'enabled' and
|
||||
val == 1 and
|
||||
|
@ -3775,7 +3809,7 @@ class XmppClient(slixmpp.ClientXMPP):
|
|||
XmppPresence.send(self, jid_bare, status_message,
|
||||
status_type=status_type)
|
||||
|
||||
await Config.set_setting_value(self.settings, jid_bare, db_file, key, val)
|
||||
await Config.set_setting_value(self, jid_bare, db_file, key, val)
|
||||
val = self.settings[jid_bare][key]
|
||||
|
||||
if key in ('enabled', 'media', 'old'):
|
||||
|
|
|
@ -174,10 +174,8 @@ class XmppCommands:
|
|||
# the look into function "check_updates" of module "task".
|
||||
# await action.scan(self, jid_bare, db_file, url)
|
||||
# if jid_bare not in self.settings:
|
||||
# Config.add_settings_jid(self.settings, jid_bare,
|
||||
# db_file)
|
||||
# old = Config.get_setting_value(self.settings, jid_bare,
|
||||
# 'old')
|
||||
# Config.add_settings_jid(self, jid_bare, db_file)
|
||||
# old = Config.get_setting_value(self, jid_bare, 'old')
|
||||
# if old:
|
||||
# # task.clean_tasks_xmpp_chat(self, jid_bare, ['status'])
|
||||
# # await send_status(jid)
|
||||
|
@ -234,8 +232,7 @@ class XmppCommands:
|
|||
|
||||
|
||||
def get_archive(self, jid_bare):
|
||||
result = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'archive')
|
||||
result = Config.get_setting_value(self, jid_bare, 'archive')
|
||||
message = str(result)
|
||||
return message
|
||||
|
||||
|
@ -246,10 +243,9 @@ class XmppCommands:
|
|||
if val_new > 500:
|
||||
message = 'Value may not be greater than 500.'
|
||||
else:
|
||||
val_old = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'archive')
|
||||
val_old = Config.get_setting_value(self, jid_bare, 'archive')
|
||||
await Config.set_setting_value(
|
||||
self.settings, jid_bare, db_file, 'archive', val_new)
|
||||
self, jid_bare, db_file, 'archive', val_new)
|
||||
message = ('Maximum archived items has been set to {} (was: {}).'
|
||||
.format(val_new, val_old))
|
||||
except:
|
||||
|
@ -334,9 +330,9 @@ class XmppCommands:
|
|||
|
||||
|
||||
def export_feeds(jid_bare, ext):
|
||||
filename = Feed.export_feeds(jid_bare, ext)
|
||||
pathname = Feed.export_feeds(jid_bare, ext)
|
||||
message = 'Feeds successfuly exported to {}.'.format(ext)
|
||||
return filename, message
|
||||
return pathname, message
|
||||
|
||||
|
||||
def fetch_gemini():
|
||||
|
@ -550,8 +546,7 @@ class XmppCommands:
|
|||
|
||||
|
||||
def get_interval(self, jid_bare):
|
||||
result = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'interval')
|
||||
result = Config.get_setting_value(self, jid_bare, 'interval')
|
||||
message = str(result)
|
||||
return message
|
||||
|
||||
|
@ -559,10 +554,9 @@ class XmppCommands:
|
|||
async def set_interval(self, db_file, jid_bare, val):
|
||||
try:
|
||||
val_new = int(val)
|
||||
val_old = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'interval')
|
||||
val_old = Config.get_setting_value(self, jid_bare, 'interval')
|
||||
await Config.set_setting_value(
|
||||
self.settings, jid_bare, db_file, 'interval', val_new)
|
||||
self, jid_bare, db_file, 'interval', val_new)
|
||||
message = ('Updates will be sent every {} minutes '
|
||||
'(was: {}).'.format(val_new, val_old))
|
||||
except Exception as e:
|
||||
|
@ -596,8 +590,7 @@ class XmppCommands:
|
|||
|
||||
|
||||
def get_length(self, jid_bare):
|
||||
result = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'length')
|
||||
result = Config.get_setting_value(self, jid_bare, 'length')
|
||||
result = str(result)
|
||||
return result
|
||||
|
||||
|
@ -605,10 +598,9 @@ class XmppCommands:
|
|||
async def set_length(self, db_file, jid_bare, val):
|
||||
try:
|
||||
val_new = int(val)
|
||||
val_old = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'length')
|
||||
val_old = Config.get_setting_value(self, jid_bare, 'length')
|
||||
await Config.set_setting_value(
|
||||
self.settings, jid_bare, db_file, 'length', val_new)
|
||||
self, jid_bare, db_file, 'length', val_new)
|
||||
if not val_new: # i.e. val_new == 0
|
||||
# TODO Add action to disable limit
|
||||
message = ('Summary length limit is disabled '
|
||||
|
@ -625,29 +617,41 @@ class XmppCommands:
|
|||
|
||||
|
||||
async def set_media_off(self, jid_bare, db_file):
|
||||
await Config.set_setting_value(self.settings, jid_bare, db_file, 'media', 0)
|
||||
await Config.set_setting_value(self, jid_bare, db_file, 'media', 0)
|
||||
message = 'Media is disabled.'
|
||||
return message
|
||||
|
||||
|
||||
async def set_media_on(self, jid_bare, db_file):
|
||||
await Config.set_setting_value(self.settings, jid_bare, db_file, 'media', 1)
|
||||
await Config.set_setting_value(self, jid_bare, db_file, 'media', 1)
|
||||
message = 'Media is enabled.'
|
||||
return message
|
||||
|
||||
|
||||
async def set_old_off(self, jid_bare, db_file):
|
||||
await Config.set_setting_value(self.settings, jid_bare, db_file, 'old', 0)
|
||||
await Config.set_setting_value(self, jid_bare, db_file, 'old', 0)
|
||||
message = 'Only new items of newly added feeds be delivered.'
|
||||
return message
|
||||
|
||||
|
||||
async def set_old_on(self, jid_bare, db_file):
|
||||
await Config.set_setting_value(self.settings, jid_bare, db_file, 'old', 1)
|
||||
await Config.set_setting_value(self, jid_bare, db_file, 'old', 1)
|
||||
message = 'All items of newly added feeds be delivered.'
|
||||
return message
|
||||
|
||||
|
||||
async def set_omemo_off(self, jid_bare, db_file):
|
||||
await Config.set_setting_value(self, jid_bare, db_file, 'omemo', 0)
|
||||
message = 'OMEMO is disabled.'
|
||||
return message
|
||||
|
||||
|
||||
async def set_omemo_on(self, jid_bare, db_file):
|
||||
await Config.set_setting_value(self, jid_bare, db_file, 'omemo', 1)
|
||||
message = 'OMEMO is enabled.'
|
||||
return message
|
||||
|
||||
|
||||
def node_delete(self, info):
|
||||
info = info.split(' ')
|
||||
if len(info) > 2:
|
||||
|
@ -687,8 +691,8 @@ class XmppCommands:
|
|||
def print_options(self, jid_bare):
|
||||
message = ''
|
||||
for key in self.settings[jid_bare]:
|
||||
val = Config.get_setting_value(self.settings, jid_bare, key)
|
||||
# val = Config.get_setting_value(self.settings, jid_bare, key)
|
||||
val = Config.get_setting_value(self, jid_bare, key)
|
||||
# val = Config.get_setting_value(self, jid_bare, key)
|
||||
steps = 11 - len(key)
|
||||
pulse = ''
|
||||
for step in range(steps):
|
||||
|
@ -698,8 +702,7 @@ class XmppCommands:
|
|||
|
||||
|
||||
def get_quantum(self, jid_bare):
|
||||
result = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'quantum')
|
||||
result = Config.get_setting_value(self, jid_bare, 'quantum')
|
||||
message = str(result)
|
||||
return message
|
||||
|
||||
|
@ -707,14 +710,13 @@ class XmppCommands:
|
|||
async def set_quantum(self, db_file, jid_bare, val):
|
||||
try:
|
||||
val_new = int(val)
|
||||
val_old = Config.get_setting_value(
|
||||
self.settings, jid_bare, 'quantum')
|
||||
val_old = Config.get_setting_value(self, jid_bare, 'quantum')
|
||||
# response = (
|
||||
# 'Every update will contain {} news items.'
|
||||
# ).format(response)
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
await Config.set_setting_value(self.settings, jid_bare,
|
||||
db_file, 'quantum', val_new)
|
||||
await Config.set_setting_value(
|
||||
self, jid_bare, db_file, 'quantum', val_new)
|
||||
message = ('Next update will contain {} news items (was: {}).'
|
||||
.format(val_new, val_old))
|
||||
except:
|
||||
|
@ -958,17 +960,16 @@ class XmppCommands:
|
|||
|
||||
# Tasks are classes which are passed to this function
|
||||
# On an occasion in which they would have returned, variable "tasks" might be called "callback"
|
||||
async def scheduler_start(self, db_file, jid_bare, tasks):
|
||||
await Config.set_setting_value(self.settings, jid_bare, db_file, 'enabled', 1)
|
||||
for task in tasks:
|
||||
task.restart_task(self, jid_bare)
|
||||
async def scheduler_start(self, db_file, jid_bare, callbacks):
|
||||
await Config.set_setting_value(self, jid_bare, db_file, 'enabled', 1)
|
||||
for callback in callbacks:
|
||||
callback.restart_task(self, jid_bare)
|
||||
message = 'Updates are enabled.'
|
||||
return message
|
||||
|
||||
|
||||
async def scheduler_stop(self, db_file, jid_bare):
|
||||
await Config.set_setting_value(
|
||||
self.settings, jid_bare, db_file, 'enabled', 0)
|
||||
await Config.set_setting_value(self, jid_bare, db_file, 'enabled', 0)
|
||||
for task in ('interval', 'status'):
|
||||
if (jid_bare in self.task_manager and
|
||||
task in self.task_manager[jid_bare]):
|
||||
|
|
180
slixfeed/xmpp/encryption.py
Normal file
180
slixfeed/xmpp/encryption.py
Normal file
|
@ -0,0 +1,180 @@
|
|||
#!/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 command_lowercase.startswith("add"):
|
||||
|
||||
2) If subscription is inadequate (see XmppPresence.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
|
||||
|
||||
3) Set timeout for moderator interaction.
|
||||
If moderator interaction has been made, and moderator approves the bot, then
|
||||
the bot will add the given groupchat to bookmarks; otherwise, the bot will
|
||||
send a message that it was not approved and therefore leaves the groupchat.
|
||||
|
||||
"""
|
||||
|
||||
from omemo.exceptions import MissingBundleException
|
||||
from slixfeed.log import Logger
|
||||
from slixmpp import JID
|
||||
from slixmpp.exceptions import IqTimeout, IqError
|
||||
from slixmpp.stanza import Message
|
||||
from slixmpp_omemo import MissingOwnKey, EncryptionPrepareException
|
||||
from slixmpp_omemo import UndecidedException, UntrustedException, NoAvailableSession
|
||||
|
||||
|
||||
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 XmppOmemo:
|
||||
|
||||
|
||||
async def decrypt(self, message: Message, allow_untrusted: bool = False):
|
||||
jid = message['from']
|
||||
try:
|
||||
message_omemo_encrypted = message['omemo_encrypted']
|
||||
message_body = await self['xep_0384'].decrypt_message(
|
||||
message_omemo_encrypted, jid, allow_untrusted)
|
||||
# decrypt_message returns Optional[str]. It is possible to get
|
||||
# body-less OMEMO message (see KeyTransportMessages), currently
|
||||
# used for example to send heartbeats to other devices.
|
||||
if message_body is not None:
|
||||
response = message_body.decode('utf8')
|
||||
omemo_decrypted = True
|
||||
else:
|
||||
omemo_decrypted = response = None
|
||||
retry = None
|
||||
except (MissingOwnKey,) as exn:
|
||||
# The message is missing our own key, it was not encrypted for
|
||||
# us, and we can't decrypt it.
|
||||
response = ('Error: Your message has not been encrypted for '
|
||||
'Slixfeed (MissingOwnKey).')
|
||||
omemo_decrypted = False
|
||||
retry = False
|
||||
logger.error(exn)
|
||||
except (NoAvailableSession,) as exn:
|
||||
# We received a message from that contained a session that we
|
||||
# don't know about (deleted session storage, etc.). We can't
|
||||
# decrypt the message, and it's going to be lost.
|
||||
# Here, as we need to initiate a new encrypted session, it is
|
||||
# best if we send an encrypted message directly. XXX: Is it
|
||||
# where we talk about self-healing messages?
|
||||
response = ('Error: Your message has not been encrypted for '
|
||||
'Slixfeed (NoAvailableSession).')
|
||||
omemo_decrypted = False
|
||||
retry = False
|
||||
logger.error(exn)
|
||||
except (UndecidedException, UntrustedException) as exn:
|
||||
# We received a message from an untrusted device. We can
|
||||
# choose to decrypt the message nonetheless, with the
|
||||
# `allow_untrusted` flag on the `decrypt_message` call, which
|
||||
# we will do here. This is only possible for decryption,
|
||||
# encryption will require us to decide if we trust the device
|
||||
# or not. Clients _should_ indicate that the message was not
|
||||
# trusted, or in undecided state, if they decide to decrypt it
|
||||
# anyway.
|
||||
response = (f'Error: Device "{exn.device}" is not present in the '
|
||||
'trusted devices of Slixfeed.')
|
||||
omemo_decrypted = False
|
||||
retry = True
|
||||
logger.error(exn)
|
||||
# We resend, setting the `allow_untrusted` parameter to True.
|
||||
# await XmppChat.process_message(self, message, allow_untrusted=True)
|
||||
except (EncryptionPrepareException,) as exn:
|
||||
# Slixmpp tried its best, but there were errors it couldn't
|
||||
# resolve. At this point you should have seen other exceptions
|
||||
# and given a chance to resolve them already.
|
||||
response = ('Error: Your message has not been encrypted for '
|
||||
'Slixfeed (EncryptionPrepareException).')
|
||||
omemo_decrypted = False
|
||||
retry = False
|
||||
logger.error(exn)
|
||||
except (Exception,) as exn:
|
||||
response = ('Error: Your message has not been encrypted for '
|
||||
'Slixfeed (Unknown).')
|
||||
omemo_decrypted = False
|
||||
retry = False
|
||||
logger.error(exn)
|
||||
raise
|
||||
|
||||
return response, omemo_decrypted, retry
|
||||
|
||||
|
||||
async def encrypt(self, jid: JID, message_body):
|
||||
expect_problems = {} # type: Optional[Dict[JID, List[int]]]
|
||||
while True:
|
||||
try:
|
||||
# `encrypt_message` excepts the plaintext to be sent, a list of
|
||||
# bare JIDs to encrypt to, and optionally a dict of problems to
|
||||
# expect per bare JID.
|
||||
#
|
||||
# Note that this function returns an `<encrypted/>` object,
|
||||
# and not a full Message stanza. This combined with the
|
||||
# `recipients` parameter that requires for a list of JIDs,
|
||||
# allows you to encrypt for 1:1 as well as groupchats (MUC).
|
||||
#
|
||||
# `expect_problems`: See EncryptionPrepareException handling.
|
||||
recipients = [jid]
|
||||
message_body = await self['xep_0384'].encrypt_message(
|
||||
message_body, recipients, expect_problems)
|
||||
omemo_encrypted = True
|
||||
break
|
||||
except UndecidedException as exn:
|
||||
# The library prevents us from sending a message to an
|
||||
# untrusted/undecided barejid, so we need to make a decision here.
|
||||
# This is where you prompt your user to ask what to do. In
|
||||
# this bot we will automatically trust undecided recipients.
|
||||
await self['xep_0384'].trust(exn.bare_jid, exn.device, exn.ik)
|
||||
omemo_encrypted = False
|
||||
# TODO: catch NoEligibleDevicesException
|
||||
except EncryptionPrepareException as exn:
|
||||
# This exception is being raised when the library has tried
|
||||
# all it could and doesn't know what to do anymore. It
|
||||
# contains a list of exceptions that the user must resolve, or
|
||||
# explicitely ignore via `expect_problems`.
|
||||
# TODO: We might need to bail out here if errors are the same?
|
||||
for error in exn.errors:
|
||||
if isinstance(error, MissingBundleException):
|
||||
# We choose to ignore MissingBundleException. It seems
|
||||
# to be somewhat accepted that it's better not to
|
||||
# encrypt for a device if it has problems and encrypt
|
||||
# for the rest, rather than error out. The "faulty"
|
||||
# device won't be able to decrypt and should display a
|
||||
# generic message. The receiving end-user at this
|
||||
# point can bring up the issue if it happens.
|
||||
message_body = (f'Could not find keys for device '
|
||||
'"{error.device}"'
|
||||
f' of recipient "{error.bare_jid}". '
|
||||
'Skipping.')
|
||||
omemo_encrypted = False
|
||||
jid = JID(error.bare_jid)
|
||||
device_list = expect_problems.setdefault(jid, [])
|
||||
device_list.append(error.device)
|
||||
except (IqError, IqTimeout) as exn:
|
||||
message_body = ('An error occured while fetching information '
|
||||
'on a recipient.\n%r' % exn)
|
||||
omemo_encrypted = False
|
||||
except Exception as exn:
|
||||
message_body = ('An error occured while attempting to encrypt'
|
||||
'.\n%r' % exn)
|
||||
omemo_encrypted = False
|
||||
raise
|
||||
|
||||
return message_body, omemo_encrypted
|
|
@ -34,21 +34,31 @@ class XmppGroupchat:
|
|||
'bookmark {}'.format(bookmark['name']))
|
||||
alias = bookmark["nick"]
|
||||
muc_jid = bookmark["jid"]
|
||||
Message.printer('Joining to MUC {} ...'.format(muc_jid))
|
||||
# Message.printer('Joining to MUC {} ...'.format(muc_jid))
|
||||
print('Joining to MUC {} ...'.format(muc_jid))
|
||||
result = await XmppMuc.join(self, muc_jid, alias)
|
||||
if result == 'ban':
|
||||
await XmppBookmark.remove(self, muc_jid)
|
||||
logger.warning('{} is banned from {}'.format(self.alias, muc_jid))
|
||||
logger.warning('Groupchat {} has been removed from bookmarks'
|
||||
.format(muc_jid))
|
||||
else:
|
||||
logger.info('Autojoin groupchat\n'
|
||||
'Name : {}\n'
|
||||
'JID : {}\n'
|
||||
'Alias : {}\n'
|
||||
.format(bookmark["name"],
|
||||
bookmark["jid"],
|
||||
bookmark["nick"]))
|
||||
match result:
|
||||
case 'ban':
|
||||
await XmppBookmark.remove(self, muc_jid)
|
||||
logger.warning('{} is banned from {}'.format(self.alias, muc_jid))
|
||||
logger.warning('Groupchat {} has been removed from bookmarks'
|
||||
.format(muc_jid))
|
||||
case 'error':
|
||||
logger.warning('An error has occured while attempting '
|
||||
'to join to groupchat {}'
|
||||
.format(muc_jid))
|
||||
case 'timeout':
|
||||
logger.warning('Timeout has reached while attempting '
|
||||
'to join to groupchat {}'
|
||||
.format(muc_jid))
|
||||
case _:
|
||||
logger.info('Autojoin groupchat\n'
|
||||
'Name : {}\n'
|
||||
'JID : {}\n'
|
||||
'Alias : {}\n'
|
||||
.format(bookmark["name"],
|
||||
bookmark["jid"],
|
||||
bookmark["nick"]))
|
||||
elif not bookmark["jid"]:
|
||||
logger.error('JID is missing for bookmark {}'
|
||||
.format(bookmark['name']))
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
|
||||
from slixfeed.log import Logger
|
||||
from slixmpp import JID
|
||||
import xml.sax.saxutils as saxutils
|
||||
|
||||
logger = Logger(__name__)
|
||||
|
@ -39,6 +40,43 @@ class XmppMessage:
|
|||
mnick=self.alias)
|
||||
|
||||
|
||||
def send_omemo(self, jid: JID, chat_type, response_encrypted):
|
||||
jid_from = str(self.boundjid) if self.is_component else None
|
||||
message = self.make_message(mto=jid, mfrom=jid_from, mtype=chat_type)
|
||||
eme_ns = 'eu.siacs.conversations.axolotl'
|
||||
# message['eme']['namespace'] = eme_ns
|
||||
# message['eme']['name'] = self['xep_0380'].mechanisms[eme_ns]
|
||||
message['eme'] = {'namespace': eme_ns}
|
||||
# message['eme'] = {'name': self['xep_0380'].mechanisms[eme_ns]}
|
||||
message.append(response_encrypted)
|
||||
message.send()
|
||||
|
||||
|
||||
def send_omemo_oob(self, jid: JID, url_encrypted, chat_type, aesgcm=False):
|
||||
jid_from = str(self.boundjid) if self.is_component else None
|
||||
# if not aesgcm: url_encrypted = saxutils.escape(url_encrypted)
|
||||
message = self.make_message(mto=jid, mfrom=jid_from, mtype=chat_type)
|
||||
eme_ns = 'eu.siacs.conversations.axolotl'
|
||||
# message['eme']['namespace'] = eme_ns
|
||||
# message['eme']['name'] = self['xep_0380'].mechanisms[eme_ns]
|
||||
message['eme'] = {'namespace': eme_ns}
|
||||
# message['eme'] = {'name': self['xep_0380'].mechanisms[eme_ns]}
|
||||
message['oob']['url'] = url_encrypted
|
||||
message.append(url_encrypted)
|
||||
message.send()
|
||||
|
||||
|
||||
# FIXME Solve this function
|
||||
def send_omemo_reply(self, message, response_encrypted):
|
||||
eme_ns = 'eu.siacs.conversations.axolotl'
|
||||
# message['eme']['namespace'] = eme_ns
|
||||
# message['eme']['name'] = self['xep_0380'].mechanisms[eme_ns]
|
||||
message['eme'] = {'namespace': eme_ns}
|
||||
# message['eme'] = {'name': self['xep_0380'].mechanisms[eme_ns]}
|
||||
message.append(response_encrypted)
|
||||
message.reply(message['body']).send()
|
||||
|
||||
|
||||
# NOTE We might want to add more characters
|
||||
# def escape_to_xml(raw_string):
|
||||
# escape_map = {
|
||||
|
|
|
@ -46,7 +46,7 @@ class XmppMuc:
|
|||
# )
|
||||
logger.info('Joining groupchat\nJID : {}\n'.format(jid))
|
||||
jid_from = str(self.boundjid) if self.is_component else None
|
||||
if alias == None: self.alias
|
||||
if not alias: alias = self.alias
|
||||
try:
|
||||
await self.plugin['xep_0045'].join_muc_wait(jid,
|
||||
alias,
|
||||
|
|
|
@ -379,7 +379,7 @@ class XmppPubsubTask:
|
|||
async def task_publish(self, jid_bare):
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
if jid_bare not in self.settings:
|
||||
Config.add_settings_jid(self.settings, jid_bare, db_file)
|
||||
Config.add_settings_jid(self, jid_bare, db_file)
|
||||
while True:
|
||||
await XmppPubsubAction.send_unread_items(self, jid_bare)
|
||||
await asyncio.sleep(60 * 180)
|
||||
|
|
|
@ -28,7 +28,7 @@ class XmppStatus:
|
|||
logger.debug('{}: jid: {}'.format(function_name, jid_bare))
|
||||
status_text = '📜️ Slixfeed RSS News Bot'
|
||||
db_file = config.get_pathname_to_database(jid_bare)
|
||||
enabled = Config.get_setting_value(self.settings, jid_bare, 'enabled')
|
||||
enabled = Config.get_setting_value(self, jid_bare, 'enabled')
|
||||
if enabled:
|
||||
jid_task = self.pending_tasks[jid_bare] if jid_bare in self.pending_tasks else None
|
||||
if jid_task and len(jid_task):
|
||||
|
@ -50,7 +50,7 @@ class XmppStatus:
|
|||
status_text = '📬️ There are {} news items'.format(str(unread))
|
||||
else:
|
||||
# print('status no news for ' + jid_bare)
|
||||
status_mode = 'available'
|
||||
status_mode = 'away'
|
||||
status_text = '📭️ No news'
|
||||
else:
|
||||
# print('status disabled for ' + jid_bare)
|
||||
|
|
|
@ -6,47 +6,51 @@ Based on http_upload.py example from project slixmpp
|
|||
https://codeberg.org/poezio/slixmpp/src/branch/master/examples/http_upload.py
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
from slixfeed.log import Logger
|
||||
from slixmpp import JID
|
||||
from slixmpp.exceptions import IqTimeout, IqError
|
||||
from slixmpp.plugins.xep_0363.http_upload import HTTPError
|
||||
import sys
|
||||
from typing import Optional
|
||||
|
||||
logger = Logger(__name__)
|
||||
# import sys
|
||||
|
||||
class XmppUpload:
|
||||
|
||||
async def start(self, jid, filename, domain=None):
|
||||
async def start(self, jid, filename: Path, size: Optional[int] = None,
|
||||
encrypted: bool = False, domain: Optional[JID] = None):
|
||||
logger.info(['Uploading file %s...', filename])
|
||||
try:
|
||||
upload_file = self['xep_0363'].upload_file
|
||||
# if self.encrypted and not self['xep_0454']:
|
||||
# print(
|
||||
# 'The xep_0454 module isn\'t available. '
|
||||
# 'Ensure you have \'cryptography\' '
|
||||
# 'from extras_require installed.',
|
||||
# file=sys.stderr,
|
||||
# )
|
||||
# return
|
||||
# elif self.encrypted:
|
||||
# upload_file = self['xep_0454'].upload_file
|
||||
try:
|
||||
url = await upload_file(
|
||||
filename, domain, timeout=10,
|
||||
if encrypted and not self['xep_0454']:
|
||||
print(
|
||||
'The xep_0454 module isn\'t available. '
|
||||
'Ensure you have \'cryptography\' '
|
||||
'from extras_require installed.',
|
||||
file=sys.stderr,
|
||||
)
|
||||
url = None
|
||||
elif encrypted:
|
||||
upload_file = self['xep_0454'].upload_file
|
||||
try:
|
||||
url = await upload_file(filename, size, domain, timeout=10,)
|
||||
logger.info('Upload successful!')
|
||||
logger.info(['Sending file to %s', jid])
|
||||
except HTTPError:
|
||||
url = ('Error: It appears that this server does not support '
|
||||
'HTTP File Upload.')
|
||||
url = None
|
||||
logger.error('It appears that this server does not support '
|
||||
'HTTP File Upload.')
|
||||
# raise HTTPError(
|
||||
# "This server doesn't appear to support HTTP File Upload"
|
||||
# )
|
||||
except IqError as e:
|
||||
url = None
|
||||
logger.error('Could not send message')
|
||||
logger.error(e)
|
||||
except IqTimeout as e:
|
||||
url = None
|
||||
# raise TimeoutError('Could not send message in time')
|
||||
logger.error('Could not send message in time')
|
||||
logger.error(e)
|
||||
|
|
Loading…
Reference in a new issue