code style reformatting using black

This commit is contained in:
Goffi 2018-06-27 20:14:46 +02:00
commit 744cb0c503

View file

@ -23,6 +23,7 @@ from sat.core.constants import Const as C
from sat.memory.persistent import PersistentBinaryDict
from sat.tools import xml_tools
from sat.core.log import getLogger
log = getLogger(__name__)
from twisted.words.xish import domish
from twisted.words.protocols.jabber import jid
@ -30,7 +31,7 @@ from twisted.words.protocols.jabber.error import StanzaError
from twisted.internet import defer
NS_BOOKMARKS = 'storage:bookmarks'
NS_BOOKMARKS = "storage:bookmarks"
PLUGIN_INFO = {
C.PI_NAME: "Bookmarks",
@ -41,28 +42,56 @@ PLUGIN_INFO = {
C.PI_RECOMMENDATIONS: ["XEP-0049"],
C.PI_MAIN: "XEP_0048",
C.PI_HANDLER: "no",
C.PI_DESCRIPTION: _("""Implementation of bookmarks""")
C.PI_DESCRIPTION: _("""Implementation of bookmarks"""),
}
class XEP_0048(object):
MUC_TYPE = 'muc'
URL_TYPE = 'url'
MUC_KEY = 'jid'
URL_KEY = 'url'
MUC_ATTRS = ('autojoin', 'name')
URL_ATTRS = ('name',)
MUC_TYPE = "muc"
URL_TYPE = "url"
MUC_KEY = "jid"
URL_KEY = "url"
MUC_ATTRS = ("autojoin", "name")
URL_ATTRS = ("name",)
def __init__(self, host):
log.info(_("Bookmarks plugin initialization"))
self.host = host
# self.__menu_id = host.registerCallback(self._bookmarksMenu, with_data=True)
self.__bm_save_id = host.registerCallback(self._bookmarksSaveCb, with_data=True)
host.importMenu((D_("Groups"), D_("Bookmarks")), self._bookmarksMenu, security_limit=0, help_string=D_("Use and manage bookmarks"))
self.__selected_id = host.registerCallback(self._bookmarkSelectedCb, with_data=True)
host.bridge.addMethod("bookmarksList", ".plugin", in_sign='sss', out_sign='a{sa{sa{ss}}}', method=self._bookmarksList, async=True)
host.bridge.addMethod("bookmarksRemove", ".plugin", in_sign='ssss', out_sign='', method=self._bookmarksRemove, async=True)
host.bridge.addMethod("bookmarksAdd", ".plugin", in_sign='ssa{ss}ss', out_sign='', method=self._bookmarksAdd, async=True)
host.importMenu(
(D_("Groups"), D_("Bookmarks")),
self._bookmarksMenu,
security_limit=0,
help_string=D_("Use and manage bookmarks"),
)
self.__selected_id = host.registerCallback(
self._bookmarkSelectedCb, with_data=True
)
host.bridge.addMethod(
"bookmarksList",
".plugin",
in_sign="sss",
out_sign="a{sa{sa{ss}}}",
method=self._bookmarksList,
async=True,
)
host.bridge.addMethod(
"bookmarksRemove",
".plugin",
in_sign="ssss",
out_sign="",
method=self._bookmarksRemove,
async=True,
)
host.bridge.addMethod(
"bookmarksAdd",
".plugin",
in_sign="ssa{ss}ss",
out_sign="",
method=self._bookmarksAdd,
async=True,
)
try:
self.private_plg = self.host.plugins["XEP-0049"]
except KeyError:
@ -74,20 +103,22 @@ class XEP_0048(object):
@defer.inlineCallbacks
def profileConnected(self, client):
local = client.bookmarks_local = PersistentBinaryDict(NS_BOOKMARKS, client.profile)
local = client.bookmarks_local = PersistentBinaryDict(
NS_BOOKMARKS, client.profile
)
yield local.load()
if not local:
local[XEP_0048.MUC_TYPE] = dict()
local[XEP_0048.URL_TYPE] = dict()
private = yield self._getServerBookmarks('private', client.profile)
private = yield self._getServerBookmarks("private", client.profile)
pubsub = client.bookmarks_pubsub = None
for bookmarks in (local, private, pubsub):
if bookmarks is not None:
for (room_jid, data) in bookmarks[XEP_0048.MUC_TYPE].items():
if data.get('autojoin', 'false') == 'true':
nick = data.get('nick', client.jid.user)
self.host.plugins['XEP-0045'].join(client, room_jid, nick, {})
if data.get("autojoin", "false") == "true":
nick = data.get("nick", client.jid.user)
self.host.plugins["XEP-0045"].join(client, room_jid, nick, {})
@defer.inlineCallbacks
def _getServerBookmarks(self, storage_type, profile):
@ -101,14 +132,18 @@ class XEP_0048(object):
@return: data dictionary, or None if feature is not available
"""
client = self.host.getClient(profile)
if storage_type == 'private':
if storage_type == "private":
try:
bookmarks_private_xml = yield self.private_plg.privateXMLGet('storage', NS_BOOKMARKS, profile)
data = client.bookmarks_private = self._bookmarkElt2Dict(bookmarks_private_xml)
bookmarks_private_xml = yield self.private_plg.privateXMLGet(
"storage", NS_BOOKMARKS, profile
)
data = client.bookmarks_private = self._bookmarkElt2Dict(
bookmarks_private_xml
)
except (StanzaError, AttributeError):
log.info(_("Private XML storage not available"))
data = client.bookmarks_private = None
elif storage_type == 'pubsub':
elif storage_type == "pubsub":
raise NotImplementedError
else:
raise ValueError("storage_type must be 'private' or 'pubsub'")
@ -124,9 +159,9 @@ class XEP_0048(object):
@param bookmarks_elt (domish.Element): bookmarks XML
@param profile: %(doc_profile)s
"""
if storage_type == 'private':
if storage_type == "private":
yield self.private_plg.privateXMLStore(bookmarks_elt, profile)
elif storage_type == 'pubsub':
elif storage_type == "pubsub":
raise NotImplementedError
else:
raise ValueError("storage_type must be 'private' or 'pubsub'")
@ -142,12 +177,14 @@ class XEP_0048(object):
conf_data = {}
url_data = {}
conference_elts = storage_elt.elements(NS_BOOKMARKS, 'conference')
conference_elts = storage_elt.elements(NS_BOOKMARKS, "conference")
for conference_elt in conference_elts:
try:
room_jid = jid.JID(conference_elt[XEP_0048.MUC_KEY])
except KeyError:
log.warning ("invalid bookmark found, igoring it:\n%s" % conference_elt.toXml())
log.warning(
"invalid bookmark found, igoring it:\n%s" % conference_elt.toXml()
)
continue
data = conf_data[room_jid] = {}
@ -156,17 +193,19 @@ class XEP_0048(object):
if conference_elt.hasAttribute(attr):
data[attr] = conference_elt[attr]
try:
data['nick'] = unicode(conference_elt.elements(NS_BOOKMARKS, 'nick').next())
data["nick"] = unicode(
conference_elt.elements(NS_BOOKMARKS, "nick").next()
)
except StopIteration:
pass
# TODO: manage password (need to be secured, see XEP-0049 §4)
url_elts = storage_elt.elements(NS_BOOKMARKS, 'url')
url_elts = storage_elt.elements(NS_BOOKMARKS, "url")
for url_elt in url_elts:
try:
url = url_elt[XEP_0048.URL_KEY]
except KeyError:
log.warning ("invalid bookmark found, igoring it:\n%s" % url_elt.toXml())
log.warning("invalid bookmark found, igoring it:\n%s" % url_elt.toXml())
continue
data = url_data[url] = {}
for attr in XEP_0048.URL_ATTRS:
@ -185,9 +224,9 @@ class XEP_0048(object):
"""
rooms_data = data.get(XEP_0048.MUC_TYPE, {})
urls_data = data.get(XEP_0048.URL_TYPE, {})
storage_elt = domish.Element((NS_BOOKMARKS, 'storage'))
storage_elt = domish.Element((NS_BOOKMARKS, "storage"))
for room_jid in rooms_data:
conference_elt = storage_elt.addElement('conference')
conference_elt = storage_elt.addElement("conference")
conference_elt[XEP_0048.MUC_KEY] = room_jid.full()
for attr in XEP_0048.MUC_ATTRS:
try:
@ -195,12 +234,12 @@ class XEP_0048(object):
except KeyError:
pass
try:
conference_elt.addElement('nick', content=rooms_data[room_jid]['nick'])
conference_elt.addElement("nick", content=rooms_data[room_jid]["nick"])
except KeyError:
pass
for url in urls_data:
url_elt = storage_elt.addElement('url')
url_elt = storage_elt.addElement("url")
url_elt[XEP_0048.URL_KEY] = url
for attr in XEP_0048.URL_ATTRS:
try:
@ -212,18 +251,20 @@ class XEP_0048(object):
def _bookmarkSelectedCb(self, data, profile):
try:
room_jid_s, nick = data['index'].split(' ', 1)
room_jid_s, nick = data["index"].split(" ", 1)
room_jid = jid.JID(room_jid_s)
except (KeyError, RuntimeError):
log.warning(_("No room jid selected"))
return {}
client = self.host.getClient(profile)
d = self.host.plugins['XEP-0045'].join(client, room_jid, nick, {})
d = self.host.plugins["XEP-0045"].join(client, room_jid, nick, {})
def join_eb(failure):
log.warning(u"Error while trying to join room: {}".format(failure))
# FIXME: failure are badly managed in plugin XEP-0045. Plugin XEP-0045 need to be fixed before managing errors correctly here
return {}
d.addCallbacks(lambda dummy: {}, join_eb)
return d
@ -233,40 +274,54 @@ class XEP_0048(object):
"""
client = self.host.getClient(profile)
xmlui = xml_tools.XMLUI(title=_('Bookmarks manager'))
adv_list = xmlui.changeContainer('advanced_list', columns=3, selectable='single', callback_id=self.__selected_id)
for bookmarks in (client.bookmarks_local, client.bookmarks_private, client.bookmarks_pubsub):
xmlui = xml_tools.XMLUI(title=_("Bookmarks manager"))
adv_list = xmlui.changeContainer(
"advanced_list",
columns=3,
selectable="single",
callback_id=self.__selected_id,
)
for bookmarks in (
client.bookmarks_local,
client.bookmarks_private,
client.bookmarks_pubsub,
):
if bookmarks is None:
continue
for (room_jid, data) in sorted(bookmarks[XEP_0048.MUC_TYPE].items(), key=lambda item: item[1].get('name',item[0].user)):
for (room_jid, data) in sorted(
bookmarks[XEP_0048.MUC_TYPE].items(),
key=lambda item: item[1].get("name", item[0].user),
):
room_jid_s = room_jid.full()
adv_list.setRowIndex(u'%s %s' % (room_jid_s, data.get('nick') or client.jid.user))
xmlui.addText(data.get('name',''))
adv_list.setRowIndex(
u"%s %s" % (room_jid_s, data.get("nick") or client.jid.user)
)
xmlui.addText(data.get("name", ""))
xmlui.addJid(room_jid)
if data.get('autojoin', 'false') == 'true':
xmlui.addText('autojoin')
if data.get("autojoin", "false") == "true":
xmlui.addText("autojoin")
else:
xmlui.addEmpty()
adv_list.end()
xmlui.addDivider('dash')
xmlui.addDivider("dash")
xmlui.addText(_("add a bookmark"))
xmlui.changeContainer("pairs")
xmlui.addLabel(_('Name'))
xmlui.addString('name')
xmlui.addLabel(_('jid'))
xmlui.addString('jid')
xmlui.addLabel(_('Nickname'))
xmlui.addString('nick', client.jid.user)
xmlui.addLabel(_('Autojoin'))
xmlui.addBool('autojoin')
xmlui.addLabel(_("Name"))
xmlui.addString("name")
xmlui.addLabel(_("jid"))
xmlui.addString("jid")
xmlui.addLabel(_("Nickname"))
xmlui.addString("nick", client.jid.user)
xmlui.addLabel(_("Autojoin"))
xmlui.addBool("autojoin")
xmlui.changeContainer("vertical")
xmlui.addButton(self.__bm_save_id, _("Save"), ('name', 'jid', 'nick', 'autojoin'))
return {'xmlui': xmlui.toXml()}
xmlui.addButton(self.__bm_save_id, _("Save"), ("name", "jid", "nick", "autojoin"))
return {"xmlui": xmlui.toXml()}
def _bookmarksSaveCb(self, data, profile):
bm_data = xml_tools.XMLUIResult2DataFormResult(data)
try:
location = jid.JID(bm_data.pop('jid'))
location = jid.JID(bm_data.pop("jid"))
except KeyError:
raise exceptions.InternalError("Can't find mandatory key")
d = self.addBookmark(XEP_0048.MUC_TYPE, location, bm_data, profile_key=profile)
@ -274,7 +329,9 @@ class XEP_0048(object):
return d
@defer.inlineCallbacks
def addBookmark(self, type_, location, data, storage_type="auto", profile_key=C.PROF_KEY_NONE):
def addBookmark(
self, type_, location, data, storage_type="auto", profile_key=C.PROF_KEY_NONE
):
"""Store a new bookmark
@param type_: bookmark type, one of:
@ -293,21 +350,21 @@ class XEP_0048(object):
- "local": Store in SàT database
@param profile_key: %(doc_profile_key)s
"""
assert storage_type in ('auto', 'pubsub', 'private', 'local')
if type_ == XEP_0048.URL_TYPE and {'autojoin', 'nick'}.intersection(data.keys()):
raise ValueError("autojoin or nick can't be used with URLs")
assert storage_type in ("auto", "pubsub", "private", "local")
if type_ == XEP_0048.URL_TYPE and {"autojoin", "nick"}.intersection(data.keys()):
raise ValueError("autojoin or nick can't be used with URLs")
client = self.host.getClient(profile_key)
if storage_type == 'auto':
if storage_type == "auto":
if client.bookmarks_pubsub is not None:
storage_type = 'pubsub'
storage_type = "pubsub"
elif client.bookmarks_private is not None:
storage_type = 'private'
storage_type = "private"
else:
storage_type = 'local'
storage_type = "local"
log.warning(_("Bookmarks will be local only"))
log.info(_('Type selected for "auto" storage: %s') % storage_type)
if storage_type == 'local':
if storage_type == "local":
client.bookmarks_local[type_][location] = data
yield client.bookmarks_local.force(type_)
else:
@ -317,7 +374,9 @@ class XEP_0048(object):
yield self._setServerBookmarks(storage_type, bookmark_elt, client.profile)
@defer.inlineCallbacks
def removeBookmark(self, type_, location, storage_type="all", profile_key=C.PROF_KEY_NONE):
def removeBookmark(
self, type_, location, storage_type="all", profile_key=C.PROF_KEY_NONE
):
"""Remove a stored bookmark
@param type_: bookmark type, one of:
@ -331,26 +390,26 @@ class XEP_0048(object):
- "local": Store in SàT database
@param profile_key: %(doc_profile_key)s
"""
assert storage_type in ('all', 'pubsub', 'private', 'local')
assert storage_type in ("all", "pubsub", "private", "local")
client = self.host.getClient(profile_key)
if storage_type in ('all', 'local'):
if storage_type in ("all", "local"):
try:
del client.bookmarks_local[type_][location]
yield client.bookmarks_local.force(type_)
except KeyError:
log.debug("Bookmark is not present in local storage")
if storage_type in ('all', 'private'):
bookmarks = yield self._getServerBookmarks('private', client.profile)
if storage_type in ("all", "private"):
bookmarks = yield self._getServerBookmarks("private", client.profile)
try:
del bookmarks[type_][location]
bookmark_elt = self._dict2BookmarkElt(type_, bookmarks)
yield self._setServerBookmarks('private', bookmark_elt, client.profile)
yield self._setServerBookmarks("private", bookmark_elt, client.profile)
except KeyError:
log.debug("Bookmark is not present in private storage")
if storage_type == 'pubsub':
if storage_type == "pubsub":
raise NotImplementedError
def _bookmarksList(self, type_, storage_location, profile_key=C.PROF_KEY_NONE):
@ -381,10 +440,10 @@ class XEP_0048(object):
ret[_storage_location][bookmark.full()] = data[bookmark].copy()
return ret
for _storage_location in ('local', 'private', 'pubsub'):
if storage_location in ('all', _storage_location):
for _storage_location in ("local", "private", "pubsub"):
if storage_location in ("all", _storage_location):
ret[_storage_location] = {}
if _storage_location in ('private',):
if _storage_location in ("private",):
# we update distant bookmarks, just in case an other client added something
d = self._getServerBookmarks(_storage_location, client.profile)
else:
@ -394,7 +453,9 @@ class XEP_0048(object):
return ret_d
def _bookmarksRemove(self, type_, location, storage_location, profile_key=C.PROF_KEY_NONE):
def _bookmarksRemove(
self, type_, location, storage_location, profile_key=C.PROF_KEY_NONE
):
"""Return stored bookmarks
@param type_: bookmark type, one of:
@ -412,7 +473,9 @@ class XEP_0048(object):
location = jid.JID(location)
return self.removeBookmark(type_, location, storage_location, profile_key)
def _bookmarksAdd(self, type_, location, data, storage_type="auto", profile_key=C.PROF_KEY_NONE):
def _bookmarksAdd(
self, type_, location, data, storage_type="auto", profile_key=C.PROF_KEY_NONE
):
if type_ == XEP_0048.MUC_TYPE:
location = jid.JID(location)
return self.addBookmark(type_, location, data, storage_type, profile_key)
@ -427,21 +490,26 @@ class XEP_0048(object):
txt_cmd = self.host.plugins[C.TEXT_CMDS]
options = mess_data["unparsed"].strip().split()
if options and options[0] not in ('autojoin', 'remove'):
if options and options[0] not in ("autojoin", "remove"):
txt_cmd.feedBack(client, _("Bad arguments"), mess_data)
return False
room_jid = mess_data["to"].userhostJID()
if "remove" in options:
self.removeBookmark(XEP_0048.MUC_TYPE, room_jid, profile_key = client.profile)
txt_cmd.feedBack(client, _("All [%s] bookmarks are being removed") % room_jid.full(), mess_data)
self.removeBookmark(XEP_0048.MUC_TYPE, room_jid, profile_key=client.profile)
txt_cmd.feedBack(
client,
_("All [%s] bookmarks are being removed") % room_jid.full(),
mess_data,
)
return False
data = { "name": room_jid.user,
"nick": client.jid.user,
"autojoin": "true" if "autojoin" in options else "false",
}
data = {
"name": room_jid.user,
"nick": client.jid.user,
"autojoin": "true" if "autojoin" in options else "false",
}
self.addBookmark(XEP_0048.MUC_TYPE, room_jid, data, profile_key=client.profile)
txt_cmd.feedBack(client, _("Bookmark added"), mess_data)