507 lines
17 KiB
Python
507 lines
17 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# Copyright (C) 2009-2020 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/>.
|
|
|
|
import shortuuid
|
|
from typing import List, Tuple, Optional
|
|
from twisted.internet import defer
|
|
from twisted.words.xish import domish
|
|
from twisted.words.protocols.jabber import jid
|
|
from wokkel import data_form
|
|
from sat.core.i18n import _, D_
|
|
from sat.core.xmpp import SatXMPPEntity
|
|
from sat.core.constants import Const as C
|
|
from sat.tools.common import uri
|
|
from sat.tools.common import data_format
|
|
from sat.core.log import getLogger
|
|
|
|
log = getLogger(__name__)
|
|
|
|
# XXX: this plugin was formely named "tickets", thus the namespace keeps this
|
|
# name
|
|
APP_NS_TICKETS = "org.salut-a-toi.tickets:0"
|
|
NS_TICKETS_TYPE = "org.salut-a-toi.tickets#type:0"
|
|
|
|
PLUGIN_INFO = {
|
|
C.PI_NAME: _("Pubsub Lists"),
|
|
C.PI_IMPORT_NAME: "LISTS",
|
|
C.PI_TYPE: "EXP",
|
|
C.PI_PROTOCOLS: [],
|
|
C.PI_DEPENDENCIES: ["XEP-0060", "XEP-0346", "XEP-0277", "IDENTITY",
|
|
"PUBSUB_INVITATION"],
|
|
C.PI_MAIN: "PubsubLists",
|
|
C.PI_HANDLER: "no",
|
|
C.PI_DESCRIPTION: _("""Pubsub lists management plugin"""),
|
|
}
|
|
|
|
TEMPLATES = {
|
|
"todo": {
|
|
"name": D_("TODO List"),
|
|
"icon": "check",
|
|
"fields": [
|
|
{"name": "title"},
|
|
{"name": "author"},
|
|
{"name": "created"},
|
|
{"name": "updated"},
|
|
{"name": "time_limit"},
|
|
{"name": "labels", "type": "text-multi"},
|
|
{
|
|
"name": "status",
|
|
"label": D_("status"),
|
|
"type": "list-single",
|
|
"options": [
|
|
{
|
|
"label": D_("to do"),
|
|
"value": "todo"
|
|
},
|
|
{
|
|
"label": D_("in progress"),
|
|
"value": "in_progress"
|
|
},
|
|
{
|
|
"label": D_("done"),
|
|
"value": "done"
|
|
},
|
|
],
|
|
"value": "todo"
|
|
},
|
|
{
|
|
"name": "priority",
|
|
"label": D_("priority"),
|
|
"type": "list-single",
|
|
"options": [
|
|
{
|
|
"label": D_("major"),
|
|
"value": "major"
|
|
},
|
|
{
|
|
"label": D_("normal"),
|
|
"value": "normal"
|
|
},
|
|
{
|
|
"label": D_("minor"),
|
|
"value": "minor"
|
|
},
|
|
],
|
|
"value": "normal"
|
|
},
|
|
{"name": "body", "type": "xhtml"},
|
|
{"name": "comments_uri"},
|
|
]
|
|
},
|
|
"shopping": {
|
|
"name": D_("Shopping List"),
|
|
"icon": "basket",
|
|
"fields": [
|
|
{"name": "name", "label": D_("name")},
|
|
{"name": "quantity", "label": D_("quantity")},
|
|
{
|
|
"name": "status",
|
|
"label": D_("status"),
|
|
"type": "list-single",
|
|
"options": [
|
|
{
|
|
"label": D_("to buy"),
|
|
"value": "to_buy"
|
|
},
|
|
{
|
|
"label": D_("bought"),
|
|
"value": "bought"
|
|
},
|
|
],
|
|
"value": "to_buy"
|
|
},
|
|
]
|
|
},
|
|
"tickets": {
|
|
"name": D_("Tickets"),
|
|
"icon": "clipboard",
|
|
"fields": [
|
|
{"name": "title"},
|
|
{"name": "author"},
|
|
{"name": "created"},
|
|
{"name": "updated"},
|
|
{"name": "labels", "type": "text-multi"},
|
|
{
|
|
"name": "type",
|
|
"label": D_("type"),
|
|
"type": "list-single",
|
|
"options": [
|
|
{
|
|
"label": D_("bug"),
|
|
"value": "bug"
|
|
},
|
|
{
|
|
"label": D_("feature request"),
|
|
"value": "feature"
|
|
},
|
|
],
|
|
"value": "bug"
|
|
},
|
|
{
|
|
"name": "status",
|
|
"label": D_("status"),
|
|
"type": "list-single",
|
|
"options": [
|
|
{
|
|
"label": D_("queued"),
|
|
"value": "queued"
|
|
},
|
|
{
|
|
"label": D_("started"),
|
|
"value": "started"
|
|
},
|
|
{
|
|
"label": D_("review"),
|
|
"value": "review"
|
|
},
|
|
{
|
|
"label": D_("closed"),
|
|
"value": "closed"
|
|
},
|
|
],
|
|
"value": "queued"
|
|
},
|
|
{
|
|
"name": "priority",
|
|
"label": D_("priority"),
|
|
"type": "list-single",
|
|
"options": [
|
|
{
|
|
"label": D_("major"),
|
|
"value": "major"
|
|
},
|
|
{
|
|
"label": D_("normal"),
|
|
"value": "normal"
|
|
},
|
|
{
|
|
"label": D_("minor"),
|
|
"value": "minor"
|
|
},
|
|
],
|
|
"value": "normal"
|
|
},
|
|
{"name": "body", "type": "xhtml"},
|
|
{"name": "comments_uri"},
|
|
]
|
|
}
|
|
}
|
|
|
|
|
|
class PubsubLists:
|
|
|
|
def __init__(self, host):
|
|
log.info(_("Pubsub lists plugin initialization"))
|
|
self.host = host
|
|
self._s = self.host.plugins["XEP-0346"]
|
|
self.namespace = self._s.getSubmittedNS(APP_NS_TICKETS)
|
|
host.registerNamespace("tickets", APP_NS_TICKETS)
|
|
host.registerNamespace("tickets_type", NS_TICKETS_TYPE)
|
|
self.host.plugins["PUBSUB_INVITATION"].register(
|
|
APP_NS_TICKETS, self
|
|
)
|
|
self._p = self.host.plugins["XEP-0060"]
|
|
self._m = self.host.plugins["XEP-0277"]
|
|
host.bridge.addMethod(
|
|
"listGet",
|
|
".plugin",
|
|
in_sign="ssiassa{ss}s",
|
|
out_sign="s",
|
|
method=lambda service, node, max_items, items_ids, sub_id, extra, profile_key:
|
|
self._s._get(
|
|
service,
|
|
node,
|
|
max_items,
|
|
items_ids,
|
|
sub_id,
|
|
extra,
|
|
default_node=self.namespace,
|
|
form_ns=APP_NS_TICKETS,
|
|
filters={
|
|
"author": self._s.valueOrPublisherFilter,
|
|
"created": self._s.dateFilter,
|
|
"updated": self._s.dateFilter,
|
|
"time_limit": self._s.dateFilter,
|
|
},
|
|
profile_key=profile_key),
|
|
async_=True,
|
|
)
|
|
host.bridge.addMethod(
|
|
"listSet",
|
|
".plugin",
|
|
in_sign="ssa{sas}ssss",
|
|
out_sign="s",
|
|
method=self._set,
|
|
async_=True,
|
|
)
|
|
host.bridge.addMethod(
|
|
"listSchemaGet",
|
|
".plugin",
|
|
in_sign="sss",
|
|
out_sign="s",
|
|
method=lambda service, nodeIdentifier, profile_key: self._s._getUISchema(
|
|
service, nodeIdentifier, default_node=self.namespace,
|
|
profile_key=profile_key),
|
|
async_=True,
|
|
)
|
|
host.bridge.addMethod(
|
|
"listsList",
|
|
".plugin",
|
|
in_sign="sss",
|
|
out_sign="s",
|
|
method=self._listsList,
|
|
async_=True,
|
|
)
|
|
host.bridge.addMethod(
|
|
"listTemplatesNamesGet",
|
|
".plugin",
|
|
in_sign="ss",
|
|
out_sign="s",
|
|
method=self._getTemplatesNames,
|
|
)
|
|
host.bridge.addMethod(
|
|
"listTemplateGet",
|
|
".plugin",
|
|
in_sign="sss",
|
|
out_sign="s",
|
|
method=self._getTemplate,
|
|
)
|
|
host.bridge.addMethod(
|
|
"listTemplateCreate",
|
|
".plugin",
|
|
in_sign="ssss",
|
|
out_sign="(ss)",
|
|
method=self._createTemplate,
|
|
async_=True,
|
|
)
|
|
|
|
async def onInvitationPreflight(
|
|
self,
|
|
client: SatXMPPEntity,
|
|
namespace: str,
|
|
name: str,
|
|
extra: dict,
|
|
service: jid.JID,
|
|
node: str,
|
|
item_id: Optional[str],
|
|
item_elt: domish.Element
|
|
) -> None:
|
|
try:
|
|
schema = await self._s.getSchemaForm(client, service, node)
|
|
except Exception as e:
|
|
log.warning(f"Can't retrive node schema as {node!r} [{service}]: {e}")
|
|
else:
|
|
try:
|
|
field_type = schema[NS_TICKETS_TYPE]
|
|
except KeyError:
|
|
log.debug("no type found in list schema")
|
|
else:
|
|
list_elt = extra["element"] = domish.Element((APP_NS_TICKETS, "list"))
|
|
list_elt["type"] = field_type
|
|
|
|
def _set(self, service, node, values, schema=None, item_id=None, extra='',
|
|
profile_key=C.PROF_KEY_NONE):
|
|
client, service, node, schema, item_id, extra = self._s.prepareBridgeSet(
|
|
service, node, schema, item_id, extra, profile_key
|
|
)
|
|
d = defer.ensureDeferred(self.set(
|
|
client, service, node, values, schema, item_id, extra, deserialise=True
|
|
))
|
|
d.addCallback(lambda ret: ret or "")
|
|
return d
|
|
|
|
async def set(
|
|
self, client, service, node, values, schema=None, item_id=None, extra=None,
|
|
deserialise=False, form_ns=APP_NS_TICKETS
|
|
):
|
|
"""Publish a tickets
|
|
|
|
@param node(unicode, None): Pubsub node to use
|
|
None to use default tickets node
|
|
@param values(dict[key(unicode), [iterable[object]|object]]): values of the ticket
|
|
|
|
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.sendItem] with additional keys:
|
|
- update(bool): if True, get previous item data to merge with current one
|
|
if True, item_id must be None
|
|
other arguments are same as for [self._s.sendDataFormItem]
|
|
@return (unicode): id of the created item
|
|
"""
|
|
if not node:
|
|
node = self.namespace
|
|
|
|
if not item_id:
|
|
comments_service = await self._m.getCommentsService(client, service)
|
|
|
|
# we need to use uuid for comments node, because we don't know item id in
|
|
# advance (we don't want to set it ourselves to let the server choose, so we
|
|
# can have a nicer id if serial ids is activated)
|
|
comments_node = self._m.getCommentsNode(
|
|
node + "_" + str(shortuuid.uuid())
|
|
)
|
|
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.ACCESS_OPEN,
|
|
}
|
|
await self._p.createNode(client, comments_service, comments_node, options)
|
|
values["comments_uri"] = uri.buildXMPPUri(
|
|
"pubsub",
|
|
subtype="microblog",
|
|
path=comments_service.full(),
|
|
node=comments_node,
|
|
)
|
|
|
|
return await self._s.set(
|
|
client, service, node, values, schema, item_id, extra, deserialise, form_ns
|
|
)
|
|
|
|
def _listsList(self, service, node, profile):
|
|
service = jid.JID(service) if service else None
|
|
node = node or None
|
|
client = self.host.getClient(profile)
|
|
d = defer.ensureDeferred(self.listsList(client, service, node))
|
|
d.addCallback(data_format.serialise)
|
|
return d
|
|
|
|
async def listsList(
|
|
self, client, service: Optional[jid.JID], node: Optional[str]=None
|
|
) -> List[dict]:
|
|
"""Retrieve list of pubsub lists registered in personal interests
|
|
|
|
@return list: list of lists metadata
|
|
"""
|
|
items, metadata = await self.host.plugins['LIST_INTEREST'].listInterests(
|
|
client, service, node, namespace=APP_NS_TICKETS)
|
|
lists = []
|
|
for item in items:
|
|
interest_elt = item.interest
|
|
if interest_elt is None:
|
|
log.warning(f"invalid interest for {client.profile}: {item.toXml}")
|
|
continue
|
|
if interest_elt.getAttribute("namespace") != APP_NS_TICKETS:
|
|
continue
|
|
pubsub_elt = interest_elt.pubsub
|
|
list_data = {
|
|
"id": item["id"],
|
|
"name": interest_elt["name"],
|
|
"service": pubsub_elt["service"],
|
|
"node": pubsub_elt["node"],
|
|
"creator": C.bool(pubsub_elt.getAttribute("creator", C.BOOL_FALSE)),
|
|
}
|
|
try:
|
|
list_elt = next(pubsub_elt.elements(APP_NS_TICKETS, "list"))
|
|
except StopIteration:
|
|
pass
|
|
else:
|
|
list_type = list_data["type"] = list_elt["type"]
|
|
if list_type in TEMPLATES:
|
|
list_data["icon_name"] = TEMPLATES[list_type]["icon"]
|
|
lists.append(list_data)
|
|
|
|
return lists
|
|
|
|
def _getTemplatesNames(self, language, profile):
|
|
client = self.host.getClient(profile)
|
|
return data_format.serialise(self.getTemplatesNames(client, language))
|
|
|
|
def getTemplatesNames(self, client, language: str) -> list:
|
|
"""Retrieve well known list templates"""
|
|
|
|
templates = [{"id": tpl_id, "name": d["name"], "icon": d["icon"]}
|
|
for tpl_id, d in TEMPLATES.items()]
|
|
return templates
|
|
|
|
def _getTemplate(self, name, language, profile):
|
|
client = self.host.getClient(profile)
|
|
return data_format.serialise(self.getTemplate(client, name, language))
|
|
|
|
def getTemplate(self, client, name: str, language: str) -> dict:
|
|
"""Retrieve a well known template"""
|
|
return TEMPLATES[name]
|
|
|
|
def _createTemplate(self, template_id, name, access_model, profile):
|
|
client = self.host.getClient(profile)
|
|
d = defer.ensureDeferred(self.createTemplate(
|
|
client, template_id, name, access_model
|
|
))
|
|
d.addCallback(lambda node_data: (node_data[0].full(), node_data[1]))
|
|
return d
|
|
|
|
async def createTemplate(
|
|
self, client, template_id: str, name: str, access_model: str
|
|
) -> Tuple[jid.JID, str]:
|
|
"""Create a list from a template"""
|
|
name = name.strip()
|
|
if not name:
|
|
name = shortuuid.uuid()
|
|
template = TEMPLATES[template_id]
|
|
|
|
fields = [
|
|
data_form.Field(fieldType="hidden", var=NS_TICKETS_TYPE, value=template_id)
|
|
]
|
|
for field_data in template['fields']:
|
|
field_type = field_data.get('type', 'text-single')
|
|
kwargs = {
|
|
"fieldType": field_type,
|
|
"var": field_data["name"],
|
|
"label": field_data.get('label'),
|
|
"value": field_data.get("value"),
|
|
}
|
|
if field_type == "xhtml":
|
|
kwargs.update({
|
|
"fieldType": None,
|
|
"ext_type": "xml",
|
|
})
|
|
if kwargs["value"] is None:
|
|
kwargs["value"] = domish.Element((C.NS_XHTML, "div"))
|
|
elif "options" in field_data:
|
|
kwargs["options"] = [
|
|
data_form.Option(o["value"], o.get("label"))
|
|
for o in field_data["options"]
|
|
]
|
|
field = data_form.Field(**kwargs)
|
|
fields.append(field)
|
|
|
|
schema = data_form.Form(
|
|
"form",
|
|
formNamespace=APP_NS_TICKETS,
|
|
fields=fields
|
|
).toElement()
|
|
|
|
service = client.jid.userhostJID()
|
|
node = self._s.getSubmittedNS(f"{APP_NS_TICKETS}_{name}")
|
|
options = {
|
|
self._p.OPT_ACCESS_MODEL: access_model
|
|
}
|
|
await self._p.createNode(client, service, node, options)
|
|
await self._s.setSchema(client, service, node, schema)
|
|
list_elt = domish.Element((APP_NS_TICKETS, "list"))
|
|
list_elt["type"] = template_id
|
|
try:
|
|
await self.host.plugins['LIST_INTEREST'].registerPubsub(
|
|
client, APP_NS_TICKETS, service, node, creator=True,
|
|
name=name, element=list_elt)
|
|
except Exception as e:
|
|
log.warning(f"Can't add list to interests: {e}")
|
|
return service, node
|