Mercurial > libervia-backend
annotate sat/plugins/plugin_misc_forums.py @ 3011:93da7c6f8e0c
plugin XEP-0198: retrieve missing messages + send buffered ones on hot reconnection:
Missing one2one messages are now retrieved with MAM on hot reconnection, and buffered ones
(which have most probably not been received by the server) are resent at the end of the
reconnection workflow. IQ results are not re-sent on hot reconnection, as they don't make
sense anymore with a new session.
fix 330
| author | Goffi <goffi@goffi.org> |
|---|---|
| date | Wed, 17 Jul 2019 09:28:35 +0200 |
| parents | 989b622faff6 |
| children | ab2696e34d29 |
| rev | line source |
|---|---|
| 2484 | 1 #!/usr/bin/env python2 |
| 2 # -*- coding: utf-8 -*- | |
| 3 | |
|
2959
989b622faff6
plugins schema, tickets, merge_requests: use serialised data for extra dict + some cosmetic changes
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
4 # SAT plugin for pubsub forums |
| 2771 | 5 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org) |
| 2484 | 6 |
| 7 # This program is free software: you can redistribute it and/or modify | |
| 8 # it under the terms of the GNU Affero General Public License as published by | |
| 9 # the Free Software Foundation, either version 3 of the License, or | |
| 10 # (at your option) any later version. | |
| 11 | |
| 12 # This program is distributed in the hope that it will be useful, | |
| 13 # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 15 # GNU Affero General Public License for more details. | |
| 16 | |
| 17 # You should have received a copy of the GNU Affero General Public License | |
| 18 # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 19 | |
| 20 from sat.core.i18n import _ | |
| 21 from sat.core.constants import Const as C | |
| 22 from sat.core import exceptions | |
| 23 from sat.core.log import getLogger | |
| 24 from sat.tools.common import uri | |
| 25 from twisted.words.protocols.jabber import jid | |
| 26 from twisted.words.xish import domish | |
| 27 from twisted.internet import defer | |
| 28 import shortuuid | |
| 29 import json | |
| 30 log = getLogger(__name__) | |
| 31 | |
| 32 NS_FORUMS = u'org.salut-a-toi.forums:0' | |
| 33 NS_FORUMS_TOPICS = NS_FORUMS + u'#topics' | |
| 34 | |
| 35 PLUGIN_INFO = { | |
| 36 C.PI_NAME: _("forums management"), | |
| 37 C.PI_IMPORT_NAME: "forums", | |
| 38 C.PI_TYPE: "EXP", | |
| 39 C.PI_PROTOCOLS: [], | |
| 40 C.PI_DEPENDENCIES: ["XEP-0060", "XEP-0277"], | |
| 41 C.PI_MAIN: "forums", | |
| 42 C.PI_HANDLER: "no", | |
| 43 C.PI_DESCRIPTION: _("""forums management plugin""") | |
| 44 } | |
| 45 FORUM_ATTR = {u'title', u'name', u'main-language', u'uri'} | |
| 46 FORUM_SUB_ELTS = (u'short-desc', u'desc') | |
| 47 FORUM_TOPICS_NODE_TPL = u'{node}#topics_{uuid}' | |
| 48 FORUM_TOPIC_NODE_TPL = u'{node}_{uuid}' | |
| 49 | |
| 50 | |
| 51 class forums(object): | |
| 52 | |
| 53 def __init__(self, host): | |
| 54 log.info(_(u"forums plugin initialization")) | |
| 55 self.host = host | |
| 56 self._m = self.host.plugins['XEP-0277'] | |
| 57 self._p = self.host.plugins['XEP-0060'] | |
| 58 self._node_options = { | |
| 59 self._p.OPT_ACCESS_MODEL: self._p.ACCESS_OPEN, | |
| 60 self._p.OPT_PERSIST_ITEMS: 1, | |
| 61 self._p.OPT_MAX_ITEMS: -1, | |
| 62 self._p.OPT_DELIVER_PAYLOADS: 1, | |
| 63 self._p.OPT_SEND_ITEM_SUBSCRIBE: 1, | |
| 64 self._p.OPT_PUBLISH_MODEL: self._p.ACCESS_OPEN, | |
| 65 } | |
| 66 host.registerNamespace('forums', NS_FORUMS) | |
| 67 host.bridge.addMethod("forumsGet", ".plugin", | |
| 68 in_sign='ssss', out_sign='s', | |
| 69 method=self._get, | |
| 70 async=True) | |
| 71 host.bridge.addMethod("forumsSet", ".plugin", | |
| 72 in_sign='sssss', out_sign='', | |
| 73 method=self._set, | |
| 74 async=True) | |
| 75 host.bridge.addMethod("forumTopicsGet", ".plugin", | |
| 76 in_sign='ssa{ss}s', out_sign='(aa{ss}a{ss})', | |
| 77 method=self._getTopics, | |
| 78 async=True) | |
| 79 host.bridge.addMethod("forumTopicCreate", ".plugin", | |
| 80 in_sign='ssa{ss}s', out_sign='', | |
| 81 method=self._createTopic, | |
| 82 async=True) | |
| 83 | |
| 84 @defer.inlineCallbacks | |
| 85 def _createForums(self, client, forums, service, node, forums_elt=None, names=None): | |
|
2959
989b622faff6
plugins schema, tickets, merge_requests: use serialised data for extra dict + some cosmetic changes
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
86 """Recursively create <forums> element(s) |
| 2484 | 87 |
| 88 @param forums(list): forums which may have subforums | |
| 89 @param service(jid.JID): service where the new nodes will be created | |
| 90 @param node(unicode): node of the forums | |
| 91 will be used as basis for the newly created nodes | |
| 92 @param parent_elt(domish.Element, None): element where the forum must be added | |
| 93 if None, the root <forums> element will be created | |
| 94 @return (domish.Element): created forums | |
| 95 """ | |
| 96 if not isinstance(forums, list): | |
| 97 raise ValueError(_(u"forums arguments must be a list of forums")) | |
| 98 if forums_elt is None: | |
| 99 forums_elt = domish.Element((NS_FORUMS, u'forums')) | |
| 100 assert names is None | |
| 101 names = set() | |
| 102 else: | |
| 103 if names is None or forums_elt.name != u'forums': | |
| 104 raise exceptions.InternalError(u'invalid forums or names') | |
| 105 assert names is not None | |
| 106 | |
| 107 for forum in forums: | |
| 108 if not isinstance(forum, dict): | |
| 109 raise ValueError(_(u"A forum item must be a dictionary")) | |
| 110 forum_elt = forums_elt.addElement('forum') | |
| 111 | |
| 112 for key, value in forum.iteritems(): | |
| 113 if key == u'name' and key in names: | |
| 114 raise exceptions.ConflictError(_(u"following forum name is not unique: {name}").format(name=key)) | |
| 115 if key == u'uri' and not value.strip(): | |
| 116 log.info(_(u"creating missing forum node")) | |
| 117 forum_node = FORUM_TOPICS_NODE_TPL.format(node=node, uuid=shortuuid.uuid()) | |
| 118 yield self._p.createNode(client, service, forum_node, self._node_options) | |
| 119 value = uri.buildXMPPUri(u'pubsub', | |
| 120 path=service.full(), | |
| 121 node=forum_node) | |
| 122 if key in FORUM_ATTR: | |
| 123 forum_elt[key] = value.strip() | |
| 124 elif key in FORUM_SUB_ELTS: | |
| 125 forum_elt.addElement(key, content=value) | |
| 126 elif key == u'sub-forums': | |
| 127 sub_forums_elt = forum_elt.addElement(u'forums') | |
| 128 yield self._createForums(client, value, service, node, sub_forums_elt, names=names) | |
| 129 else: | |
| 130 log.warning(_(u"Unknown forum attribute: {key}").format(key=key)) | |
| 131 if not forum_elt.getAttribute(u'title'): | |
| 132 name = forum_elt.getAttribute(u'name') | |
| 133 if name: | |
| 134 forum_elt[u'title'] = name | |
| 135 else: | |
| 136 raise ValueError(_(u"forum need a title or a name")) | |
| 137 if not forum_elt.getAttribute(u'uri') and not forum_elt.children: | |
| 138 raise ValueError(_(u"forum need uri or sub-forums")) | |
| 139 defer.returnValue(forums_elt) | |
| 140 | |
| 141 def _parseForums(self, parent_elt=None, forums=None): | |
|
2959
989b622faff6
plugins schema, tickets, merge_requests: use serialised data for extra dict + some cosmetic changes
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
142 """Recursivly parse a <forums> elements and return corresponding forums data |
| 2484 | 143 |
| 144 @param item(domish.Element): item with <forums> element | |
| 145 @param parent_elt(domish.Element, None): element to parse | |
| 146 @return (list): parsed data | |
| 147 @raise ValueError: item is invalid | |
| 148 """ | |
| 149 if parent_elt.name == u'item': | |
| 150 forums = [] | |
| 151 try: | |
| 152 forums_elt = next(parent_elt.elements(NS_FORUMS, u'forums')) | |
| 153 except StopIteration: | |
| 154 raise ValueError(_(u"missing <forums> element")) | |
| 155 else: | |
| 156 forums_elt = parent_elt | |
| 157 if forums is None: | |
| 158 raise exceptions.InternalError(u'expected forums') | |
| 159 if forums_elt.name != 'forums': | |
| 160 raise ValueError(_(u'Unexpected element: {xml}').format(xml=forums_elt.toXml())) | |
| 161 for forum_elt in forums_elt.elements(): | |
| 162 if forum_elt.name == 'forum': | |
| 163 data = {} | |
| 164 for attrib in FORUM_ATTR.intersection(forum_elt.attributes): | |
| 165 data[attrib] = forum_elt[attrib] | |
| 166 unknown = set(forum_elt.attributes).difference(FORUM_ATTR) | |
| 167 if unknown: | |
| 168 log.warning(_(u"Following attributes are unknown: {unknown}").format(unknown=unknown)) | |
| 169 for elt in forum_elt.elements(): | |
| 170 if elt.name in FORUM_SUB_ELTS: | |
| 171 data[elt.name] = unicode(elt) | |
| 172 elif elt.name == u'forums': | |
| 173 sub_forums = data[u'sub-forums'] = [] | |
| 174 self._parseForums(elt, sub_forums) | |
| 175 if not u'title' in data or not {u'uri', u'sub-forums'}.intersection(data): | |
| 176 log.warning(_(u"invalid forum, ignoring: {xml}").format(xml=forum_elt.toXml())) | |
| 177 else: | |
| 178 forums.append(data) | |
| 179 else: | |
| 180 log.warning(_(u"unkown forums sub element: {xml}").format(xml=forum_elt)) | |
| 181 | |
| 182 return forums | |
| 183 | |
| 184 def _get(self, service=None, node=None, forums_key=None, profile_key=C.PROF_KEY_NONE): | |
| 185 client = self.host.getClient(profile_key) | |
| 186 if service.strip(): | |
| 187 service = jid.JID(service) | |
| 188 else: | |
| 189 service = None | |
| 190 if not node.strip(): | |
| 191 node = None | |
| 192 d=self.get(client, service, node, forums_key or None) | |
| 193 d.addCallback(lambda data: json.dumps(data)) | |
| 194 return d | |
| 195 | |
| 196 @defer.inlineCallbacks | |
| 197 def get(self, client, service=None, node=None, forums_key=None): | |
| 198 if service is None: | |
| 199 service = client.pubsub_service | |
| 200 if node is None: | |
| 201 node = NS_FORUMS | |
| 202 if forums_key is None: | |
| 203 forums_key = u'default' | |
| 204 items_data = yield self._p.getItems(client, service, node, item_ids=[forums_key]) | |
| 205 item = items_data[0][0] | |
| 206 # we have the item and need to convert it to json | |
| 207 forums = self._parseForums(item) | |
| 208 defer.returnValue(forums) | |
| 209 | |
| 210 def _set(self, forums, service=None, node=None, forums_key=None, profile_key=C.PROF_KEY_NONE): | |
| 211 client = self.host.getClient(profile_key) | |
| 212 forums = json.loads(forums) | |
| 213 if service.strip(): | |
| 214 service = jid.JID(service) | |
| 215 else: | |
| 216 service = None | |
| 217 if not node.strip(): | |
| 218 node = None | |
| 219 return self.set(client, forums, service, node, forums_key or None) | |
| 220 | |
| 221 @defer.inlineCallbacks | |
| 222 def set(self, client, forums, service=None, node=None, forums_key=None): | |
|
2959
989b622faff6
plugins schema, tickets, merge_requests: use serialised data for extra dict + some cosmetic changes
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
223 """Create or replace forums structure |
| 2484 | 224 |
| 225 @param forums(list): list of dictionary as follow: | |
| 226 a dictionary represent a forum metadata, with the following keys: | |
| 227 - title: title of the forum | |
| 228 - name: short name (unique in those forums) for the forum | |
| 229 - main-language: main language to be use in the forums | |
| 230 - uri: XMPP uri to the microblog node hosting the forum | |
| 231 - short-desc: short description of the forum (in main-language) | |
| 232 - desc: long description of the forum (in main-language) | |
| 233 - sub-forums: a list of sub-forums with the same structure | |
| 234 title or name is needed, and uri or sub-forums | |
| 235 @param forums_key(unicode, None): key (i.e. item id) of the forums | |
| 236 may be used to store different forums structures for different languages | |
| 237 None to use "default" | |
| 238 """ | |
| 239 if service is None: | |
| 240 service = client.pubsub_service | |
| 241 if node is None: | |
| 242 node = NS_FORUMS | |
| 243 if forums_key is None: | |
| 244 forums_key = u'default' | |
| 245 forums_elt = yield self._createForums(client, forums, service, node) | |
| 246 yield self._p.sendItem(client, service, node, forums_elt, item_id=forums_key) | |
| 247 | |
| 248 def _getTopics(self, service, node, extra=None, profile_key=C.PROF_KEY_NONE): | |
| 249 client = self.host.getClient(profile_key) | |
| 250 extra = self._p.parseExtra(extra) | |
| 251 d = self.getTopics(client, jid.JID(service), node, rsm_request=extra.rsm_request, extra=extra.extra) | |
| 252 d.addCallback(lambda(topics, metadata): (topics, {k: unicode(v) for k,v in metadata.iteritems()})) | |
| 253 return d | |
| 254 | |
| 255 @defer.inlineCallbacks | |
| 256 def getTopics(self, client, service, node, rsm_request=None, extra=None): | |
|
2959
989b622faff6
plugins schema, tickets, merge_requests: use serialised data for extra dict + some cosmetic changes
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
257 """Retrieve topics data |
| 2484 | 258 |
| 259 Topics are simple microblog URIs with some metadata duplicated from first post | |
| 260 """ | |
| 261 topics_data = yield self._p.getItems(client, service, node, rsm_request=rsm_request, extra=extra) | |
| 262 topics = [] | |
| 263 item_elts, metadata = topics_data | |
| 264 for item_elt in item_elts: | |
| 265 topic_elt = next(item_elt.elements(NS_FORUMS, u'topic')) | |
| 266 title_elt = next(topic_elt.elements(NS_FORUMS, u'title')) | |
| 267 topic = {u'uri': topic_elt[u'uri'], | |
| 268 u'author': topic_elt[u'author'], | |
| 269 u'title': unicode(title_elt)} | |
| 270 topics.append(topic) | |
| 271 defer.returnValue((topics, metadata)) | |
| 272 | |
| 273 def _createTopic(self, service, node, mb_data, profile_key): | |
| 274 client = self.host.getClient(profile_key) | |
| 275 return self.createTopic(client, jid.JID(service), node, mb_data) | |
| 276 | |
| 277 @defer.inlineCallbacks | |
| 278 def createTopic(self, client, service, node, mb_data): | |
| 279 try: | |
| 280 title = mb_data[u'title'] | |
| 281 if not u'content' in mb_data: | |
| 282 raise KeyError(u'content') | |
| 283 except KeyError as e: | |
| 284 raise exceptions.DataError(u"missing mandatory data: {key}".format(key=e.args[0])) | |
| 285 | |
| 286 topic_node = FORUM_TOPIC_NODE_TPL.format(node=node, uuid=shortuuid.uuid()) | |
| 287 yield self._p.createNode(client, service, topic_node, self._node_options) | |
| 288 self._m.send(client, mb_data, service, topic_node) | |
| 289 topic_uri = uri.buildXMPPUri(u'pubsub', | |
| 290 subtype=u'microblog', | |
| 291 path=service.full(), | |
| 292 node=topic_node) | |
| 293 topic_elt = domish.Element((NS_FORUMS, 'topic')) | |
| 294 topic_elt[u'uri'] = topic_uri | |
| 295 topic_elt[u'author'] = client.jid.userhost() | |
| 296 topic_elt.addElement(u'title', content = title) | |
| 297 yield self._p.sendItem(client, service, node, topic_elt) |