From 8cd50a7726c55a85698adfeed46a437498bcbcb4 Mon Sep 17 00:00:00 2001
From: Neui <neuisen@googlemail.com>
Date: Sat, 10 Oct 2020 01:12:10 +0200
Subject: [PATCH] Add & implement org.gnome.GTG.Tasks DBus interface

Introducing org.gnome.GTG.Tasks, an DBus interface to manage tasks. This
is very much inspired by the old "DBus Wrapper", that implemented
org.gnome.GTGTasks (I think), but this is in some ways different:

* Do actions in batches
* Only handle tasks, no UI stuff (actions can replace some)
---
 GTG/core/dbus/tasks.py            | 356 ++++++++++++++++++++++++++++++
 GTG/core/meson.build              |   1 +
 GTG/gtk/application.py            |   8 +
 data/dbus/meson.build             |   8 +
 data/dbus/org.gnome.GTG.Tasks.xml | 258 ++++++++++++++++++++++
 data/meson.build                  |   1 +
 meson.build                       |   1 +
 7 files changed, 633 insertions(+)
 create mode 100644 GTG/core/dbus/tasks.py
 create mode 100644 data/dbus/meson.build
 create mode 100644 data/dbus/org.gnome.GTG.Tasks.xml

diff --git a/GTG/core/dbus/tasks.py b/GTG/core/dbus/tasks.py
new file mode 100644
index 0000000000..a1a8789618
--- /dev/null
+++ b/GTG/core/dbus/tasks.py
@@ -0,0 +1,356 @@
+
+# Implementation of the org.gnome.GTG.Tasks interface
+
+import datetime
+import logging
+import enum
+from gi.repository import GLib
+from GTG.core.search import parse_search_query, InvalidQuery
+from GTG.core.dates import Date
+from GTG.core.task import Task
+from .dbus import DBusInterfaceImplService, DBusReturnError
+
+
+__all__ = ('DBusImplTasks', 'InvalidTaskDict', 'TaskDict', 'TaskStatus')
+log = logging.getLogger(__name__)
+
+
+class TaskStatus(enum.IntEnum):
+    """Task status for the DBus-Interface."""
+
+    unknown = 0
+    """Unknown status, normally you shouldn't use and see this."""
+    active = 1
+    """Task is still active (and is open)."""
+    dismissed = 2
+    """Task has been dismissed (and is closed)."""
+    done = 3
+    """Task has been completed (and is closed)."""
+
+    @classmethod
+    def status_to_enum(cls, status: str):
+        _status_to_enum_map = {
+            Task.STA_ACTIVE: cls.active,
+            Task.STA_DISMISSED: cls.dismissed,
+            Task.STA_DONE: cls.done,
+        }
+        return _status_to_enum_map.get(status, cls.unknown)
+
+    @classmethod
+    def enum_to_status(cls, e):
+        _enum_to_status_map = {
+            cls.active: Task.STA_ACTIVE,
+            cls.dismissed: Task.STA_DISMISSED,
+            cls.done: Task.STA_DONE,
+        }
+        return _enum_to_status_map.get(e, '')
+
+
+class TaskDict(dict):
+    """Helper class for managing a task dictionary."""
+
+    @classmethod
+    def from_task(cls, task: Task):
+        """
+        Converts the specified task to an task dictionary.
+        """
+        d = TaskDict()
+        d["id"] = task.get_id()
+        d["status"] = TaskStatus.status_to_enum(task.get_status())
+        d["title"] = task.get_title()
+        d["duedate"] = _date_to_string(task.get_due_date())
+        d["startdate"] = _date_to_string(task.get_start_date())
+        d["donedate"] = _date_to_string(task.get_closed_date())
+        d["tags"] = task.get_tags_name()
+        d["text"] = task.get_text()
+        d["children"] = task.get_children()
+        d["parents"] = task.get_parents()
+        return d
+
+    _to_variant_type = {
+        "id": 's',
+        "status": 'i',
+        "title": 's',
+        "duedate": 's',
+        "startdate": 's',
+        "donedate": 's',
+        "tags": 'as',
+        "text": 's',
+        "children": 'as',
+        "parent": 's',
+        "parents": 'as',
+    }
+
+    def to_variant(self) -> dict:
+        """
+        Convert an task dict to a variant dict to be submitted over DBus.
+        """
+        d = dict(self)
+        for name, vtype in self._to_variant_type.items():
+            if name in d:
+                d[name] = GLib.Variant(vtype, d[name])
+        return d
+        # return GLib.Variant("a{sv}", d) breaks GLib.Variant('aa{sv}', [dv])
+
+
+def _task_to_variant(task: Task) -> dict:
+    """
+    Convert an task object to a variant dict to be submitted over DBus.
+    """
+    return TaskDict.from_task(task).to_variant()
+
+
+def _variant_to_task_dict(task_variant) -> TaskDict:
+    """
+    Convert an variant dict to a task dict.
+    """
+    return TaskDict(task_variant.unpack())
+
+
+def _date_to_string(date: Date):
+    """
+    Convert a gtg date to either an english fuzzy string or to ISO format.
+    """
+    if date == Date.now():
+        return "now"
+    if date == Date.no_date():
+        return ""
+    if date == Date.soon():
+        return "soon"
+    if date == Date.someday():
+        return "someday"
+    return date.isoformat()  # Uses the wrapped python date object
+
+
+_string_to_date_map = {
+    "": Date.no_date(),
+    "now": Date.now(),
+    "soon": Date.soon(),
+    "someday": Date.someday(),
+}
+
+
+def _string_to_date(sdate: str) -> Date:
+    """
+    Convert string to the correct a gtg date without localization.
+    """
+    try:
+        return _string_to_date_map[sdate]
+    except KeyError:
+        try:
+            return Date(datetime.date.fromisoformat(sdate))
+        except ValueError:
+            raise DBusReturnError("gtg.InvalidDateFormat",
+                                  f"Invalid date format '{sdate}'")
+
+
+class InvalidTaskDict(DBusReturnError):
+    """
+    Return DBus Error about an invalid type for a task dictionary.
+    """
+    def __init__(self, what, got, expected):
+        got = got.__name__
+        expected = expected.__name__
+        super().__init__("gtg.InvalidTaskDict",
+                         f"{what} is a {got}, but expected {expected}")
+
+
+class DBusImplTasks(DBusInterfaceImplService):
+    INTERFACE_NAME = 'org.gnome.GTG.Tasks'
+
+    def __init__(self, req):
+        super().__init__()
+        self.req = req
+
+        tree = req.get_main_view()
+        # TODO: Register signals
+        # tree.register_cllbck('node-added', lambda tid, _:
+        #                           self.TaskAdded(tid))
+        # tree.register_cllbck('node-modified', lambda tid, _:
+        #                           self.TaskModified(tid))
+        # tree.register_cllbck('node-deleted', lambda tid, _:
+        #                           self.TaskDeleted(tid))
+
+    def _get_task(self, tid):
+        """
+        Return task from a tid, otherwise return an not-found DBus error.
+        """
+        task = self.req.get_task(tid)
+        if task is None:
+            raise DBusReturnError("gtg.TaskNotFound",
+                                  f"Task not found by id '{tid}'")
+        return task
+
+    def GetTasks(self, tids: list) -> list:
+        log.debug(f"Doing GetTasks({tids})")
+        return [_task_to_variant(self._get_task(tid)) for tid in tids]
+
+    def GetActiveTaskIds(self) -> list:
+        log.debug(f"Doing GetActiveTaskIds()")
+        return self.GetTaskIdsFiltered(['active', 'workable'])
+
+    def GetActiveTasks(self) -> list:
+        log.debug(f"Doing GetActiveTasks()")
+        return self.GetTasks(self.GetActiveTaskIds())
+
+    def GetTaskIdsFiltered(self, filters: list) -> list:
+        log.debug(f"Doing GetTasksFiltered({filters})")
+        tree = self.req.get_tasks_tree().get_basetree()
+        view = tree.get_viewtree(name=None)  # Anonymous viewtree
+        last_index = len(filters) - 1
+        for i, filter in enumerate(filters):
+            is_last = i == last_index
+            if filter[0] == '!':
+                view.apply_filter(filter[1:], parameters={'negate': 1},
+                                  refresh=is_last)
+            else:
+                view.apply_filter(filter, refresh=is_last)
+        return list(view.get_all_nodes())
+
+    def GetTasksFiltered(self, filters: list) -> list:
+        log.debug(f"Doing GetTasksFiltered({filters})")
+        return self.GetTasks(self.GetTaskIdsFiltered(filters))
+
+    def SearchTaskIds(self, query: str) -> list:
+        log.debug(f"Doing SearchTaskIds({query})")
+        tree = self.req.get_tasks_tree().get_basetree()
+        view = tree.get_viewtree()
+        try:
+            search = parse_search_query(query)
+            view.apply_filter('search', parameters=search)
+            tasks = view.get_all_nodes()
+            if tasks:
+                return tasks
+        except InvalidQuery as e:
+            raise DBusReturnError("gtg.InvalidQuery",
+                                  f"Invalid Query '{query}': {e}")
+        return []
+
+    def SearchTasks(self, query: str) -> list:
+        log.debug(f"Doing SearchTasks({query})")
+        return self.GetTasks(self.SearchTaskIds(query))
+
+    def HasTasks(self, tids: list) -> dict:
+        log.debug(f"Doing HasTasks({tids})")
+        return {tid: self.req.has_task(tid) for tid in tids}
+
+    def DeleteTasks(self, tids: list) -> dict:
+        log.debug(f"Doing DeleteTasks({tids})")
+        d = {}
+        for tid in tids:
+            d[tid] = self.req.has_task(tid)
+            if d[tid]:  # Task exists, so let's delete it
+                self.req.delete_task(tid)
+        return d
+
+    def NewTasks(self, tasks: list) -> list:
+        log.debug(f"Doing NewTasks({tasks})")
+        r = []
+        for new_task_dict in tasks:
+            self._verify_task_dict(new_task_dict)
+            new_task = self.req.new_task()
+            self._modify_task(new_task, new_task_dict)
+            r.append(_task_to_variant(new_task))
+        return r
+
+    def ModifyTasks(self, patches: list) -> list:
+        log.debug(f"Doing ModifyTasks({patches})")
+        r = []
+        for patch in patches:
+            if "id" not in patch:
+                raise DBusReturnError("gtg.MissingTaskId",
+                                      "No 'id' in task dict")
+            self._verify_task_dict(patch)
+            task = self._get_task(patch["id"])
+            patched_task = self._modify_task(task, patch)
+            r.append(_task_to_variant(patched_task))
+        return r
+
+    def _modify_task(self, task: Task, patch: dict) -> Task:
+        """Modify a single task and return it"""
+        if "title" in patch:
+            task.set_title(patch["title"])
+        if "text" in patch:
+            task.set_text(patch["text"])
+        if "duedate" in patch:
+            task.set_due_date(_string_to_date(patch["duedate"]))
+        if "startdate" in patch:
+            task.set_start_date(_string_to_date(patch["startdate"]))
+        if "status" in patch:
+            task.set_status(TaskStatus.enum_to_status(patch["status"]))
+        if "donedate" in patch:
+            old_status = task.get_status()
+            donedate = _string_to_date(patch["donedate"])
+            task.set_status(old_status, donedate=donedate)
+        if "tags" in patch:
+            old_tags = set(task.get_tags_name())
+            new_tags = set(patch["tags"])
+            common_tags = old_tags & new_tags
+            for removed_tag in old_tags - common_tags:
+                task.remove_tag(removed_tag)
+            for added_tag in new_tags - common_tags:
+                task.add_tag(added_tag)
+        if "children" in patch:
+            log.debug("TODO: Implement patching subtask list")  # TODO
+        if "parent" in patch:
+            log.debug("TODO: Implement patching parent")  # TODO
+        return task
+
+    def _verify_task_dict_types(self, td: dict):
+        """
+        Check if an task dict has the correct types.
+        """
+        # Reusing TaskDict._to_variant_type because it already contains the
+        # types it uses for serializing
+        for key, vartype in TaskDict._to_variant_type.items():
+            if key not in td:
+                continue
+
+            if vartype == 'i':
+                expected_type = int
+            elif vartype == 's':
+                expected_type = str
+            elif vartype[0] == 'a':
+                expected_type = list
+            else:
+                raise RuntimeError("Unknown vartype")
+
+            if type(td[key]) is not expected_type:
+                raise InvalidTaskDict(f"'{key}'", type(td[key]), expected_type)
+
+            if vartype[0] != 'a':
+                continue
+
+            if vartype[1] == 's':
+                expected_type = str
+            else:
+                log.debug("Unknown vartype, can't verify children: %r",
+                          vartype)
+                continue
+            for elem in td[key]:
+                if type(elem) is not expected_type:
+                    raise InvalidTaskDict(f"'{key}' element",
+                                          type(elem), expected_type)
+
+    def _verify_task_dict(self, td: dict):
+        """
+        Verify the types and whenever the values are valid for a task dict.
+        """
+        self._verify_task_dict_types(td)
+        if "startdate" in td:
+            date = _string_to_date(td["startdate"])
+            if date.is_fuzzy() and date != Date.no_date():
+                raise DBusReturnError("gtg.InvalidStartDate",
+                                      f"Invalid start date '{td['startdate']}'")
+
+        if "donedate" in td:  # TODO: What about status?
+            date = _string_to_date(td["donedate"])
+            if date.is_fuzzy() and date != Date.no_date():
+                raise DBusReturnError("gtg.InvalidDoneDate",
+                                      f"Invalid done date '{td['donedate']}'")
+
+        if "status" in td:
+            status = TaskStatus.enum_to_status(td["status"])
+            if status == '':
+                raise DBusReturnError("gtg.InvalidStatus",
+                                      f"Invalid status {td['status']}")
diff --git a/GTG/core/meson.build b/GTG/core/meson.build
index 935de05695..912159c023 100644
--- a/GTG/core/meson.build
+++ b/GTG/core/meson.build
@@ -55,6 +55,7 @@ gtg_core_plugin_sources = [
 gtg_core_dbus_sources = [
   'dbus/__init__.py',
   'dbus/dbus.py',
+  'dbus/tasks.py',
 ]
 
 python3.install_sources(gtg_core_sources, subdir: 'GTG' / 'core', pure: true)
diff --git a/GTG/gtk/application.py b/GTG/gtk/application.py
index 9f4c435ae7..048644afa9 100644
--- a/GTG/gtk/application.py
+++ b/GTG/gtk/application.py
@@ -40,6 +40,7 @@
 from GTG.gtk.backends import BackendsDialog
 from GTG.gtk.browser.tag_editor import TagEditor
 from GTG.core.timer import Timer
+from GTG.core.dbus.tasks import DBusImplTasks
 
 log = logging.getLogger(__name__)
 
@@ -117,6 +118,10 @@ def do_startup(self):
 
         self.init_style()
 
+        self.dbus_tasks = DBusImplTasks(self.req)
+        self.dbus_tasks.dbus_register(self.get_dbus_connection(),
+                                      self.get_dbus_object_path())
+
     def do_activate(self):
         """Callback when launched from the desktop."""
 
@@ -564,6 +569,9 @@ def do_shutdown(self):
             # Save data and shutdown datastore backends
             self.req.save_datastore(quit=True)
 
+        if self.dbus_tasks:
+            self.dbus_tasks.dbus_unregister()
+
         Gtk.Application.do_shutdown(self)
 
     # --------------------------------------------------------------------------
diff --git a/data/dbus/meson.build b/data/dbus/meson.build
new file mode 100644
index 0000000000..b45999c18a
--- /dev/null
+++ b/data/dbus/meson.build
@@ -0,0 +1,8 @@
+configure_file(
+  input: rdnn_name + '.Tasks.xml',
+  output: rdnn_name + '.Tasks.xml',
+  copy: true,
+  install: true,
+  install_dir: dbusinterfacesdir
+)
+
diff --git a/data/dbus/org.gnome.GTG.Tasks.xml b/data/dbus/org.gnome.GTG.Tasks.xml
new file mode 100644
index 0000000000..f80c2bec43
--- /dev/null
+++ b/data/dbus/org.gnome.GTG.Tasks.xml
@@ -0,0 +1,258 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node name="/org/gnome/GTG">
+    <!--
+        org.gnome.GTG.Tasks:
+        @short_description: Manage GTG Tasks
+
+        Interface that GTG implements to let other applications view and edit
+        tasks.
+
+        An common type used here would be the so-called "task dict(ionary)" or
+        a{sv}. It means it is a map of string to generic values. They could
+        contain:
+
+        * id (s): The ID the task can be identified, also called TID (task ID)
+        * title (s): Title of the task
+        * status (i): 0: Unknown/Invalid, 1: Active (Open),
+                      2: Dismissed (Closed), 3: Done (Closed)
+        * text (s): Text content of the task
+        * duedate (s): Due date in ISO 8601, or a fuzzy date
+                       "now", "soon", "someday"
+        * startdate (s): Start date in ISO 8601,
+                         or a fuzzy date "now", "soon", "someday"
+        * donedate (s): When the task was finished (status is 2 or 3),
+                        in ISO 8601 format. Ignore if status is 1 (Active/Open).
+        * tags (as): Tags the task has, without @
+        * children (as): TIDs of subtasks
+        * parent (s): TIDs of the parent task (empty or non-existent means root)
+
+        TODO: Recurring tasks
+        TODO: Write more about Text content of the task
+    -->
+    <interface name="org.gnome.GTG.Tasks">
+        <!--
+            GetTasks:
+            @tids: An array of Task IDs, whose info should be retrieved
+            @tasks: An dictionary of the requested IDs to their task dictionary.
+
+            Simlpy return the task dictionary for the given TIDs.
+            Refer to the interface description for the task dict values.
+
+            Whenever an TID does not exists, it'll fail with gtg.TaskNotFound
+            exception.
+        -->
+        <method name="GetTasks">
+            <arg name="tids" type="as" direction="in"/>
+            <arg name="tasks" type="aa{sv}" direction="out"/>
+        </method>
+
+        <!--
+            GetActiveTaskIds:
+            @tasks: An array of TIDs that are currently active.
+
+            TODO: API documentation, explain what active means
+            Refer to the interface description for the task dict values.
+        -->
+        <method name="GetActiveTaskIds">
+            <arg name="tids" type="as" direction="out"/>
+        </method>
+
+        <!--
+            GetActiveTasks:
+            @tasks: An array of tasks dictionary that are currently active.
+
+            TODO: API documentation, explain what active means
+            Refer to the interface description for the task dict values.
+        -->
+        <method name="GetActiveTasks">
+            <arg name="tasks" type="aa{sv}" direction="out"/>
+        </method>
+
+        <!--
+            GetTaskIdsFiltered:
+            @filter: Filters to apply, also see filters_bank documentation
+            @task_ids: Filtered tasks ids matching the specified filters
+
+            TODO: API documentation
+            Also see the GetTaskFiltered method to find more about filters.
+        -->
+        <method name="GetTaskIdsFiltered">
+            <arg name="filter" type="as" direction="in"/>
+            <arg name="tids" type="as" direction="out"/>
+        </method>
+
+        <!--
+            GetTasksFiltered:
+            @filter: Filters to apply, also see filters_bank documentation
+            @tasks: Filtered tasks dicts matching the specified filters
+
+            TODO: API documentation, possibly explain some of filters_bank
+        -->
+        <method name="GetTasksFiltered">
+            <arg name="filter" type="as" direction="in"/>
+            <arg name="tasks" type="aa{sv}" direction="out"/>
+        </method>
+
+        <!--
+            SearchTasks:
+            @query: Search for tasks, like search bar with special options
+            @tasks: Filtered tasks ids matching the specified filters
+
+            TODO: API documentation, possibly explain some of the specials
+            (If used, need to check)
+        -->
+        <method name="SearchTaskIds">
+            <arg name="query" type="s" direction="in"/>
+            <arg name="tids" type="as" direction="out"/>
+        </method>
+
+        <!--
+            SearchTasks:
+            @query: Search for tasks, like the search bar with special options
+            @tasks: Filtered tasks dicts matching the specified filters
+
+            TODO: API documentation, possibly explain some of the specials
+            (If used, need to check)
+        -->
+        <method name="SearchTasks">
+            <arg name="query" type="s" direction="in"/>
+            <arg name="tasks" type="aa{sv}" direction="out"/>
+        </method>
+
+        <!--
+            HasTasks:
+            @tids: Array of task IDs to check
+            @successful: Map of task IDs to a boolean indicating it exists
+
+            Check whenever the task (by their ID) exists.
+            It returns an dictionary with the key being the requested task id,
+            and the value a boolean whenever the task exists (True) or not
+            (False).
+            Never fails by itself.
+        -->
+        <method name="HasTasks">
+            <arg name="tids" type="as" direction="in"/>
+            <arg name="present" type="a{sb}" direction="out"/>
+        </method>
+
+        <!--
+            DeleteTasks:
+            @tids Array of task IDs to delete
+            @successful: Map of task IDs to a boolean indication success deleting
+
+            Deletes the specified Tasks by their IDs, and returns a map
+            for each ID indicating whenever it got deleted (True) or not
+            (False).
+            Usually, the reason for not being able to delete something is
+            because it does not exists.
+
+            TODO: Recursive deletion?
+        -->
+        <method name="DeleteTasks">
+            <arg name="tids" type="as" direction="in"/>
+            <arg name="successful" type="a{sb}" direction="out"/>
+        </method>
+
+        <!--
+            NewTasks:
+            @data: Array of task dictionaries to add
+            @ids: Array of the new task IDs for the tasks
+
+            TODO: API documentation
+        -->
+        <method name="NewTasks">
+            <arg name="data" type="aa{sv}" direction="in"/>
+            <arg name="ids" type="as" direction="out"/>
+        </method>
+
+        <!--
+            ModifyTasks:
+            @patch: Array of task dictionaries to update, uses the TID to
+                    find the task to modify.
+            @resulting: Array of task dictionaries that was updated, containing
+                        the updated info.
+
+            Update the tasks with the provided information. The patch is an
+            array of task dicts, however attributes not to be modified are
+            simply left out.
+            The id key is required to identify the task to modify, then any
+            other attributes as described in the interface description
+            can then be specified to change.
+
+            When the task is being closed (status is 2 or 3), then it uses the
+            current date for the done date, unless one is explicitly specified.
+            This means any previous done date is overridden.
+
+            Quirks:
+            * The text content will contain the tags, but adding in the text
+              won't update correctly until the user opens the task itself.
+            * Likewise, adding tags will work better, but won't be visible
+              in the text section until the user opens the task itself.
+            * The text content will automatically gain the tags back when the
+              user opens the task itself.
+
+            The following errors can occur:
+            * gtg.InvalidTaskDict: Whenever the given dictionary types doesn't
+              match up.
+            * gtg.InvalidDateFormat: Whenever the date format is wrong
+            * gtg.MissingTaskId: Whenever the 'id'-attribute is missing
+            * gtg.InvalidStartDate: Whenever the start date is invalid
+              (It's a fuzzy date, which it does not allow)
+            * gtg.InvalidDoneDate: Whenever the done date is invalid
+              (It's a fuzzy date, which it does not allow)
+            * gtg.InvalidStatus: Whenever the status is invalid
+              (Outside of being 1, 2 or 3)
+
+            NOTE: Since GTG currently does not support being transactional,
+                  on error previous changes are applied while not later ones.
+        -->
+        <method name="ModifyTasks">
+            <arg name="patch" type="aa{sv}" direction="in"/>
+            <arg name="result" type="aa{sv}" direction="out"/>
+        </method>
+
+        <!--
+            TaskAdded:
+            @tid: Task ID that has been added.
+
+            Signal meaning a new task has been added/created.
+
+            Usually, the task will at this point contain default values,
+            since the user inputs data after creation. However, when creating
+            tasks programmatically (like via NewTasks method), it could already
+            contain data.
+        -->
+        <signal name="TaskAdded">
+            <arg name="tid" type="s"/>
+        </signal>
+
+        <!--
+            TaskModified
+            @tid: Task ID that has been modified.
+
+            Signal meaning a new task has been modified in some way.
+
+            TODO: API documentation
+        -->
+        <signal name="TaskModified">
+            <arg name="tid" type="s"/>
+        </signal>
+
+        <!--
+            TaskDeleted
+            @tid: Task ID that has been deleted.
+
+            Signal meaning a task has been deleted, either by the user
+            or programmatically (like via DeleteTasks method).
+            This does NOT mean it has been closed (which just changes the
+            status)
+
+            You can't access the tasks data of the specified TID since it
+            has been deleted. It is only useful if you keep track of it and
+            now remove it from your internal memory.
+        -->
+        <signal name="TaskDeleted">
+            <arg name="tid" type="s"/>
+        </signal>
+    </interface>
+</node>
diff --git a/data/meson.build b/data/meson.build
index b93f412abb..ce27329592 100644
--- a/data/meson.build
+++ b/data/meson.build
@@ -34,3 +34,4 @@ configure_file(
 )
 
 subdir('icons')
+subdir('dbus')
diff --git a/meson.build b/meson.build
index 4035f5c436..66b42a3806 100644
--- a/meson.build
+++ b/meson.build
@@ -20,6 +20,7 @@ datadir = prefix / get_option('datadir')
 appdatadir = datadir / 'metainfo'
 desktopdir = datadir / 'applications'
 dbusservicedir = datadir / 'dbus-1' / 'services'
+dbusinterfacesdir = datadir / 'dbus-1' / 'interfaces'
 icondir = datadir / 'icons'
 pythondir = python3.get_path('purelib')
 rdnn_name = 'org.gnome.GTG'