erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

code style reformatting using black

Browse source
This commit is contained in:
Goffi 2018-06-27 20:14:46 +02:00
commit 744cb0c503
1 changed files with 21394 additions and 10488 deletions
Download patch file Download diff file Expand all files Collapse all files

421
sat/plugins/plugin_exp_pubsub_schema.py
View file

@ -27,6 +27,7 @@ from twisted.words.protocols.jabber import jid
from twisted.words.protocols.jabber.xmlstream import XMPPHandler
from twisted.internet import defer
from sat.core.log import getLogger
log = getLogger(__name__)
from wokkel import disco, iwokkel
from wokkel import data_form
@ -36,7 +37,7 @@ from collections import Iterable
import copy
import itertools
NS_SCHEMA = 'https://salut-a-toi/protocol/schema:0'
NS_SCHEMA = "https://salut-a-toi/protocol/schema:0"
PLUGIN_INFO = {
C.PI_NAME: "PubSub Schema",
@ -46,47 +47,63 @@ PLUGIN_INFO = {
C.PI_DEPENDENCIES: ["XEP-0060", "IDENTITY"],
C.PI_MAIN: "PubsubSchema",
C.PI_HANDLER: "yes",
C.PI_DESCRIPTION: _("""Handle Pubsub data schemas""")
C.PI_DESCRIPTION: _("""Handle Pubsub data schemas"""),
}
class PubsubSchema(object):
def __init__(self, host):
log.info(_(u"PubSub Schema initialization"))
self.host = host
self._p = self.host.plugins["XEP-0060"]
self._i = self.host.plugins["IDENTITY"]
host.bridge.addMethod("psSchemaGet", ".plugin",
in_sign='sss', out_sign='s',
method=self._getSchema,
async=True
)
host.bridge.addMethod("psSchemaSet", ".plugin",
in_sign='ssss', out_sign='',
method=self._setSchema,
async=True
)
host.bridge.addMethod("psSchemaUIGet", ".plugin",
in_sign='sss', out_sign='s',
method=utils.partial(self._getUISchema, default_node=None),
async=True
)
host.bridge.addMethod("psItemsFormGet", ".plugin",
in_sign='ssssiassa{ss}s', out_sign='(asa{ss})',
method=self._getDataFormItems,
async=True)
host.bridge.addMethod("psItemFormSend", ".plugin",
in_sign='ssa{sas}ssa{ss}s', out_sign='s',
method=self._sendDataFormItem,
async=True)
host.bridge.addMethod(
"psSchemaGet",
".plugin",
in_sign="sss",
out_sign="s",
method=self._getSchema,
async=True,
)
host.bridge.addMethod(
"psSchemaSet",
".plugin",
in_sign="ssss",
out_sign="",
method=self._setSchema,
async=True,
)
host.bridge.addMethod(
"psSchemaUIGet",
".plugin",
in_sign="sss",
out_sign="s",
method=utils.partial(self._getUISchema, default_node=None),
async=True,
)
host.bridge.addMethod(
"psItemsFormGet",
".plugin",
in_sign="ssssiassa{ss}s",
out_sign="(asa{ss})",
method=self._getDataFormItems,
async=True,
)
host.bridge.addMethod(
"psItemFormSend",
".plugin",
in_sign="ssa{sas}ssa{ss}s",
out_sign="s",
method=self._sendDataFormItem,
async=True,
)
def getHandler(self, client):
return SchemaHandler()
def _getSchemaBridgeCb(self, schema_elt):
if schema_elt is None:
return u''
return u""
return schema_elt.toXml()
def _getSchema(self, service, nodeIdentifier, profile_key=C.PROF_KEY_NONE):
@ -98,11 +115,11 @@ class PubsubSchema(object):
def _getSchemaCb(self, iq_elt):
try:
schema_elt = next(iq_elt.elements(NS_SCHEMA, 'schema'))
schema_elt = next(iq_elt.elements(NS_SCHEMA, "schema"))
except StopIteration:
raise exceptions.DataError('missing <schema> element')
raise exceptions.DataError("missing <schema> element")
try:
x_elt = next(schema_elt.elements((data_form.NS_X_DATA, 'x')))
x_elt = next(schema_elt.elements((data_form.NS_X_DATA, "x")))
except StopIteration:
# there is not schema on this node
return None
@ -117,18 +134,26 @@ class PubsubSchema(object):
@return (domish.Element, None): schema (<x> element)
None if not schema has been set on this node
"""
iq_elt = client.IQ(u'get')
iq_elt = client.IQ(u"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
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
@defer.inlineCallbacks
def getSchemaForm(self, client, service, nodeIdentifier, schema=None, form_type='form', copy_form=True):
def getSchemaForm(
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
@ -147,7 +172,11 @@ class PubsubSchema(object):
log.debug(_(u"unspecified schema, we need to request it"))
schema = yield self.getSchema(client, service, nodeIdentifier)
if schema is None:
raise exceptions.DataError(_(u"no schema specified, and this node has no schema either, we can't construct the data form"))
raise exceptions.DataError(
_(
u"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:
schema = copy.deepcopy(schema)
@ -156,17 +185,18 @@ class PubsubSchema(object):
try:
form = data_form.Form.fromElement(schema)
except data_form.Error as e:
raise exceptions.DataError(_(u"Invalid Schema: {msg}").format(
msg = e))
raise exceptions.DataError(_(u"Invalid Schema: {msg}").format(msg=e))
form.formType = form_type
defer.returnValue(form)
def schema2XMLUI(self, schema_elt):
form = data_form.Form.fromElement(schema_elt)
xmlui = xml_tools.dataForm2XMLUI(form, '')
xmlui = xml_tools.dataForm2XMLUI(form, "")
return xmlui
def _getUISchema(self, service, nodeIdentifier, default_node=None, profile_key=C.PROF_KEY_NONE):
def _getUISchema(
self, service, nodeIdentifier, default_node=None, profile_key=C.PROF_KEY_NONE
):
if not nodeIdentifier:
if not default_node:
raise ValueError(_(u"nodeIndentifier needs to be set"))
@ -185,7 +215,7 @@ class PubsubSchema(object):
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'))
schema = generic.parseXml(schema.encode("utf-8"))
return self.setSchema(client, service, nodeIdentifier, schema)
def setSchema(self, client, service, nodeIdentifier, schema):
@ -196,31 +226,67 @@ class PubsubSchema(object):
"""
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
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()
def _getDataFormItems(self, form_ns='', service='', node='', schema='', max_items=10, item_ids=None, sub_id=None, extra_dict=None, profile_key=C.PROF_KEY_NONE):
def _getDataFormItems(
self,
form_ns="",
service="",
node="",
schema="",
max_items=10,
item_ids=None,
sub_id=None,
extra_dict=None,
profile_key=C.PROF_KEY_NONE,
):
client = self.host.getClient(profile_key)
service = jid.JID(service) if service else None
if not node:
raise exceptions.DataError(_(u'empty node is not allowed'))
raise exceptions.DataError(_(u"empty node is not allowed"))
if schema:
schema = generic.parseXml(schema.encode('utf-8'))
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.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 = 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.serItemsData)
return d
@defer.inlineCallbacks
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):
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
@param schema(domish.Element, data_form.Form, None): schema of the node if known
@ -237,15 +303,28 @@ class PubsubSchema(object):
"""
if not nodeIdentifier:
if not default_node:
raise ValueError(_(u"default_node must be set if nodeIdentifier is not set"))
raise ValueError(
_(u"default_node must be set if nodeIdentifier is not set")
)
nodeIdentifier = default_node
# we need the initial form to get options of fields when suitable
schema_form = yield self.getSchemaForm(client, service, nodeIdentifier, schema, form_type='result', copy_form=False)
items_data = yield self._p.getItems(client, service, nodeIdentifier, max_items, item_ids, sub_id, rsm_request, extra)
schema_form = yield self.getSchemaForm(
client, service, nodeIdentifier, schema, form_type="result", copy_form=False
)
items_data = yield self._p.getItems(
client,
service,
nodeIdentifier,
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, u'x')):
for x_elt in item_elt.elements((data_form.NS_X_DATA, u"x")):
form = data_form.Form.fromElement(x_elt)
if form_ns and form.formNamespace != form_ns:
continue
@ -254,28 +333,59 @@ class PubsubSchema(object):
schema_form,
# FIXME: conflicts with schema (i.e. if "id" or "publisher" already exists)
# are not checked
prepend = (('label', 'id'),('text', item_elt['id'], u'id'),
('label', 'publisher'),('text', item_elt.getAttribute('publisher',''), u'publisher')),
filters = filters,
)
prepend=(
("label", "id"),
("text", item_elt["id"], u"id"),
("label", "publisher"),
("text", item_elt.getAttribute("publisher", ""), u"publisher"),
),
filters=filters,
)
items_xmlui.append(xmlui)
break
defer.returnValue((items_xmlui, metadata))
def _sendDataFormItem(self, service, nodeIdentifier, values, schema=None, item_id=None, extra=None, profile_key=C.PROF_KEY_NONE):
def _sendDataFormItem(
self,
service,
nodeIdentifier,
values,
schema=None,
item_id=None,
extra=None,
profile_key=C.PROF_KEY_NONE,
):
client = self.host.getClient(profile_key)
service = None if not service else jid.JID(service)
if schema:
schema = generic.parseXml(schema.encode('utf-8'))
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.addCallback(lambda ret: ret or u'')
d = self.sendDataFormItem(
client,
service,
nodeIdentifier,
values,
schema,
item_id or None,
extra,
deserialise=True,
)
d.addCallback(lambda ret: ret or u"")
return d
@defer.inlineCallbacks
def sendDataFormItem(self, client, service, nodeIdentifier, values, schema=None, item_id=None, extra=None, deserialise=False):
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 form
@ -289,26 +399,34 @@ class PubsubSchema(object):
other parameters as the same as for [self._p.sendItem]
@return (unicode): id of the created item
"""
form = yield self.getSchemaForm(client, service, nodeIdentifier, schema, form_type='submit')
form = yield self.getSchemaForm(
client, service, nodeIdentifier, schema, form_type="submit"
)
for name, values_list in values.iteritems():
try:
field = form.fields[name]
except KeyError:
log.warning(_(u"field {name} doesn't exist, ignoring it").format(name=name))
log.warning(
_(u"field {name} doesn't exist, ignoring it").format(name=name)
)
continue
if isinstance(values_list, basestring) or not isinstance(values_list, Iterable):
if isinstance(values_list, basestring) or not isinstance(
values_list, Iterable
):
values_list = [values_list]
if deserialise:
if field.fieldType == 'boolean':
if field.fieldType == "boolean":
values_list = [C.bool(v) for v in values_list]
elif field.fieldType == 'text-multi':
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]))
values_list = list(
itertools.chain(*[v.splitlines() for v in values_list])
)
elif 'jid' in field.fieldType:
elif "jid" in field.fieldType:
values_list = [jid.JID(v) for v in values_list]
if 'list' in field.fieldType:
if "list" in field.fieldType:
# 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]
@ -317,7 +435,9 @@ class PubsubSchema(object):
values_list = field.values
field.values = values_list
yield self._p.sendItem(client, service, nodeIdentifier, form.toElement(), item_id, extra)
yield self._p.sendItem(
client, service, nodeIdentifier, form.toElement(), item_id, extra
)
## filters ##
# filters useful for data form to XMLUI conversion #
@ -327,7 +447,7 @@ class PubsubSchema(object):
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)
publisher = jid.JID(form_xmlui.named_widgets["publisher"].value)
except (KeyError, RuntimeError):
pass
else:
@ -339,18 +459,20 @@ class PubsubSchema(object):
main use case is using a textbox for labels
"""
if widget_type != u'textbox':
if widget_type != u"textbox":
return widget_type, args, kwargs
widget_type = u'list'
options = [o for o in args.pop(0).split(u'\n') if o]
kwargs = {'options': options,
'name': kwargs.get('name'),
'styles': (u'noselect', u'extensible', u'reducible')}
widget_type = u"list"
options = [o for o in args.pop(0).split(u"\n") if o]
kwargs = {
"options": options,
"name": kwargs.get("name"),
"styles": (u"noselect", u"extensible", u"reducible"),
}
return widget_type, args, kwargs
def dateFilter(self, form_xmlui, widget_type, args, kwargs):
"""Convert a string with a date to a unix timestamp"""
if widget_type != u'string' or not args[0]:
if widget_type != u"string" or not args[0]:
return widget_type, args, kwargs
# we convert XMPP date to timestamp
try:
@ -377,7 +499,19 @@ class PubsubSchema(object):
return client, service, node, max_items, extra, sub_id
def _get(self, service='', node='', max_items=10, item_ids=None, sub_id=None, extra=None, default_node=None, form_ns=None, filters=None, profile_key=C.PROF_KEY_NONE):
def _get(
self,
service="",
node="",
max_items=10,
item_ids=None,
sub_id=None,
extra=None,
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
@ -392,11 +526,16 @@ class PubsubSchema(object):
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)):
if C.bool(extra.get("labels_as_list", C.BOOL_FALSE)):
filters = filters.copy()
filters[u'labels'] = self.textbox2ListFilter
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,
filters[u"labels"] = self.textbox2ListFilter
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,
@ -404,7 +543,8 @@ class PubsubSchema(object):
extra=extra.extra,
default_node=default_node,
form_ns=form_ns,
filters=filters)
filters=filters,
)
d.addCallback(self._p.serItemsData)
return d
@ -416,30 +556,65 @@ class PubsubSchema(object):
client = self.host.getClient(profile_key)
service = None if not service else jid.JID(service)
if schema:
schema = generic.parseXml(schema.encode('utf-8'))
schema = generic.parseXml(schema.encode("utf-8"))
else:
schema = None
if extra and u'update' in extra:
extra[u'update'] = C.bool(extra[u'update'])
if extra and u"update" in extra:
extra[u"update"] = C.bool(extra[u"update"])
return client, service, node or None, schema, item_id or None, extra
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):
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.prepareBridgeSet(service, node, schema, item_id, extra)
d = 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 u'')
client, service, node, schema, item_id, extra = self.prepareBridgeSet(
service, node, schema, item_id, extra
)
d = 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 u"")
return d
@defer.inlineCallbacks
def set(self, client, service, node, values, schema, item_id, extra, deserialise, form_ns, default_node=None, fill_author=True):
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
@ -463,44 +638,56 @@ class PubsubSchema(object):
node = default_node
now = utils.xmpp_date()
if not item_id:
values['created'] = now
elif extra.get(u'update', False):
values["created"] = now
elif extra.get(u"update", False):
if item_id is None:
raise exceptions.DataError(_(u'if extra["update"] is set, item_id must be set too'))
raise exceptions.DataError(
_(u'if extra["update"] is set, item_id must be set too')
)
try:
# we get previous item
items_data = yield self._p.getItems(client, service, node, item_ids=[item_id])
items_data = yield self._p.getItems(
client, service, node, item_ids=[item_id]
)
item_elt = items_data[0][0]
except Exception as e:
log.warning(_(u"Can't get previous item, update ignored: {reason}").format(
reason = e))
log.warning(
_(u"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(_(u"Can't parse previous item, update ignored: data form not found").format(
reason = e))
log.warning(
_(
u"Can't parse previous item, update ignored: data form not found"
).format(reason=e)
)
else:
for name, field in form.fields.iteritems():
if name not in values:
values[name] = u'\n'.join(unicode(v) for v in field.values)
values[name] = u"\n".join(unicode(v) for v in field.values)
values['updated'] = now
values["updated"] = now
if fill_author:
if not values.get('author'):
if not values.get("author"):
identity = yield self._i.getIdentity(client, client.jid)
values['author'] = identity['nick']
if not values.get('author_jid'):
values['author_jid'] = client.jid.full()
item_id = yield self.sendDataFormItem(client, service, node, values, schema, item_id, extra, deserialise)
values["author"] = identity["nick"]
if not values.get("author_jid"):
values["author_jid"] = client.jid.full()
item_id = yield self.sendDataFormItem(
client, service, node, values, schema, item_id, extra, deserialise
)
defer.returnValue(item_id)
class SchemaHandler(XMPPHandler):
implements(iwokkel.IDisco)
def getDiscoInfo(self, requestor, service, nodeIdentifier=''):
def getDiscoInfo(self, requestor, service, nodeIdentifier=""):
return [disco.DiscoFeature(NS_SCHEMA)]
def getDiscoItems(self, requestor, service, nodeIdentifier=''):
def getDiscoItems(self, requestor, service, nodeIdentifier=""):
return []