plugin XEP-0346: "Form Discovery and Publishing" implementation:

this implementation replaces the former non standard node schema, and works in a similar
way (the schema is put in a separated node instead of a special field, thus it will now
work with most/all PubSub services, and not only SàT PubSub).

The implementation has been done in a way that nothing should be changed in frontends
(bridge methods names and arguments stay the same). The nodes are modified, but if values
are taken from backend, it's automatically adapted.
This commit is contained in:
Goffi 2020-12-11 17:57:00 +01:00
commit 968ee50d31
4 changed files with 158 additions and 134 deletions

View file

@ -29,14 +29,14 @@ from sat.core.log import getLogger
log = getLogger(__name__)
NS_MERGE_REQUESTS = 'org.salut-a-toi.merge_requests:0'
APP_NS_MERGE_REQUESTS = 'org.salut-a-toi.merge_requests:0'
PLUGIN_INFO = {
C.PI_NAME: _("Merge requests management"),
C.PI_IMPORT_NAME: "MERGE_REQUESTS",
C.PI_TYPE: "EXP",
C.PI_PROTOCOLS: [],
C.PI_DEPENDENCIES: ["XEP-0060", "PUBSUB_SCHEMA", "TICKETS", "TEXT_SYNTAXES"],
C.PI_DEPENDENCIES: ["XEP-0060", "XEP-0346", "TICKETS", "TEXT_SYNTAXES"],
C.PI_MAIN: "MergeRequests",
C.PI_HANDLER: "no",
C.PI_DESCRIPTION: _("""Merge requests management plugin""")
@ -68,9 +68,10 @@ class MergeRequests(object):
def __init__(self, host):
log.info(_("Merge requests plugin initialization"))
self.host = host
host.registerNamespace('merge_requests', NS_MERGE_REQUESTS)
self._s = self.host.plugins["XEP-0346"]
self.namespace = self._s.getSubmittedNS(APP_NS_MERGE_REQUESTS)
host.registerNamespace('merge_requests', self.namespace)
self._p = self.host.plugins["XEP-0060"]
self._s = self.host.plugins["PUBSUB_SCHEMA"]
self._t = self.host.plugins["TICKETS"]
self._handlers = {}
self._handlers_list = [] # handlers sorted by priority
@ -89,7 +90,7 @@ class MergeRequests(object):
method=lambda service, nodeIdentifier, profile_key:
self._s._getUISchema(service,
nodeIdentifier,
default_node=NS_MERGE_REQUESTS,
default_node=self.namespace,
profile_key=profile_key),
async_=True)
host.bridge.addMethod("mergeRequestParseData", ".plugin",
@ -172,7 +173,7 @@ class MergeRequests(object):
- list of parsed request data (if extra['parse'] is set, else empty list)
"""
if not node:
node = NS_MERGE_REQUESTS
node = self.namespace
if extra is None:
extra = {}
# XXX: Q&D way to get list for labels when displaying them, but text when we
@ -181,17 +182,19 @@ class MergeRequests(object):
filters = {'labels': self._s.textbox2ListFilter}
else:
filters = {}
tickets_xmlui, metadata = yield self._s.getDataFormItems(
client,
service,
node,
max_items=max_items,
item_ids=item_ids,
sub_id=sub_id,
rsm_request=rsm_request,
extra=extra,
form_ns=NS_MERGE_REQUESTS,
filters = filters)
tickets_xmlui, metadata = yield defer.ensureDeferred(
self._s.getDataFormItems(
client,
service,
node,
max_items=max_items,
item_ids=item_ids,
sub_id=sub_id,
rsm_request=rsm_request,
extra=extra,
form_ns=APP_NS_MERGE_REQUESTS,
filters = filters)
)
parsed_patches = []
if extra.get('parse', False):
for ticket in tickets_xmlui:
@ -228,7 +231,7 @@ class MergeRequests(object):
@return (unicode): id of the created item
"""
if not node:
node = NS_MERGE_REQUESTS
node = self.namespace
if values is None:
values = {}
update = extra.get('update', False)
@ -285,7 +288,7 @@ class MergeRequests(object):
values[FIELD_DATA] = data
item_id = await self._t.set(client, service, node, values, schema, item_id, extra,
deserialise, form_ns=NS_MERGE_REQUESTS)
deserialise, form_ns=APP_NS_MERGE_REQUESTS)
return item_id
def _parseData(self, data_type, data):
@ -326,14 +329,16 @@ class MergeRequests(object):
@param repository(unicode): path to the repository where the code stands
"""
if not node:
node = NS_MERGE_REQUESTS
tickets_xmlui, metadata = yield self._s.getDataFormItems(
client,
service,
node,
max_items=1,
item_ids=[item],
form_ns=NS_MERGE_REQUESTS)
node = self.namespace
tickets_xmlui, metadata = yield defer.ensureDeferred(
self._s.getDataFormItems(
client,
service,
node,
max_items=1,
item_ids=[item],
form_ns=APP_NS_MERGE_REQUESTS)
)
ticket_xmlui = tickets_xmlui[0]
data = ticket_xmlui.named_widgets[FIELD_DATA].value
data_type = ticket_xmlui.named_widgets[FIELD_DATA_TYPE].value

View file

@ -1,6 +1,5 @@
#!/usr/bin/env python3
# SAT plugin for Pubsub Schemas
# Copyright (C) 2009-2020 Jérôme Poisson (goffi@goffi.org)
# This program is free software: you can redistribute it and/or modify
@ -25,27 +24,29 @@ from sat.core.log import getLogger
log = getLogger(__name__)
NS_TICKETS = "org.salut-a-toi.tickets:0"
APP_NS_TICKETS = "org.salut-a-toi.tickets:0"
PLUGIN_INFO = {
C.PI_NAME: _("Tickets management"),
C.PI_IMPORT_NAME: "TICKETS",
C.PI_TYPE: "EXP",
C.PI_PROTOCOLS: [],
C.PI_DEPENDENCIES: ["XEP-0060", "PUBSUB_SCHEMA", "XEP-0277", "IDENTITY"],
C.PI_DEPENDENCIES: ["XEP-0060", "XEP-0346", "XEP-0277", "IDENTITY"],
C.PI_MAIN: "Tickets",
C.PI_HANDLER: "no",
C.PI_DESCRIPTION: _("""Tickets management plugin"""),
}
class Tickets(object):
class Tickets:
def __init__(self, host):
log.info(_("Tickets plugin initialization"))
self.host = host
host.registerNamespace("tickets", NS_TICKETS)
self._s = self.host.plugins["XEP-0346"]
self.namespace = self._s.getSubmittedNS(APP_NS_TICKETS)
host.registerNamespace("tickets", self.namespace)
self._p = self.host.plugins["XEP-0060"]
self._s = self.host.plugins["PUBSUB_SCHEMA"]
self._m = self.host.plugins["XEP-0277"]
host.bridge.addMethod(
"ticketsGet",
@ -60,8 +61,8 @@ class Tickets(object):
items_ids,
sub_id,
extra,
default_node=NS_TICKETS,
form_ns=NS_TICKETS,
default_node=self.namespace,
form_ns=APP_NS_TICKETS,
filters={
"author": self._s.valueOrPublisherFilter,
"created": self._s.dateFilter,
@ -84,7 +85,7 @@ class Tickets(object):
in_sign="sss",
out_sign="s",
method=lambda service, nodeIdentifier, profile_key: self._s._getUISchema(
service, nodeIdentifier, default_node=NS_TICKETS,
service, nodeIdentifier, default_node=self.namespace,
profile_key=profile_key),
async_=True,
)
@ -101,7 +102,7 @@ class Tickets(object):
return d
async def set(self, client, service, node, values, schema=None, item_id=None, extra=None,
deserialise=False, form_ns=NS_TICKETS):
deserialise=False, form_ns=APP_NS_TICKETS):
"""Publish a tickets
@param node(unicode, None): Pubsub node to use
@ -119,7 +120,7 @@ class Tickets(object):
@return (unicode): id of the created item
"""
if not node:
node = NS_TICKETS
node = self.namespace
if not item_id:
comments_service = await self._m.getCommentsService(client, service)

View file

@ -32,7 +32,7 @@ PLUGIN_INFO = {
C.PI_NAME: "tickets import",
C.PI_IMPORT_NAME: "TICKETS_IMPORT",
C.PI_TYPE: C.PLUG_TYPE_IMPORT,
C.PI_DEPENDENCIES: ["IMPORT", "XEP-0060", "XEP-0277", "PUBSUB_SCHEMA"],
C.PI_DEPENDENCIES: ["IMPORT", "XEP-0060", "XEP-0277", "XEP-0346"],
C.PI_MAIN: "TicketsImportPlugin",
C.PI_HANDLER: "no",
C.PI_DESCRIPTION: _(
@ -45,7 +45,7 @@ OPT_MAPPING = "mapping"
FIELDS_LIST = ("labels", "cc_emails") # fields which must have a list as value
FIELDS_DATE = ("created", "updated")
NS_TICKETS = "org.salut-a-toi.tickets:0"
NS_TICKETS = "fdp/submitted/org.salut-a-toi.tickets:0"
class TicketsImportPlugin(object):
@ -59,7 +59,7 @@ class TicketsImportPlugin(object):
self._importers = {}
self._p = host.plugins["XEP-0060"]
self._m = host.plugins["XEP-0277"]
self._s = host.plugins["PUBSUB_SCHEMA"]
self._s = host.plugins["XEP-0346"]
host.plugins["IMPORT"].initialize(self, "tickets")
@defer.inlineCallbacks
@ -161,8 +161,10 @@ class TicketsImportPlugin(object):
id=id_, title=ticket_data.get("title", "")
)
)
return self._s.sendDataFormItem(
client, service, node, ticket_data, session["schema"], id_
return defer.ensureDeferred(
self._s.sendDataFormItem(
client, service, node, ticket_data, session["schema"], id_
)
)
def itemFilters(self, client, ticket_data, session, options):

View file

@ -1,6 +1,6 @@
#!/usr/bin/env python3
# SAT plugin for Pubsub Schemas
# SàT plugin for XEP-0346
# Copyright (C) 2009-2020 Jérôme Poisson (goffi@goffi.org)
# This program is free software: you can redistribute it and/or modify
@ -37,11 +37,13 @@ from sat.core.log import getLogger
log = getLogger(__name__)
NS_SCHEMA = "https://salut-a-toi/protocol/schema:0"
NS_FDP = "urn:xmpp:fdp:0"
TEMPLATE_PREFIX = "fdp/template/"
SUBMITTED_PREFIX = "fdp/submitted/"
PLUGIN_INFO = {
C.PI_NAME: "PubSub Schema",
C.PI_IMPORT_NAME: "PUBSUB_SCHEMA",
C.PI_NAME: "Form Discovery and Publishing",
C.PI_IMPORT_NAME: "XEP-0346",
C.PI_TYPE: "EXP",
C.PI_PROTOCOLS: [],
C.PI_DEPENDENCIES: ["XEP-0060", "IDENTITY"],
@ -102,6 +104,18 @@ class PubsubSchema(object):
def getHandler(self, client):
return SchemaHandler()
def getApplicationNS(self, namespace):
"""Retrieve application namespace, i.e. namespace without FDP prefix"""
if namespace.startswith(SUBMITTED_PREFIX):
namespace = namespace[len(SUBMITTED_PREFIX):]
elif namespace.startswith(TEMPLATE_PREFIX):
namespace = namespace[len(TEMPLATE_PREFIX):]
return namespace
def getSubmittedNS(self, app_ns: str) -> str:
"""Returns node to use to submit forms"""
return f"{SUBMITTED_PREFIX}{app_ns}"
def _getSchemaBridgeCb(self, schema_elt):
if schema_elt is None:
return ""
@ -110,45 +124,37 @@ class PubsubSchema(object):
def _getSchema(self, service, nodeIdentifier, profile_key=C.PROF_KEY_NONE):
client = self.host.getClient(profile_key)
service = None if not service else jid.JID(service)
d = self.getSchema(client, service, nodeIdentifier)
d = defer.ensureDeferred(self.getSchema(client, service, nodeIdentifier))
d.addCallback(self._getSchemaBridgeCb)
return d
def _getSchemaCb(self, iq_elt):
try:
schema_elt = next(iq_elt.elements(NS_SCHEMA, "schema"))
except StopIteration:
raise exceptions.DataError("missing <schema> element")
try:
x_elt = next(schema_elt.elements((data_form.NS_X_DATA, "x")))
except StopIteration:
# there is not schema on this node
return None
return x_elt
def getSchema(self, client, service, nodeIdentifier):
async def getSchema(self, client, service, nodeIdentifier):
"""retrieve PubSub node schema
@param service(jid.JID, None): jid of PubSub service
None to use our PEP
@param nodeIdentifier(unicode): node to get schema from
@return (domish.Element, None): schema (<x> element)
None if not schema has been set on this node
None if no schema has been set on this node
"""
iq_elt = client.IQ("get")
if service is not None:
iq_elt["to"] = service.full()
pubsub_elt = iq_elt.addElement((NS_SCHEMA, "pubsub"))
schema_elt = pubsub_elt.addElement((NS_SCHEMA, "schema"))
schema_elt["node"] = nodeIdentifier
d = iq_elt.send()
d.addCallback(self._getSchemaCb)
return d
app_ns = self.getApplicationNS(nodeIdentifier)
node_id = f"{TEMPLATE_PREFIX}{app_ns}"
items_data = await self._p.getItems(client, service, node_id, max_items=1)
try:
schema = next(items_data[0][0].elements(data_form.NS_X_DATA, 'x'))
except IndexError:
schema = None
except StopIteration:
log.warning(
f"No schema found in item of {service!r} at node {nodeIdentifier!r}: "
f"\n{items_data[0][0].toXml()}"
)
schema = None
return schema
@defer.inlineCallbacks
def getSchemaForm(self, client, service, nodeIdentifier, schema=None,
async def getSchemaForm(self, client, service, nodeIdentifier, schema=None,
form_type="form", copy_form=True):
"""get data form from node's schema
"""Get data form from node's schema
@param service(None, jid.JID): PubSub service
@param nodeIdentifier(unicode): node
@ -164,7 +170,7 @@ class PubsubSchema(object):
"""
if schema is None:
log.debug(_("unspecified schema, we need to request it"))
schema = yield self.getSchema(client, service, nodeIdentifier)
schema = await self.getSchema(client, service, nodeIdentifier)
if schema is None:
raise exceptions.DataError(
_(
@ -183,14 +189,14 @@ class PubsubSchema(object):
formNamespace = schema.formNamespace,
fields = schema.fieldList,
)
defer.returnValue(schema)
return schema
try:
form = data_form.Form.fromElement(schema)
except data_form.Error as e:
raise exceptions.DataError(_("Invalid Schema: {msg}").format(msg=e))
form.formType = form_type
defer.returnValue(form)
return form
def schema2XMLUI(self, schema_elt):
form = data_form.Form.fromElement(schema_elt)
@ -210,31 +216,36 @@ class PubsubSchema(object):
return d
def getUISchema(self, client, service, nodeIdentifier):
d = self.getSchema(client, service, nodeIdentifier)
d = defer.ensureDeferred(self.getSchema(client, service, nodeIdentifier))
d.addCallback(self.schema2XMLUI)
return d
def _setSchema(self, service, nodeIdentifier, schema, profile_key=C.PROF_KEY_NONE):
client = self.host.getClient(profile_key)
service = None if not service else jid.JID(service)
schema = generic.parseXml(schema.encode("utf-8"))
return self.setSchema(client, service, nodeIdentifier, schema)
schema = generic.parseXml(schema.encode())
return defer.ensureDeferred(
self.setSchema(client, service, nodeIdentifier, schema)
)
def setSchema(self, client, service, nodeIdentifier, schema):
"""set or replace PubSub node schema
async def setSchema(self, client, service, nodeIdentifier, schema):
"""Set or replace PubSub node schema
@param schema(domish.Element, None): schema to set
None if schema need to be removed
"""
iq_elt = client.IQ()
if service is not None:
iq_elt["to"] = service.full()
pubsub_elt = iq_elt.addElement((NS_SCHEMA, "pubsub"))
schema_elt = pubsub_elt.addElement((NS_SCHEMA, "schema"))
schema_elt["node"] = nodeIdentifier
if schema is not None:
schema_elt.addChild(schema)
return iq_elt.send()
app_ns = self.getApplicationNS(nodeIdentifier)
node_id = f"{TEMPLATE_PREFIX}{app_ns}"
node_options = {
self._p.OPT_ACCESS_MODEL: self._p.ACCESS_OPEN,
self._p.OPT_PERSIST_ITEMS: 1,
self._p.OPT_MAX_ITEMS: 1,
self._p.OPT_DELIVER_PAYLOADS: 1,
self._p.OPT_SEND_ITEM_SUBSCRIBE: 1,
self._p.OPT_PUBLISH_MODEL: self._p.PUBLISH_MODEL_PUBLISHERS,
}
await self._p.createIfNewNode(client, service, node_id, node_options)
await self._p.sendItem(client, service, node_id, schema, self._p.ID_SINGLETON)
def _getDataFormItems(self, form_ns="", service="", node="", schema="", max_items=10,
item_ids=None, sub_id=None, extra_dict=None,
@ -249,23 +260,24 @@ class PubsubSchema(object):
schema = None
max_items = None if max_items == C.NO_LIMIT else max_items
extra = self._p.parseExtra(extra_dict)
d = self.getDataFormItems(
client,
service,
node,
schema,
max_items or None,
item_ids,
sub_id or None,
extra.rsm_request,
extra.extra,
form_ns=form_ns or None,
d = defer.ensureDeferred(
self.getDataFormItems(
client,
service,
node,
schema,
max_items or None,
item_ids,
sub_id or None,
extra.rsm_request,
extra.extra,
form_ns=form_ns or None,
)
)
d.addCallback(self._p.transItemsData)
return d
@defer.inlineCallbacks
def getDataFormItems(self, client, service, nodeIdentifier, schema=None,
async def getDataFormItems(self, client, service, nodeIdentifier, schema=None,
max_items=None, item_ids=None, sub_id=None, rsm_request=None,
extra=None, default_node=None, form_ns=None, filters=None):
"""Get items known as being data forms, and convert them to XMLUI
@ -289,10 +301,10 @@ class PubsubSchema(object):
)
nodeIdentifier = default_node
# we need the initial form to get options of fields when suitable
schema_form = yield self.getSchemaForm(
schema_form = await self.getSchemaForm(
client, service, nodeIdentifier, schema, form_type="result", copy_form=False
)
items_data = yield self._p.getItems(
items_data = await self._p.getItems(
client,
service,
nodeIdentifier,
@ -331,7 +343,7 @@ class PubsubSchema(object):
)
items_xmlui.append(xmlui)
break
defer.returnValue((items_xmlui, metadata))
return (items_xmlui, metadata)
def _sendDataFormItem(self, service, nodeIdentifier, values, schema=None,
item_id=None, extra=None, profile_key=C.PROF_KEY_NONE):
@ -341,22 +353,24 @@ class PubsubSchema(object):
schema = generic.parseXml(schema.encode("utf-8"))
else:
schema = None
d = self.sendDataFormItem(
client,
service,
nodeIdentifier,
values,
schema,
item_id or None,
extra,
deserialise=True,
d = defer.ensureDeferred(
self.sendDataFormItem(
client,
service,
nodeIdentifier,
values,
schema,
item_id or None,
extra,
deserialise=True,
)
)
d.addCallback(lambda ret: ret or "")
return d
@defer.inlineCallbacks
def sendDataFormItem(self, client, service, nodeIdentifier, values, schema=None,
item_id=None, extra=None, deserialise=False):
async def sendDataFormItem(
self, client, service, nodeIdentifier, values, schema=None, item_id=None,
extra=None, deserialise=False):
"""Publish an item as a dataform when we know that there is a schema
@param values(dict[key(unicode), [iterable[object], object]]): values set for the
@ -372,7 +386,7 @@ class PubsubSchema(object):
other parameters as the same as for [self._p.sendItem]
@return (unicode): id of the created item
"""
form = yield self.getSchemaForm(
form = await self.getSchemaForm(
client, service, nodeIdentifier, schema, form_type="submit"
)
@ -432,7 +446,7 @@ class PubsubSchema(object):
field.values = values_list
yield self._p.sendItem(
await self._p.sendItem(
client, service, nodeIdentifier, form.toElement(), item_id, extra
)
@ -520,18 +534,20 @@ class PubsubSchema(object):
client, service, node, max_items, extra, sub_id = self.prepareBridgeGet(
service, node, max_items, sub_id, extra, profile_key
)
d = self.getDataFormItems(
client,
service,
node or None,
max_items=max_items,
item_ids=item_ids,
sub_id=sub_id,
rsm_request=extra.rsm_request,
extra=extra.extra,
default_node=default_node,
form_ns=form_ns,
filters=filters,
d = defer.ensureDeferred(
self.getDataFormItems(
client,
service,
node or None,
max_items=max_items,
item_ids=item_ids,
sub_id=sub_id,
rsm_request=extra.rsm_request,
extra=extra.extra,
default_node=default_node,
form_ns=form_ns,
filters=filters,
)
)
d.addCallback(self._p.transItemsData)
d.addCallback(lambda data: data_format.serialise(data))
@ -670,7 +686,7 @@ class PubsubSchema(object):
class SchemaHandler(XMPPHandler):
def getDiscoInfo(self, requestor, service, nodeIdentifier=""):
return [disco.DiscoFeature(NS_SCHEMA)]
return [disco.DiscoFeature(NS_FDP)]
def getDiscoItems(self, requestor, service, nodeIdentifier=""):
return []