Thuban/Model/save.py

# $Id$
# Copyright (c) 2001-2004 by Intevation GmbH
# Authors:
# Jan-Oliver Wagner <[email protected]> (2004)
# Bernhard Herzog <[email protected]> (2001-2004)
# Jonathan Coles <[email protected]> (2003)
# Frank Koormann <[email protected]> (2003)
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Functions to save a session to a file
"""

__version__ = "$Revision$"

import os

import Thuban.Lib.fileutil

from Thuban.Model.layer import Layer, RasterLayer

from Thuban.Model.classification import \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap
from Thuban.Model.transientdb import AutoTransientTable, TransientJoinedTable
from Thuban.Model.table import DBFTable, FIELDTYPE_STRING
from Thuban.Model.data import DerivedShapeStore, ShapefileStore, \
                              SHAPETYPE_POINT

from Thuban.Model.xmlwriter import XMLWriter
from postgisdb import PostGISConnection, PostGISShapeStore

def relative_filename(dir, filename):
    """Return a filename relative to dir for the absolute file name absname.

    This is almost the same as the function in fileutil, except that dir
    can be an empty string in which case filename will be returned
    unchanged.
    """
    if dir:
        return Thuban.Lib.fileutil.relative_filename(dir, filename)
    else:
        return filename


def unify_filename(filename):
    """Return a 'unified' version of filename

    The .thuban files should be as platform independent as possible.
    Since they must contain filenames the filenames have to unified. We
    unify on unix-like filenames for now, which means we do nothing on a
    posix system and simply replace backslashes with slashes on windows
    """
    if os.name == "posix":
        return filename
    elif os.name == "nt":
        return "/".join(filename.split("\\"))
    else:
        raise RuntimeError("Unsupported platform for unify_filename: %s"
                           % os.name)

def sort_data_stores(stores):
    """Return a topologically sorted version of the sequence of data containers

    The list is sorted so that data containers that depend on other data
    containers have higher indexes than the containers they depend on.
    """
    if not stores:
        return []
    processed = {}
    result = []
    todo = stores[:]
    while todo:
        # It doesn't really matter which if the items of todo is
        # processed next, but if we take the first one, the order is
        # preserved to some degree which makes writing some of the test
        # cases easier.
        container = todo.pop(0)
        if id(container) in processed:
            continue
        deps = [dep for dep in container.Dependencies()
                    if id(dep) not in processed]
        if deps:
            todo.append(container)
            todo.extend(deps)
        else:
            result.append(container)
            processed[id(container)] = 1
    return result


class SessionSaver(XMLWriter):

    """Class to serialize a session into an XML file.

    Applications built on top of Thuban may derive from this class and
    override or extend the methods to save additional information. This
    additional information should take the form of additional attributes
    or elements whose names are prefixed with a namespace. To define a
    namespace derived classes should extend the write_session method to
    pass the namespaces to the default implementation.
    """


    def __init__(self, session):
        XMLWriter.__init__(self)
        self.session = session
        # Map object ids to the ids used in the thuban files
        self.idmap = {}

    def get_id(self, obj):
        """Return the id used in the thuban file for the object obj"""
        return self.idmap.get(id(obj))

    def define_id(self, obj, value = None):
        if value is None:
            value = "D" + str(id(obj))
        self.idmap[id(obj)] = value
        return value

    def has_id(self, obj):
        return self.idmap.has_key(id(obj))

    def prepare_filename(self, filename):
        """Return the string to use when writing filename to the thuban file

        The returned string is a unified version (only slashes as
        directory separators, see unify_filename) of filename expressed
        relative to the directory the .thuban file is written to.
        """
        return unify_filename(relative_filename(self.dir, filename))

    def write(self, file_or_filename):
        XMLWriter.write(self, file_or_filename)

        self.write_header("session", "thuban-1.1.dtd")
        self.write_session(self.session)
        self.close()

    def write_session(self, session, attrs = None, namespaces = ()):
        """Write the session and its contents

        By default, write a session element with the title attribute and
        call write_map for each map contained in the session.

        The optional argument attrs is for additional attributes and, if
        given, should be a mapping from attribute names to attribute
        values. The values should not be XML-escaped yet.

        The optional argument namespaces, if given, should be a sequence
        of (name, URI) pairs. The namespaces are written as namespace
        attributes into the session element. This is mainly useful for
        derived classes that need to store additional information in a
        thuban session file.
        """
        if attrs is None:
            attrs = {}
        attrs["title"] = session.title
        for name, uri in namespaces:
            attrs["xmlns:" + name] = uri
        # default name space
        attrs["xmlns"] = \
               "http://thuban.intevation.org/dtds/thuban-1.1-dev.dtd"
        self.open_element("session", attrs)
        self.write_db_connections(session)
        self.write_data_containers(session)
        for map in session.Maps():
            self.write_map(map)
        self.close_element("session")

    def write_db_connections(self, session):
        for conn in session.DBConnections():
            if isinstance(conn, PostGISConnection):
                self.write_element("dbconnection",
                                   {"id": self.define_id(conn),
                                    "dbtype": "postgis",
                                    "host": conn.host,
                                    "port": conn.port,
                                    "user": conn.user,
                                    "dbname": conn.dbname})
            else:
                raise ValueError("Can't handle db connection %r" % conn)

    def write_data_containers(self, session):
        containers = sort_data_stores(session.DataContainers())
        for container in containers:
            if isinstance(container, AutoTransientTable):
                # AutoTransientTable instances are invisible in the
                # thuban files. They're only used internally. To make
                # sure that containers depending on AutoTransientTable
                # instances refer to the right real containers we give
                # the AutoTransientTable instances the same id as the
                # source they depend on.
                self.define_id(container,
                               self.get_id(container.Dependencies()[0]))
                continue

            idvalue = self.define_id(container)
            if isinstance(container, ShapefileStore):
                self.define_id(container.Table(), idvalue)
                filename = self.prepare_filename(container.FileName())
                self.write_element("fileshapesource",
                                   {"id": idvalue, "filename": filename,
                                    "filetype": "shapefile"})
            elif isinstance(container, DerivedShapeStore):
                shapesource, table = container.Dependencies()
                self.write_element("derivedshapesource",
                                   {"id": idvalue,
                                    "shapesource": self.get_id(shapesource),
                                    "table": self.get_id(table)})
            elif isinstance(container, PostGISShapeStore):
                conn = container.DBConnection()
                self.write_element("dbshapesource",
                                   {"id": idvalue,
                                    "dbconn": self.get_id(conn),
                                    "tablename": container.TableName(),
                                    "id_column": container.IDColumn().name,
                                    "geometry_column":
                                      container.GeometryColumn().name,
                                    })
            elif isinstance(container, DBFTable):
                filename = self.prepare_filename(container.FileName())
                self.write_element("filetable",
                                   {"id": idvalue,
                                    "title": container.Title(),
                                    "filename": filename,
                                    "filetype": "DBF"})
            elif isinstance(container, TransientJoinedTable):
                left, right = container.Dependencies()
                left_field = container.left_field
                right_field = container.right_field
                self.write_element("jointable",
                                   {"id": idvalue,
                                    "title": container.Title(),
                                    "right": self.get_id(right),
                                    "rightcolumn": right_field,
                                    "left": self.get_id(left),
                                    "leftcolumn": left_field,
                                    "jointype": container.JoinType()})
            else:
                raise ValueError("Can't handle container %r" % container)


    def write_map(self, map):
        """Write the map and its contents.

        By default, write a map element element with the title
        attribute, call write_projection to write the projection
        element, call write_layer for each layer contained in the map
        and finally call write_label_layer to write the label layer.
        """
        self.open_element('map title="%s"' % self.encode(map.title))
        self.write_projection(map.projection)
        for layer in map.Layers():
            self.write_layer(layer)
        self.write_label_layer(map.LabelLayer())
        self.close_element('map')

    def write_projection(self, projection):
        """Write the projection.
        """
        if projection and len(projection.params) > 0:
            attrs = {"name": projection.GetName()}
            epsg = projection.EPSGCode()
            if epsg is not None:
                attrs["epsg"] = epsg
            self.open_element("projection", attrs)
            for param in projection.params:
                self.write_element('parameter value="%s"' % 
                                   self.encode(param))
            self.close_element("projection")

    def write_layer(self, layer, attrs = None):
        """Write the layer.

        The optional argument attrs is for additional attributes and, if
        given, should be a mapping from attribute names to attribute
        values. The values should not be XML-escaped yet.
        """

        if attrs is None:
            attrs = {}

        attrs["title"]   = layer.title
        attrs["visible"] = ("false", "true")[int(layer.Visible())]

        if isinstance(layer, Layer):
            attrs["shapestore"]   = self.get_id(layer.ShapeStore())

            lc = layer.GetClassification()
            attrs["stroke"] = lc.GetDefaultLineColor().hex()
            attrs["stroke_width"] = str(lc.GetDefaultLineWidth())
            attrs["fill"] = lc.GetDefaultFill().hex()

            self.open_element("layer", attrs)
            self.write_projection(layer.GetProjection())
            self.write_classification(layer)
            self.close_element("layer")
        elif isinstance(layer, RasterLayer):
            attrs["filename"] = self.prepare_filename(layer.filename)
            self.open_element("rasterlayer", attrs)
            self.write_projection(layer.GetProjection())
            self.close_element("rasterlayer")

    def write_classification(self, layer, attrs = None):
        """Write Classification information."""

        if attrs is None:
            attrs = {}

        lc = layer.GetClassification()

        field = layer.GetClassificationColumn()

        #
        # there isn't a classification of anything so do nothing
        #
        if field is None: return

        attrs["field"] = field
        attrs["field_type"] = str(layer.GetFieldType(field))
        self.open_element("classification", attrs)

        for g in lc:
            if isinstance(g, ClassGroupDefault):
                open_el  = 'clnull label="%s"' % self.encode(g.GetLabel())
                close_el = 'clnull'
            elif isinstance(g, ClassGroupSingleton):
                if layer.GetFieldType(field) == FIELDTYPE_STRING:
                    value = self.encode(g.GetValue())
                else:
                    value = str(g.GetValue())
                open_el  = 'clpoint label="%s" value="%s"' \
                           % (self.encode(g.GetLabel()), value)
                close_el = 'clpoint'
            elif isinstance(g, ClassGroupRange):
                open_el  = 'clrange label="%s" range="%s"' \
                          % (self.encode(g.GetLabel()), str(g.GetRange()))
                close_el = 'clrange'
            else:
                assert False, _("Unsupported group type in classification")
                continue

            data = g.GetProperties()
            dict = {'stroke'      : data.GetLineColor().hex(),
                    'stroke_width': str(data.GetLineWidth()),
                    'fill'        : data.GetFill().hex()}

            # only for point layers write the size attribute
            if layer.ShapeType() == SHAPETYPE_POINT:
                dict['size'] =  str(data.GetSize())

            self.open_element(open_el)
            self.write_element("cldata", dict)
            self.close_element(close_el)

        self.close_element("classification")

    def write_label_layer(self, layer):
        """Write the label layer.
        """
        labels = layer.Labels()
        if labels:
            self.open_element('labellayer')
            for label in labels:
                self.write_element(('label x="%g" y="%g" text="%s"'
                                    ' halign="%s" valign="%s"')
                                % (label.x, label.y, 
                                   self.encode(label.text), 
                                   label.halign,
                                   label.valign))
            self.close_element('labellayer')


def save_session(session, file, saver_class = None):
    """Save the session session to a file.

    The file argument may either be a filename or an open file object.

    The optional argument saver_class is the class to use to serialize
    the session. By default or if it's None, the saver class will be
    SessionSaver.

    If writing the session is successful call the session's
    UnsetModified method
    """
    if saver_class is None:
        saver_class = SessionSaver
    saver = saver_class(session)
    saver.write(file)

    # after a successful save consider the session unmodified.
    session.UnsetModified()
1	# $Id$
2	# Copyright (c) 2001-2004 by Intevation GmbH
3	# Authors:
4	# Jan-Oliver Wagner <[email protected]> (2004)
5	# Bernhard Herzog <[email protected]> (2001-2004)
6	# Jonathan Coles <[email protected]> (2003)
7	# Frank Koormann <[email protected]> (2003)
8	#
9	# This program is free software under the GPL (>=v2)
10	# Read the file COPYING coming with Thuban for details.
11
12	"""
13	Functions to save a session to a file
14	"""
15
16	__version__ = "$Revision$"
17
18	import os
19
20	import Thuban.Lib.fileutil
21
22	from Thuban.Model.layer import Layer, RasterLayer
23
24	from Thuban.Model.classification import \
25	ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap
26	from Thuban.Model.transientdb import AutoTransientTable, TransientJoinedTable
27	from Thuban.Model.table import DBFTable, FIELDTYPE_STRING
28	from Thuban.Model.data import DerivedShapeStore, ShapefileStore, \
29	SHAPETYPE_POINT
30
31	from Thuban.Model.xmlwriter import XMLWriter
32	from postgisdb import PostGISConnection, PostGISShapeStore
33
34	def relative_filename(dir, filename):
35	"""Return a filename relative to dir for the absolute file name absname.
36
37	This is almost the same as the function in fileutil, except that dir
38	can be an empty string in which case filename will be returned
39	unchanged.
40	"""
41	if dir:
42	return Thuban.Lib.fileutil.relative_filename(dir, filename)
43	else:
44	return filename
45
46
47	def unify_filename(filename):
48	"""Return a 'unified' version of filename
49
50	The .thuban files should be as platform independent as possible.
51	Since they must contain filenames the filenames have to unified. We
52	unify on unix-like filenames for now, which means we do nothing on a
53	posix system and simply replace backslashes with slashes on windows
54	"""
55	if os.name == "posix":
56	return filename
57	elif os.name == "nt":
58	return "/".join(filename.split("\\"))
59	else:
60	raise RuntimeError("Unsupported platform for unify_filename: %s"
61	% os.name)
62
63	def sort_data_stores(stores):
64	"""Return a topologically sorted version of the sequence of data containers
65
66	The list is sorted so that data containers that depend on other data
67	containers have higher indexes than the containers they depend on.
68	"""
69	if not stores:
70	return []
71	processed = {}
72	result = []
73	todo = stores[:]
74	while todo:
75	# It doesn't really matter which if the items of todo is
76	# processed next, but if we take the first one, the order is
77	# preserved to some degree which makes writing some of the test
78	# cases easier.
79	container = todo.pop(0)
80	if id(container) in processed:
81	continue
82	deps = [dep for dep in container.Dependencies()
83	if id(dep) not in processed]
84	if deps:
85	todo.append(container)
86	todo.extend(deps)
87	else:
88	result.append(container)
89	processed[id(container)] = 1
90	return result
91
92
93	class SessionSaver(XMLWriter):
94
95	"""Class to serialize a session into an XML file.
96
97	Applications built on top of Thuban may derive from this class and
98	override or extend the methods to save additional information. This
99	additional information should take the form of additional attributes
100	or elements whose names are prefixed with a namespace. To define a
101	namespace derived classes should extend the write_session method to
102	pass the namespaces to the default implementation.
103	"""
104
105
106	def __init__(self, session):
107	XMLWriter.__init__(self)
108	self.session = session
109	# Map object ids to the ids used in the thuban files
110	self.idmap = {}
111
112	def get_id(self, obj):
113	"""Return the id used in the thuban file for the object obj"""
114	return self.idmap.get(id(obj))
115
116	def define_id(self, obj, value = None):
117	if value is None:
118	value = "D" + str(id(obj))
119	self.idmap[id(obj)] = value
120	return value
121
122	def has_id(self, obj):
123	return self.idmap.has_key(id(obj))
124
125	def prepare_filename(self, filename):
126	"""Return the string to use when writing filename to the thuban file
127
128	The returned string is a unified version (only slashes as
129	directory separators, see unify_filename) of filename expressed
130	relative to the directory the .thuban file is written to.
131	"""
132	return unify_filename(relative_filename(self.dir, filename))
133
134	def write(self, file_or_filename):
135	XMLWriter.write(self, file_or_filename)
136
137	self.write_header("session", "thuban-1.1.dtd")
138	self.write_session(self.session)
139	self.close()
140
141	def write_session(self, session, attrs = None, namespaces = ()):
142	"""Write the session and its contents
143
144	By default, write a session element with the title attribute and
145	call write_map for each map contained in the session.
146
147	The optional argument attrs is for additional attributes and, if
148	given, should be a mapping from attribute names to attribute
149	values. The values should not be XML-escaped yet.
150
151	The optional argument namespaces, if given, should be a sequence
152	of (name, URI) pairs. The namespaces are written as namespace
153	attributes into the session element. This is mainly useful for
154	derived classes that need to store additional information in a
155	thuban session file.
156	"""
157	if attrs is None:
158	attrs = {}
159	attrs["title"] = session.title
160	for name, uri in namespaces:
161	attrs["xmlns:" + name] = uri
162	# default name space
163	attrs["xmlns"] = \
164	"http://thuban.intevation.org/dtds/thuban-1.1-dev.dtd"
165	self.open_element("session", attrs)
166	self.write_db_connections(session)
167	self.write_data_containers(session)
168	for map in session.Maps():
169	self.write_map(map)
170	self.close_element("session")
171
172	def write_db_connections(self, session):
173	for conn in session.DBConnections():
174	if isinstance(conn, PostGISConnection):
175	self.write_element("dbconnection",
176	{"id": self.define_id(conn),
177	"dbtype": "postgis",
178	"host": conn.host,
179	"port": conn.port,
180	"user": conn.user,
181	"dbname": conn.dbname})
182	else:
183	raise ValueError("Can't handle db connection %r" % conn)
184
185	def write_data_containers(self, session):
186	containers = sort_data_stores(session.DataContainers())
187	for container in containers:
188	if isinstance(container, AutoTransientTable):
189	# AutoTransientTable instances are invisible in the
190	# thuban files. They're only used internally. To make
191	# sure that containers depending on AutoTransientTable
192	# instances refer to the right real containers we give
193	# the AutoTransientTable instances the same id as the
194	# source they depend on.
195	self.define_id(container,
196	self.get_id(container.Dependencies()[0]))
197	continue
198
199	idvalue = self.define_id(container)
200	if isinstance(container, ShapefileStore):
201	self.define_id(container.Table(), idvalue)
202	filename = self.prepare_filename(container.FileName())
203	self.write_element("fileshapesource",
204	{"id": idvalue, "filename": filename,
205	"filetype": "shapefile"})
206	elif isinstance(container, DerivedShapeStore):
207	shapesource, table = container.Dependencies()
208	self.write_element("derivedshapesource",
209	{"id": idvalue,
210	"shapesource": self.get_id(shapesource),
211	"table": self.get_id(table)})
212	elif isinstance(container, PostGISShapeStore):
213	conn = container.DBConnection()
214	self.write_element("dbshapesource",
215	{"id": idvalue,
216	"dbconn": self.get_id(conn),
217	"tablename": container.TableName(),
218	"id_column": container.IDColumn().name,
219	"geometry_column":
220	container.GeometryColumn().name,
221	})
222	elif isinstance(container, DBFTable):
223	filename = self.prepare_filename(container.FileName())
224	self.write_element("filetable",
225	{"id": idvalue,
226	"title": container.Title(),
227	"filename": filename,
228	"filetype": "DBF"})
229	elif isinstance(container, TransientJoinedTable):
230	left, right = container.Dependencies()
231	left_field = container.left_field
232	right_field = container.right_field
233	self.write_element("jointable",
234	{"id": idvalue,
235	"title": container.Title(),
236	"right": self.get_id(right),
237	"rightcolumn": right_field,
238	"left": self.get_id(left),
239	"leftcolumn": left_field,
240	"jointype": container.JoinType()})
241	else:
242	raise ValueError("Can't handle container %r" % container)
243
244
245	def write_map(self, map):
246	"""Write the map and its contents.
247
248	By default, write a map element element with the title
249	attribute, call write_projection to write the projection
250	element, call write_layer for each layer contained in the map
251	and finally call write_label_layer to write the label layer.
252	"""
253	self.open_element('map title="%s"' % self.encode(map.title))
254	self.write_projection(map.projection)
255	for layer in map.Layers():
256	self.write_layer(layer)
257	self.write_label_layer(map.LabelLayer())
258	self.close_element('map')
259
260	def write_projection(self, projection):
261	"""Write the projection.
262	"""
263	if projection and len(projection.params) > 0:
264	attrs = {"name": projection.GetName()}
265	epsg = projection.EPSGCode()
266	if epsg is not None:
267	attrs["epsg"] = epsg
268	self.open_element("projection", attrs)
269	for param in projection.params:
270	self.write_element('parameter value="%s"' %
271	self.encode(param))
272	self.close_element("projection")
273
274	def write_layer(self, layer, attrs = None):
275	"""Write the layer.
276
277	The optional argument attrs is for additional attributes and, if
278	given, should be a mapping from attribute names to attribute
279	values. The values should not be XML-escaped yet.
280	"""
281
282	if attrs is None:
283	attrs = {}
284
285	attrs["title"] = layer.title
286	attrs["visible"] = ("false", "true")[int(layer.Visible())]
287
288	if isinstance(layer, Layer):
289	attrs["shapestore"] = self.get_id(layer.ShapeStore())
290
291	lc = layer.GetClassification()
292	attrs["stroke"] = lc.GetDefaultLineColor().hex()
293	attrs["stroke_width"] = str(lc.GetDefaultLineWidth())
294	attrs["fill"] = lc.GetDefaultFill().hex()
295
296	self.open_element("layer", attrs)
297	self.write_projection(layer.GetProjection())
298	self.write_classification(layer)
299	self.close_element("layer")
300	elif isinstance(layer, RasterLayer):
301	attrs["filename"] = self.prepare_filename(layer.filename)
302	self.open_element("rasterlayer", attrs)
303	self.write_projection(layer.GetProjection())
304	self.close_element("rasterlayer")
305
306	def write_classification(self, layer, attrs = None):
307	"""Write Classification information."""
308
309	if attrs is None:
310	attrs = {}
311
312	lc = layer.GetClassification()
313
314	field = layer.GetClassificationColumn()
315
316	#
317	# there isn't a classification of anything so do nothing
318	#
319	if field is None: return
320
321	attrs["field"] = field
322	attrs["field_type"] = str(layer.GetFieldType(field))
323	self.open_element("classification", attrs)
324
325	for g in lc:
326	if isinstance(g, ClassGroupDefault):
327	open_el = 'clnull label="%s"' % self.encode(g.GetLabel())
328	close_el = 'clnull'
329	elif isinstance(g, ClassGroupSingleton):
330	if layer.GetFieldType(field) == FIELDTYPE_STRING:
331	value = self.encode(g.GetValue())
332	else:
333	value = str(g.GetValue())
334	open_el = 'clpoint label="%s" value="%s"' \
335	% (self.encode(g.GetLabel()), value)
336	close_el = 'clpoint'
337	elif isinstance(g, ClassGroupRange):
338	open_el = 'clrange label="%s" range="%s"' \
339	% (self.encode(g.GetLabel()), str(g.GetRange()))
340	close_el = 'clrange'
341	else:
342	assert False, _("Unsupported group type in classification")
343	continue
344
345	data = g.GetProperties()
346	dict = {'stroke' : data.GetLineColor().hex(),
347	'stroke_width': str(data.GetLineWidth()),
348	'fill' : data.GetFill().hex()}
349
350	# only for point layers write the size attribute
351	if layer.ShapeType() == SHAPETYPE_POINT:
352	dict['size'] = str(data.GetSize())
353
354	self.open_element(open_el)
355	self.write_element("cldata", dict)
356	self.close_element(close_el)
357
358	self.close_element("classification")
359
360	def write_label_layer(self, layer):
361	"""Write the label layer.
362	"""
363	labels = layer.Labels()
364	if labels:
365	self.open_element('labellayer')
366	for label in labels:
367	self.write_element(('label x="%g" y="%g" text="%s"'
368	' halign="%s" valign="%s"')
369	% (label.x, label.y,
370	self.encode(label.text),
371	label.halign,
372	label.valign))
373	self.close_element('labellayer')
374
375
376
377	def save_session(session, file, saver_class = None):
378	"""Save the session session to a file.
379
380	The file argument may either be a filename or an open file object.
381
382	The optional argument saver_class is the class to use to serialize
383	the session. By default or if it's None, the saver class will be
384	SessionSaver.
385
386	If writing the session is successful call the session's
387	UnsetModified method
388	"""
389	if saver_class is None:
390	saver_class = SessionSaver
391	saver = saver_class(session)
392	saver.write(file)
393
394	# after a successful save consider the session unmodified.
395	session.UnsetModified()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision