829 lines
31 KiB
Python
829 lines
31 KiB
Python
#!/usr/bin/env python3
|
||
|
||
# SàT plugin for XEP-0346
|
||
# Copyright (C) 2009-2026 Jérôme Poisson (goffi@goffi.org)
|
||
|
||
# This program is free software: you can redistribute it and/or modify
|
||
# it under the terms of the GNU Affero General Public License as published by
|
||
# the Free Software Foundation, either version 3 of the License, or
|
||
# (at your option) any later version.
|
||
|
||
# This program is distributed in the hope that it will be useful,
|
||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
# GNU Affero General Public License for more details.
|
||
|
||
# You should have received a copy of the GNU Affero General Public License
|
||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
||
from collections.abc import Iterable
|
||
import itertools
|
||
from typing import Optional
|
||
from zope.interface import implementer
|
||
from twisted.words.protocols.jabber import jid
|
||
from twisted.words.protocols.jabber.xmlstream import XMPPHandler
|
||
from twisted.words.xish import domish
|
||
from twisted.internet import defer
|
||
from tx_xmpp import disco, itx_xmpp
|
||
from tx_xmpp import data_form
|
||
from tx_xmpp import generic
|
||
from libervia.backend.core.i18n import _
|
||
from libervia.backend.core import exceptions
|
||
from libervia.backend.core.constants import Const as C
|
||
from libervia.backend.core.xmpp import SatXMPPEntity
|
||
from libervia.backend.tools import xml_tools
|
||
from libervia.backend.tools import utils
|
||
from libervia.backend.tools.common import date_utils
|
||
from libervia.backend.tools.common import data_format
|
||
from libervia.backend.core.log import getLogger
|
||
|
||
log = getLogger(__name__)
|
||
|
||
NS_FDP = "urn:xmpp:fdp:0"
|
||
TEMPLATE_PREFIX = "fdp/template/"
|
||
SUBMITTED_PREFIX = "fdp/submitted/"
|
||
|
||
PLUGIN_INFO = {
|
||
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"],
|
||
C.PI_MAIN: "PubsubSchema",
|
||
C.PI_HANDLER: "yes",
|
||
C.PI_DESCRIPTION: _("""Handle Pubsub data schemas"""),
|
||
}
|
||
|
||
|
||
class PubsubSchema(object):
|
||
def __init__(self, host):
|
||
log.info(_("PubSub Schema initialization"))
|
||
self.host = host
|
||
self._p = self.host.plugins["XEP-0060"]
|
||
self._i = self.host.plugins["IDENTITY"]
|
||
host.bridge.add_method(
|
||
"ps_schema_get",
|
||
".plugin",
|
||
in_sign="sss",
|
||
out_sign="s",
|
||
method=self._get_schema,
|
||
async_=True,
|
||
)
|
||
host.bridge.add_method(
|
||
"ps_schema_set",
|
||
".plugin",
|
||
in_sign="ssss",
|
||
out_sign="",
|
||
method=self._set_schema,
|
||
async_=True,
|
||
)
|
||
host.bridge.add_method(
|
||
"ps_schema_ui_get",
|
||
".plugin",
|
||
in_sign="sss",
|
||
out_sign="s",
|
||
method=lambda service, nodeIdentifier, profile_key: self._get_ui_schema(
|
||
service, nodeIdentifier, default_node=None, profile_key=profile_key
|
||
),
|
||
async_=True,
|
||
)
|
||
host.bridge.add_method(
|
||
"ps_schema_dict_get",
|
||
".plugin",
|
||
in_sign="sss",
|
||
out_sign="s",
|
||
method=self._get_schema_dict,
|
||
async_=True,
|
||
)
|
||
host.bridge.add_method(
|
||
"ps_schema_application_ns_get",
|
||
".plugin",
|
||
in_sign="s",
|
||
out_sign="s",
|
||
method=self.get_application_ns,
|
||
)
|
||
host.bridge.add_method(
|
||
"ps_schema_template_node_get",
|
||
".plugin",
|
||
in_sign="s",
|
||
out_sign="s",
|
||
method=self.get_template_ns,
|
||
)
|
||
host.bridge.add_method(
|
||
"ps_schema_submitted_node_get",
|
||
".plugin",
|
||
in_sign="s",
|
||
out_sign="s",
|
||
method=self.get_submitted_ns,
|
||
)
|
||
host.bridge.add_method(
|
||
"ps_items_form_get",
|
||
".plugin",
|
||
in_sign="ssssiassss",
|
||
out_sign="(asa{ss})",
|
||
method=self._get_data_form_items,
|
||
async_=True,
|
||
)
|
||
host.bridge.add_method(
|
||
"ps_item_form_send",
|
||
".plugin",
|
||
in_sign="ssa{sas}ssa{ss}s",
|
||
out_sign="s",
|
||
method=self._send_data_form_item,
|
||
async_=True,
|
||
)
|
||
|
||
def get_handler(self, client):
|
||
return SchemaHandler()
|
||
|
||
def get_application_ns(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 get_template_ns(self, namespace: str) -> str:
|
||
"""Returns node used for data template (i.e. schema)"""
|
||
app_ns = self.get_application_ns(namespace)
|
||
return f"{TEMPLATE_PREFIX}{app_ns}"
|
||
|
||
def get_submitted_ns(self, namespace: str) -> str:
|
||
"""Returns node to use to submit forms"""
|
||
return f"{SUBMITTED_PREFIX}{self.get_application_ns(namespace)}"
|
||
|
||
def _get_schema_bridge_cb(self, schema_elt):
|
||
if schema_elt is None:
|
||
return ""
|
||
return schema_elt.toXml()
|
||
|
||
def _get_schema(self, service, nodeIdentifier, profile_key=C.PROF_KEY_NONE):
|
||
client = self.host.get_client(profile_key)
|
||
service = None if not service else jid.JID(service)
|
||
d = defer.ensureDeferred(self.get_schema(client, service, nodeIdentifier))
|
||
d.addCallback(self._get_schema_bridge_cb)
|
||
return d
|
||
|
||
async def get_schema(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 no schema has been set on this node
|
||
"""
|
||
app_ns = self.get_application_ns(nodeIdentifier)
|
||
node_id = f"{TEMPLATE_PREFIX}{app_ns}"
|
||
items_data = await self._p.get_items(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
|
||
|
||
async def get_schema_form(
|
||
self,
|
||
client,
|
||
service,
|
||
nodeIdentifier,
|
||
schema=None,
|
||
form_type="form",
|
||
copy_form=True,
|
||
):
|
||
"""Get data form from node's schema
|
||
|
||
@param service(None, jid.JID): PubSub service
|
||
@param nodeIdentifier(unicode): node
|
||
@param schema(domish.Element, data_form.Form, None): node schema
|
||
if domish.Element, will be converted to data form
|
||
if data_form.Form it will be returned without modification
|
||
if None, it will be retrieved from node (imply one additional XMPP request)
|
||
@param form_type(unicode): type of the form
|
||
@param copy_form(bool): if True and if schema is already a data_form.Form, will deep copy it before returning
|
||
needed when the form is reused and it will be modified (e.g. in send_data_form_item)
|
||
@return(data_form.Form): data form
|
||
the form should not be modified if copy_form is not set
|
||
"""
|
||
if schema is None:
|
||
log.debug(_("unspecified schema, we need to request it"))
|
||
schema = await self.get_schema(client, service, nodeIdentifier)
|
||
if schema is None:
|
||
raise exceptions.DataError(
|
||
_(
|
||
"no schema specified, and this node has no schema either, we can't construct the data form"
|
||
)
|
||
)
|
||
elif isinstance(schema, data_form.Form):
|
||
if copy_form:
|
||
# XXX: we don't use deepcopy as it will do an infinite loop if a
|
||
# domish.Element is present in the form fields (happens for
|
||
# XEP-0315 data forms XML Element)
|
||
schema = data_form.Form(
|
||
formType=schema.formType,
|
||
title=schema.title,
|
||
instructions=schema.instructions[:],
|
||
formNamespace=schema.formNamespace,
|
||
fields=schema.fieldList,
|
||
)
|
||
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
|
||
return form
|
||
|
||
def schema_2_xmlui(self, schema_elt):
|
||
form = data_form.Form.fromElement(schema_elt)
|
||
xmlui = xml_tools.data_form_2_xmlui(form, "")
|
||
return xmlui
|
||
|
||
def _get_ui_schema(
|
||
self, service, nodeIdentifier, default_node=None, profile_key=C.PROF_KEY_NONE
|
||
):
|
||
if not nodeIdentifier:
|
||
if not default_node:
|
||
raise ValueError(_("nodeIndentifier needs to be set"))
|
||
nodeIdentifier = default_node
|
||
client = self.host.get_client(profile_key)
|
||
service = None if not service else jid.JID(service)
|
||
d = self.get_ui_schema(client, service, nodeIdentifier)
|
||
d.addCallback(lambda xmlui: xmlui.toXml())
|
||
return d
|
||
|
||
def get_ui_schema(self, client, service, nodeIdentifier):
|
||
d = defer.ensureDeferred(self.get_schema(client, service, nodeIdentifier))
|
||
d.addCallback(self.schema_2_xmlui)
|
||
return d
|
||
|
||
def _set_schema(self, service, nodeIdentifier, schema, profile_key=C.PROF_KEY_NONE):
|
||
client = self.host.get_client(profile_key)
|
||
service = None if not service else jid.JID(service)
|
||
schema = generic.parseXml(schema.encode())
|
||
return defer.ensureDeferred(
|
||
self.set_schema(client, service, nodeIdentifier, schema)
|
||
)
|
||
|
||
async def set_schema(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
|
||
"""
|
||
node_id = self.get_template_ns(nodeIdentifier)
|
||
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.create_if_new_node(client, service, node_id, node_options)
|
||
await self._p.send_item(client, service, node_id, schema, self._p.ID_SINGLETON)
|
||
|
||
def _get_schema_dict(self, service, nodeIdentifier, profile):
|
||
service = None if not service else jid.JID(service)
|
||
client = self.host.get_client(profile)
|
||
d = defer.ensureDeferred(self.get_schema_dict(client, service, nodeIdentifier))
|
||
d.addCallback(data_format.serialise)
|
||
return d
|
||
|
||
async def get_schema_dict(
|
||
self, client: SatXMPPEntity, service: Optional[jid.JID], nodeIdentifier: str
|
||
) -> dict:
|
||
"""Retrieve a node schema and format it a simple dictionary
|
||
|
||
The dictionary is made so it can be easily serialisable
|
||
"""
|
||
schema_form = await self.get_schema_form(client, service, nodeIdentifier)
|
||
return xml_tools.data_form_2_data_dict(schema_form)
|
||
|
||
def _get_data_form_items(
|
||
self,
|
||
form_ns="",
|
||
service="",
|
||
node="",
|
||
schema="",
|
||
max_items=10,
|
||
item_ids=None,
|
||
sub_id=None,
|
||
extra="",
|
||
profile_key=C.PROF_KEY_NONE,
|
||
):
|
||
client = self.host.get_client(profile_key)
|
||
service = jid.JID(service) if service else None
|
||
if not node:
|
||
raise exceptions.DataError(_("empty node is not allowed"))
|
||
if schema:
|
||
schema = generic.parseXml(schema.encode("utf-8"))
|
||
else:
|
||
schema = None
|
||
max_items = None if max_items == C.NO_LIMIT else max_items
|
||
extra = self._p.parse_extra(data_format.deserialise(extra))
|
||
d = defer.ensureDeferred(
|
||
self.get_data_form_items(
|
||
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.trans_items_data)
|
||
return d
|
||
|
||
async def get_data_form_items(
|
||
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
|
||
|
||
@param schema(domish.Element, data_form.Form, None): schema of the node if known
|
||
if None, it will be retrieved from node
|
||
@param default_node(unicode): node to use if nodeIdentifier is None or empty
|
||
@param form_ns (unicode, None): namespace of the form
|
||
None to accept everything, even if form has no namespace
|
||
@param filters(dict, None): same as for xml_tools.data_form_result_2_xmlui
|
||
other parameters as the same as for [get_items]
|
||
@return (list[unicode]): XMLUI of the forms
|
||
if an item is invalid (not corresponding to form_ns or not a data_form)
|
||
it will be skipped
|
||
@raise ValueError: one argument is invalid
|
||
"""
|
||
if not nodeIdentifier:
|
||
if not default_node:
|
||
raise ValueError(
|
||
_("default_node must be set if nodeIdentifier is not set")
|
||
)
|
||
nodeIdentifier = default_node
|
||
submitted_ns = self.get_submitted_ns(nodeIdentifier)
|
||
# we need the initial form to get options of fields when suitable
|
||
schema_form = await self.get_schema_form(
|
||
client, service, nodeIdentifier, schema, form_type="result", copy_form=False
|
||
)
|
||
items_data = await self._p.get_items(
|
||
client,
|
||
service,
|
||
submitted_ns,
|
||
max_items,
|
||
item_ids,
|
||
sub_id,
|
||
rsm_request,
|
||
extra,
|
||
)
|
||
items, metadata = items_data
|
||
items_xmlui = []
|
||
for item_elt in items:
|
||
for x_elt in item_elt.elements(data_form.NS_X_DATA, "x"):
|
||
form = data_form.Form.fromElement(x_elt)
|
||
if form_ns and form.formNamespace != form_ns:
|
||
log.debug(
|
||
f"form's namespace ({form.formNamespace!r}) differs from expected"
|
||
f"{form_ns!r}"
|
||
)
|
||
continue
|
||
prepend = [
|
||
("label", "id"),
|
||
("text", item_elt["id"], "id"),
|
||
("label", "publisher"),
|
||
]
|
||
try:
|
||
publisher = jid.JID(item_elt["publisher"])
|
||
except (KeyError, jid.InvalidFormat):
|
||
pass
|
||
else:
|
||
prepend.append(("jid", publisher, "publisher"))
|
||
xmlui = xml_tools.data_form_result_2_xmlui(
|
||
form,
|
||
schema_form,
|
||
# FIXME: conflicts with schema (i.e. if "id" or "publisher" already exists)
|
||
# are not checked
|
||
prepend=prepend,
|
||
filters=filters,
|
||
read_only=False,
|
||
)
|
||
items_xmlui.append(xmlui)
|
||
break
|
||
return (items_xmlui, metadata)
|
||
|
||
def _send_data_form_item(
|
||
self,
|
||
service,
|
||
nodeIdentifier,
|
||
values,
|
||
schema=None,
|
||
item_id=None,
|
||
extra=None,
|
||
profile_key=C.PROF_KEY_NONE,
|
||
):
|
||
client = self.host.get_client(profile_key)
|
||
service = None if not service else jid.JID(service)
|
||
if schema:
|
||
schema = generic.parseXml(schema.encode("utf-8"))
|
||
else:
|
||
schema = None
|
||
d = defer.ensureDeferred(
|
||
self.send_data_form_item(
|
||
client,
|
||
service,
|
||
nodeIdentifier,
|
||
values,
|
||
schema,
|
||
item_id or None,
|
||
extra,
|
||
deserialise=True,
|
||
)
|
||
)
|
||
d.addCallback(lambda ret: ret or "")
|
||
return d
|
||
|
||
async def send_data_form_item(
|
||
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
|
||
form. If not iterable, will be put in a list.
|
||
@param schema(domish.Element, data_form.Form, None): data schema
|
||
None to retrieve data schema from node (need to do a additional XMPP call)
|
||
Schema is needed to construct data form to publish
|
||
@param deserialise(bool): if True, data are list of unicode and must be
|
||
deserialized according to expected type.
|
||
This is done in this method and not directly in _send_data_form_item because we
|
||
need to know the data type which is in the form, not availablable in
|
||
_send_data_form_item
|
||
other parameters as the same as for [self._p.send_item]
|
||
@return (unicode): id of the created item
|
||
"""
|
||
form = await self.get_schema_form(
|
||
client, service, nodeIdentifier, schema, form_type="submit"
|
||
)
|
||
|
||
for name, values_list in values.items():
|
||
try:
|
||
field = form.fields[name]
|
||
except KeyError:
|
||
log.warning(
|
||
_("field {name} doesn't exist, ignoring it").format(name=name)
|
||
)
|
||
continue
|
||
if isinstance(values_list, str) or not isinstance(values_list, Iterable):
|
||
values_list = [values_list]
|
||
if deserialise:
|
||
if field.fieldType == "boolean":
|
||
values_list = [C.bool(v) for v in values_list]
|
||
elif field.fieldType == "text-multi":
|
||
# for text-multi, lines must be put on separate values
|
||
values_list = list(
|
||
itertools.chain(*[v.splitlines() for v in values_list])
|
||
)
|
||
elif xml_tools.is_xhtml_field(field):
|
||
values_list = [
|
||
generic.parseXml(v.encode("utf-8")) for v in values_list
|
||
]
|
||
elif "jid" in (field.fieldType or ""):
|
||
values_list = [jid.JID(v) for v in values_list]
|
||
if "list" in (field.fieldType or ""):
|
||
# for lists, we check that given values are allowed in form
|
||
allowed_values = [o.value for o in field.options]
|
||
values_list = [v for v in values_list if v in allowed_values]
|
||
if not values_list:
|
||
# if values don't map to allowed values, we use default ones
|
||
values_list = field.values
|
||
elif field.ext_type == "xml":
|
||
# FIXME: XML elements are not handled correctly, we need to know if we
|
||
# have actual XML/XHTML, or text to escape
|
||
for idx, value in enumerate(values_list[:]):
|
||
if isinstance(value, domish.Element):
|
||
if field.value and (
|
||
value.name != field.value.name or value.uri != field.value.uri
|
||
):
|
||
# the element is not the one expected in form, so we create the right element
|
||
# to wrap the current value
|
||
wrapper_elt = domish.Element(
|
||
(field.value.uri, field.value.name)
|
||
)
|
||
wrapper_elt.addChild(value)
|
||
values_list[idx] = wrapper_elt
|
||
else:
|
||
# we have to convert the value to a domish.Element
|
||
if field.value and field.value.uri == C.NS_XHTML:
|
||
div_elt = domish.Element((C.NS_XHTML, "div"))
|
||
div_elt.addContent(str(value))
|
||
values_list[idx] = div_elt
|
||
else:
|
||
# only XHTML fields are handled for now
|
||
raise NotImplementedError
|
||
|
||
field.values = values_list
|
||
|
||
return await self._p.send_item(
|
||
client, service, nodeIdentifier, form.toElement(), item_id, extra
|
||
)
|
||
|
||
## filters ##
|
||
# filters useful for data form to XMLUI conversion #
|
||
|
||
def value_or_publisher_filter(self, form_xmlui, widget_type, args, kwargs):
|
||
"""Replace missing value by publisher's user part"""
|
||
if not args[0]:
|
||
# value is not filled: we use user part of publisher (if we have it)
|
||
try:
|
||
publisher = jid.JID(form_xmlui.named_widgets["publisher"].value)
|
||
except (KeyError, RuntimeError):
|
||
pass
|
||
else:
|
||
args[0] = publisher.user.capitalize()
|
||
return widget_type, args, kwargs
|
||
|
||
def textbox_2_list_filter(self, form_xmlui, widget_type, args, kwargs):
|
||
"""Split lines of a textbox in a list
|
||
|
||
main use case is using a textbox for labels
|
||
"""
|
||
if widget_type != "textbox":
|
||
return widget_type, args, kwargs
|
||
widget_type = "list"
|
||
options = [o for o in args.pop(0).split("\n") if o]
|
||
kwargs = {
|
||
"options": options,
|
||
"name": kwargs.get("name"),
|
||
"styles": ("noselect", "extensible", "reducible"),
|
||
}
|
||
return widget_type, args, kwargs
|
||
|
||
def date_filter(self, form_xmlui, widget_type, args, kwargs):
|
||
"""Convert a string with a date to a unix timestamp"""
|
||
if widget_type != "string" or not args[0]:
|
||
return widget_type, args, kwargs
|
||
# we convert XMPP date to timestamp
|
||
try:
|
||
args[0] = str(date_utils.date_parse(args[0]))
|
||
except Exception as e:
|
||
log.warning(_("Can't parse date field: {msg}").format(msg=e))
|
||
return widget_type, args, kwargs
|
||
|
||
## Helper methods ##
|
||
|
||
def prepare_bridge_get(self, service, node, max_items, sub_id, extra, profile_key):
|
||
"""Parse arguments received from bridge *Get methods and return higher level data
|
||
|
||
@return (tuple): (client, service, node, max_items, extra, sub_id) usable for
|
||
internal methods
|
||
"""
|
||
client = self.host.get_client(profile_key)
|
||
service = jid.JID(service) if service else None
|
||
if not node:
|
||
node = None
|
||
max_items = None if max_items == C.NO_LIMIT else max_items
|
||
if not sub_id:
|
||
sub_id = None
|
||
extra = self._p.parse_extra(extra)
|
||
|
||
return client, service, node, max_items, extra, sub_id
|
||
|
||
def _get(
|
||
self,
|
||
service="",
|
||
node="",
|
||
max_items=10,
|
||
item_ids=None,
|
||
sub_id=None,
|
||
extra="",
|
||
default_node=None,
|
||
form_ns=None,
|
||
filters=None,
|
||
profile_key=C.PROF_KEY_NONE,
|
||
):
|
||
"""bridge method to retrieve data from node with schema
|
||
|
||
this method is a helper so dependant plugins can use it directly
|
||
when adding *Get methods
|
||
extra can have the key "labels_as_list" which is a hack to convert
|
||
labels from textbox to list in XMLUI, which usually render better
|
||
in final UI.
|
||
"""
|
||
if filters is None:
|
||
filters = {}
|
||
extra = data_format.deserialise(extra)
|
||
# XXX: Q&D way to get list for labels when displaying them, but text when we
|
||
# have to modify them
|
||
if C.bool(extra.get("labels_as_list", C.BOOL_FALSE)):
|
||
filters = filters.copy()
|
||
filters["labels"] = self.textbox_2_list_filter
|
||
client, service, node, max_items, extra, sub_id = self.prepare_bridge_get(
|
||
service, node, max_items, sub_id, extra, profile_key
|
||
)
|
||
d = defer.ensureDeferred(
|
||
self.get_data_form_items(
|
||
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.trans_items_data)
|
||
d.addCallback(lambda data: data_format.serialise(data))
|
||
return d
|
||
|
||
def prepare_bridge_set(self, service, node, schema, item_id, extra, profile_key):
|
||
"""Parse arguments received from bridge *Set methods and return higher level data
|
||
|
||
@return (tuple): (client, service, node, schema, item_id, extra) usable for
|
||
internal methods
|
||
"""
|
||
client = self.host.get_client(profile_key)
|
||
service = None if not service else jid.JID(service)
|
||
if schema:
|
||
schema = generic.parseXml(schema.encode("utf-8"))
|
||
else:
|
||
schema = None
|
||
extra = data_format.deserialise(extra)
|
||
return client, service, node or None, schema, item_id or None, extra
|
||
|
||
async def copy_missing_values(self, client, service, node, item_id, form_ns, values):
|
||
"""Retrieve values existing in original item and missing in update
|
||
|
||
Existing item will be retrieve, and values not already specified in values will
|
||
be filled
|
||
@param service: same as for [XEP_0060.get_items]
|
||
@param node: same as for [XEP_0060.get_items]
|
||
@param item_id(unicode): id of the item to retrieve
|
||
@param form_ns (unicode, None): namespace of the form
|
||
@param values(dict): values to fill
|
||
This dict will be modified *in place* to fill value present in existing
|
||
item and missing in the dict.
|
||
"""
|
||
try:
|
||
# we get previous item
|
||
items_data = await self._p.get_items(
|
||
client, service, node, item_ids=[item_id]
|
||
)
|
||
item_elt = items_data[0][0]
|
||
except Exception as e:
|
||
log.warning(
|
||
_("Can't get previous item, update ignored: {reason}").format(reason=e)
|
||
)
|
||
else:
|
||
# and parse it
|
||
form = data_form.findForm(item_elt, form_ns)
|
||
if form is None:
|
||
log.warning(
|
||
_("Can't parse previous item, update ignored: data form not found")
|
||
)
|
||
else:
|
||
for name, field in form.fields.items():
|
||
if name not in values:
|
||
values[name] = "\n".join(str(v) for v in field.values)
|
||
|
||
def _set(
|
||
self,
|
||
service,
|
||
node,
|
||
values,
|
||
schema=None,
|
||
item_id=None,
|
||
extra=None,
|
||
default_node=None,
|
||
form_ns=None,
|
||
fill_author=True,
|
||
profile_key=C.PROF_KEY_NONE,
|
||
):
|
||
"""bridge method to set item in node with schema
|
||
|
||
this method is a helper so dependant plugins can use it directly
|
||
when adding *Set methods
|
||
"""
|
||
client, service, node, schema, item_id, extra = self.prepare_bridge_set(
|
||
service, node, schema, item_id, extra
|
||
)
|
||
d = defer.ensureDeferred(
|
||
self.set(
|
||
client,
|
||
service,
|
||
node,
|
||
values,
|
||
schema,
|
||
item_id,
|
||
extra,
|
||
deserialise=True,
|
||
form_ns=form_ns,
|
||
default_node=default_node,
|
||
fill_author=fill_author,
|
||
)
|
||
)
|
||
d.addCallback(lambda ret: ret or "")
|
||
return d
|
||
|
||
async def set(
|
||
self,
|
||
client,
|
||
service,
|
||
node,
|
||
values,
|
||
schema,
|
||
item_id,
|
||
extra,
|
||
deserialise,
|
||
form_ns,
|
||
default_node=None,
|
||
fill_author=True,
|
||
):
|
||
"""Set an item in a node with a schema
|
||
|
||
This method can be used directly by *Set methods added by dependant plugin
|
||
@param values(dict[key(unicode), [iterable[object]|object]]): values of the items
|
||
if value is not iterable, it will be put in a list
|
||
'created' and 'updated' will be forced to current time:
|
||
- 'created' is set if item_id is None, i.e. if it's a new ticket
|
||
- 'updated' is set everytime
|
||
@param extra(dict, None): same as for [XEP-0060.send_item] with additional keys:
|
||
- update(bool): if True, get previous item data to merge with current one
|
||
if True, item_id must be set
|
||
@param form_ns (unicode, None): namespace of the form
|
||
needed when an update is done
|
||
@param default_node(unicode, None): value to use if node is not set
|
||
other arguments are same as for [self._s.send_data_form_item]
|
||
@return (unicode): id of the created item
|
||
"""
|
||
if extra is None:
|
||
extra = {}
|
||
if not node:
|
||
if default_node is None:
|
||
raise ValueError(_("default_node must be set if node is not set"))
|
||
node = default_node
|
||
node = self.get_submitted_ns(node)
|
||
now = utils.xmpp_date()
|
||
if not item_id:
|
||
values["created"] = now
|
||
elif extra.get("update", False):
|
||
if item_id is None:
|
||
raise exceptions.DataError(
|
||
_('if extra["update"] is set, item_id must be set too')
|
||
)
|
||
await self.copy_missing_values(
|
||
client, service, node, item_id, form_ns, values
|
||
)
|
||
|
||
values["updated"] = now
|
||
if fill_author:
|
||
if not values.get("author"):
|
||
id_data = await self._i.get_identity(client, None, ["nicknames"])
|
||
values["author"] = id_data["nicknames"][0]
|
||
if not values.get("author_jid"):
|
||
values["author_jid"] = client.jid.full()
|
||
item_id = await self.send_data_form_item(
|
||
client, service, node, values, schema, item_id, extra, deserialise
|
||
)
|
||
return item_id
|
||
|
||
|
||
@implementer(itx_xmpp.IDisco)
|
||
class SchemaHandler(XMPPHandler):
|
||
|
||
def getDiscoInfo(self, requestor, service, nodeIdentifier=""):
|
||
return [disco.DiscoFeature(NS_FDP)]
|
||
|
||
def getDiscoItems(self, requestor, service, nodeIdentifier=""):
|
||
return []
|