2004-09-29 08:49:01 +05:30
|
|
|
#
|
2004-08-01 09:51:31 +05:30
|
|
|
# Gramps - a GTK+/GNOME based genealogy program
|
|
|
|
#
|
2005-03-14 03:40:40 +05:30
|
|
|
# Copyright (C) 2000-2005 Donald N. Allingham
|
2004-08-01 09:51:31 +05:30
|
|
|
#
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU General Public License as published by
|
|
|
|
# the Free Software Foundation; either version 2 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 General Public License for more details.
|
|
|
|
#
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
|
|
# along with this program; if not, write to the Free Software
|
|
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
#
|
|
|
|
|
|
|
|
# $Id$
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Base class for the GRAMPS databases. All database interfaces should inherit
|
|
|
|
from this class.
|
|
|
|
"""
|
|
|
|
|
2004-08-07 10:46:57 +05:30
|
|
|
#-------------------------------------------------------------------------
|
|
|
|
#
|
|
|
|
# libraries
|
|
|
|
#
|
|
|
|
#-------------------------------------------------------------------------
|
2004-08-01 09:51:31 +05:30
|
|
|
import cPickle
|
2004-08-24 09:18:15 +05:30
|
|
|
import time
|
2005-01-09 07:48:49 +05:30
|
|
|
import random
|
2004-08-27 03:24:14 +05:30
|
|
|
import locale
|
2004-10-04 02:34:54 +05:30
|
|
|
import re
|
2005-04-19 20:17:02 +05:30
|
|
|
from sys import maxint
|
2005-08-18 11:28:28 +05:30
|
|
|
import sets
|
2004-08-07 10:46:57 +05:30
|
|
|
from gettext import gettext as _
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-01-09 07:48:49 +05:30
|
|
|
#-------------------------------------------------------------------------
|
|
|
|
#
|
|
|
|
# GRAMPS libraries
|
|
|
|
#
|
|
|
|
#-------------------------------------------------------------------------
|
|
|
|
from RelLib import *
|
2005-01-06 22:58:31 +05:30
|
|
|
import GrampsKeys
|
2005-04-02 01:34:12 +05:30
|
|
|
import GrampsDBCallback
|
2004-09-25 10:42:15 +05:30
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
#-------------------------------------------------------------------------
|
|
|
|
#
|
2004-08-07 10:46:57 +05:30
|
|
|
# constants
|
2004-08-01 09:51:31 +05:30
|
|
|
#
|
|
|
|
#-------------------------------------------------------------------------
|
2004-08-07 10:46:57 +05:30
|
|
|
_UNDO_SIZE = 1000
|
2004-10-04 02:34:54 +05:30
|
|
|
_id_reg = re.compile("%\d+d")
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-11 21:52:36 +05:30
|
|
|
PERSON_KEY = 0
|
|
|
|
FAMILY_KEY = 1
|
|
|
|
SOURCE_KEY = 2
|
|
|
|
EVENT_KEY = 3
|
|
|
|
MEDIA_KEY = 4
|
|
|
|
PLACE_KEY = 5
|
2005-05-27 23:13:04 +05:30
|
|
|
REPOSITORY_KEY = 6
|
2004-08-11 21:52:36 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
PERSON_COL_KEY = 'columns'
|
|
|
|
CHILD_COL_KEY = 'child_columns'
|
|
|
|
PLACE_COL_KEY = 'place_columns'
|
|
|
|
SOURCE_COL_KEY = 'source_columns'
|
|
|
|
MEDIA_COL_KEY = 'media_columns'
|
|
|
|
REPOSITORY_COL_KEY = 'repository_columns'
|
2005-06-07 10:38:50 +05:30
|
|
|
EVENT_COL_KEY = 'event_columns'
|
2005-04-18 04:04:56 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
_sigbase = ('person', 'family', 'source', 'event',
|
|
|
|
'media', 'place', 'repository')
|
2005-04-18 04:04:56 +05:30
|
|
|
|
2004-12-06 09:43:13 +05:30
|
|
|
class GrampsCursor:
|
|
|
|
"""
|
|
|
|
Provides a basic iterator that allows the user to cycle through
|
|
|
|
the elements in a particular map. A cursor should never be
|
|
|
|
directly instantiated. Instead, in should be created by the
|
|
|
|
database class.
|
|
|
|
|
|
|
|
A cursor should only be used for a single pass through the
|
|
|
|
database. If multiple passes are needed, multiple cursors
|
|
|
|
should be used.
|
|
|
|
"""
|
|
|
|
|
|
|
|
def first(self):
|
|
|
|
"""
|
|
|
|
Returns the first (index, data) pair in the database. This
|
|
|
|
should be called before the first call to next(). Note that
|
|
|
|
the data return is in the format of the serialized format
|
|
|
|
stored in the database, not in the more usable class object.
|
|
|
|
The data should be converted to a class using the class's
|
|
|
|
unserialize method.
|
|
|
|
|
|
|
|
If no data is available, None is returned.
|
|
|
|
"""
|
|
|
|
return None
|
|
|
|
|
|
|
|
def next(self):
|
|
|
|
"""
|
|
|
|
Returns the next (index, data) pair in the database. Like
|
|
|
|
the first() method, the data return is in the format of the
|
|
|
|
serialized format stored in the database, not in the more
|
|
|
|
usable class object. The data should be converted to a class
|
|
|
|
using the class's unserialize method.
|
|
|
|
|
|
|
|
None is returned when no more data is available.
|
|
|
|
"""
|
|
|
|
return None
|
|
|
|
|
|
|
|
def close(self):
|
|
|
|
"""
|
|
|
|
Closes the cursor. This should be called when the user is
|
|
|
|
finished using the cursor, freeing up the cursor's resources.
|
|
|
|
"""
|
|
|
|
pass
|
|
|
|
|
2005-04-02 01:34:12 +05:30
|
|
|
class GrampsDbBase(GrampsDBCallback.GrampsDBCallback):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
GRAMPS database object. This object is a base class for all
|
|
|
|
database interfaces.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-04-02 01:34:12 +05:30
|
|
|
__signals__ = {
|
|
|
|
'person-add' : (list,),
|
|
|
|
'person-update' : (list,),
|
|
|
|
'person-delete' : (list,),
|
|
|
|
'person-rebuild' : None,
|
|
|
|
'family-add' : (list,),
|
|
|
|
'family-update' : (list,),
|
|
|
|
'family-delete' : (list,),
|
|
|
|
'family-rebuild' : None,
|
|
|
|
'source-add' : (list,),
|
|
|
|
'source-update' : (list,),
|
|
|
|
'source-delete' : (list,),
|
|
|
|
'source-rebuild' : None,
|
|
|
|
'place-add' : (list,),
|
|
|
|
'place-update' : (list,),
|
|
|
|
'place-delete' : (list,),
|
2005-04-04 05:57:06 +05:30
|
|
|
'place-rebuild' : None,
|
|
|
|
'media-add' : (list,),
|
|
|
|
'media-update' : (list,),
|
|
|
|
'media-delete' : (list,),
|
|
|
|
'media-rebuild' : None,
|
2005-04-18 04:04:56 +05:30
|
|
|
'event-add' : (list,),
|
|
|
|
'event-update' : (list,),
|
|
|
|
'event-delete' : (list,),
|
|
|
|
'event-rebuild' : None,
|
2005-05-27 23:13:04 +05:30
|
|
|
'repository-add' : (list,),
|
|
|
|
'repository-update' : (list,),
|
|
|
|
'repository-delete' : (list,),
|
|
|
|
'repository-rebuild' : None,
|
2005-04-02 01:34:12 +05:30
|
|
|
}
|
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
def __init__(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Creates a new GrampsDbBase instance. A new GrampDbBase class should
|
|
|
|
never be directly created. Only classes derived from this class should
|
|
|
|
be created.
|
|
|
|
"""
|
|
|
|
|
2005-04-02 01:34:12 +05:30
|
|
|
GrampsDBCallback.GrampsDBCallback.__init__(self)
|
|
|
|
|
2005-02-17 04:19:54 +05:30
|
|
|
self.readonly = False
|
2005-01-09 07:48:49 +05:30
|
|
|
self.rand = random.Random(time.time())
|
2004-08-13 10:04:07 +05:30
|
|
|
self.smap_index = 0
|
|
|
|
self.emap_index = 0
|
|
|
|
self.pmap_index = 0
|
|
|
|
self.fmap_index = 0
|
|
|
|
self.lmap_index = 0
|
|
|
|
self.omap_index = 0
|
2005-05-27 23:13:04 +05:30
|
|
|
self.rmap_index = 0
|
2004-08-13 10:04:07 +05:30
|
|
|
|
2005-08-18 11:28:28 +05:30
|
|
|
self.family_event_names = sets.Set()
|
|
|
|
self.individual_event_names = sets.Set()
|
|
|
|
self.individual_attributes = sets.Set()
|
|
|
|
self.family_attributes = sets.Set()
|
|
|
|
|
2005-01-06 22:58:31 +05:30
|
|
|
self.set_person_id_prefix(GrampsKeys.get_person_id_prefix())
|
|
|
|
self.set_object_id_prefix(GrampsKeys.get_object_id_prefix())
|
|
|
|
self.set_family_id_prefix(GrampsKeys.get_family_id_prefix())
|
|
|
|
self.set_source_id_prefix(GrampsKeys.get_source_id_prefix())
|
|
|
|
self.set_place_id_prefix(GrampsKeys.get_place_id_prefix())
|
|
|
|
self.set_event_id_prefix(GrampsKeys.get_event_id_prefix())
|
2005-05-27 23:13:04 +05:30
|
|
|
self.set_repository_id_prefix(GrampsKeys.get_repository_id_prefix())
|
2004-08-13 10:04:07 +05:30
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
self.open = 0
|
|
|
|
self.genderStats = GenderStats()
|
|
|
|
|
2004-10-08 09:29:55 +05:30
|
|
|
self.undodb = None
|
2004-08-24 09:18:15 +05:30
|
|
|
self.id_trans = None
|
|
|
|
self.fid_trans = None
|
|
|
|
self.pid_trans = None
|
|
|
|
self.sid_trans = None
|
|
|
|
self.oid_trans = None
|
2005-05-27 23:13:04 +05:30
|
|
|
self.rid_trans = None
|
2005-06-08 10:10:33 +05:30
|
|
|
self.eid_trans = None
|
2004-08-01 09:51:31 +05:30
|
|
|
self.env = None
|
|
|
|
self.person_map = None
|
|
|
|
self.family_map = None
|
|
|
|
self.place_map = None
|
|
|
|
self.source_map = None
|
2005-05-27 23:13:04 +05:30
|
|
|
self.repository_map = None
|
2004-08-01 09:51:31 +05:30
|
|
|
self.media_map = None
|
|
|
|
self.event_map = None
|
|
|
|
self.metadata = None
|
2004-10-01 00:02:56 +05:30
|
|
|
self.name_group = None
|
2004-08-13 10:04:07 +05:30
|
|
|
self.undo_callback = None
|
|
|
|
self.redo_callback = None
|
2004-08-01 09:51:31 +05:30
|
|
|
self.modified = 0
|
|
|
|
|
2004-08-11 09:12:38 +05:30
|
|
|
self.undoindex = -1
|
|
|
|
self.translist = [None] * _UNDO_SIZE
|
|
|
|
self.default = None
|
|
|
|
self.owner = Researcher()
|
|
|
|
self.bookmarks = []
|
|
|
|
self.path = ""
|
|
|
|
self.place2title = {}
|
2005-04-04 06:41:50 +05:30
|
|
|
self.name_group = {}
|
2005-03-31 10:00:44 +05:30
|
|
|
|
2005-08-18 11:28:28 +05:30
|
|
|
def rebuild_secondary(self,callback=None):
|
|
|
|
pass
|
|
|
|
|
2005-06-05 09:31:56 +05:30
|
|
|
def version_supported(self):
|
|
|
|
""" Returns True when the file has a supported version"""
|
|
|
|
return True
|
|
|
|
|
2005-03-03 11:03:22 +05:30
|
|
|
def need_upgrade(self):
|
|
|
|
return False
|
|
|
|
|
|
|
|
def upgrade(self):
|
|
|
|
pass
|
|
|
|
|
2005-01-09 07:48:49 +05:30
|
|
|
def create_id(self):
|
2005-04-29 03:51:20 +05:30
|
|
|
return "%08x%08x" % ( int(time.time()*10000),
|
|
|
|
self.rand.randint(0,maxint))
|
2005-01-09 07:48:49 +05:30
|
|
|
|
2004-12-05 09:45:48 +05:30
|
|
|
def get_person_cursor(self):
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
2004-12-10 06:58:43 +05:30
|
|
|
def get_family_cursor(self):
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
2005-06-07 10:38:50 +05:30
|
|
|
def get_event_cursor(self):
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
2004-12-10 06:58:43 +05:30
|
|
|
def get_place_cursor(self):
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
|
|
|
def get_source_cursor(self):
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
|
|
|
def get_media_cursor(self):
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def get_repository_cursor(self):
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
def load(self,name,callback):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Opens the specified database. The method needs to be overridden
|
|
|
|
in the derived class.
|
|
|
|
"""
|
2004-09-11 04:10:00 +05:30
|
|
|
assert False, "Needs to be overridden in the derived class"
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-11 09:12:38 +05:30
|
|
|
def close(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Closes the specified database. The method needs to be overridden
|
|
|
|
in the derived class.
|
|
|
|
"""
|
2004-09-11 04:10:00 +05:30
|
|
|
assert False, "Needs to be overridden in the derived class"
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-10-13 09:21:27 +05:30
|
|
|
def abort_changes(self):
|
|
|
|
pass
|
|
|
|
|
2004-08-11 09:12:38 +05:30
|
|
|
def is_open(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns 1 if the database has been opened.
|
|
|
|
"""
|
2004-08-11 09:12:38 +05:30
|
|
|
return self.person_map != None
|
2005-04-04 22:11:01 +05:30
|
|
|
|
|
|
|
def request_rebuild(self):
|
|
|
|
"""
|
|
|
|
Notifies clients that the data has change significantly, and that all
|
|
|
|
internal data dependent on the database should be rebuilt.
|
|
|
|
"""
|
|
|
|
self.emit('person-rebuild')
|
|
|
|
self.emit('family-rebuild')
|
|
|
|
self.emit('place-rebuild')
|
|
|
|
self.emit('source-rebuild')
|
|
|
|
self.emit('media-rebuild')
|
2005-04-18 04:04:56 +05:30
|
|
|
self.emit('event-rebuild')
|
2005-05-27 23:13:04 +05:30
|
|
|
self.emit('repository-rebuild')
|
2005-04-18 04:04:56 +05:30
|
|
|
|
|
|
|
def _commit_base(self, obj, data_map, key, update_list, add_list,
|
|
|
|
transaction, change_time):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Commits the specified Person to the database, storing the changes
|
|
|
|
as part of the transaction.
|
|
|
|
"""
|
2005-05-24 18:38:06 +05:30
|
|
|
if self.readonly or not obj or not obj.handle:
|
2005-02-17 04:19:54 +05:30
|
|
|
return
|
2004-08-24 09:18:15 +05:30
|
|
|
if change_time:
|
2005-04-18 04:04:56 +05:30
|
|
|
obj.change = int(change_time)
|
2004-08-24 09:18:15 +05:30
|
|
|
else:
|
2005-04-18 04:04:56 +05:30
|
|
|
obj.change = int(time.time())
|
|
|
|
handle = str(obj.handle)
|
|
|
|
|
|
|
|
if transaction.batch:
|
|
|
|
data_map[handle] = obj.serialize()
|
2005-08-06 08:27:37 +05:30
|
|
|
old_data = None
|
2005-04-05 05:22:46 +05:30
|
|
|
else:
|
2005-04-18 04:04:56 +05:30
|
|
|
old_data = data_map.get(handle)
|
|
|
|
transaction.add(key,handle,old_data)
|
|
|
|
if old_data:
|
|
|
|
update_list.append((handle,obj.serialize()))
|
|
|
|
else:
|
|
|
|
add_list.append((handle,obj.serialize()))
|
2005-08-11 05:23:24 +05:30
|
|
|
return old_data
|
2005-07-09 01:54:54 +05:30
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def commit_person(self,person,transaction,change_time=None):
|
|
|
|
"""
|
|
|
|
Commits the specified Person to the database, storing the changes
|
|
|
|
as part of the transaction.
|
|
|
|
"""
|
2005-08-11 05:23:24 +05:30
|
|
|
old_data = self._commit_base(
|
|
|
|
person, self.person_map, PERSON_KEY, transaction.person_update,
|
|
|
|
transaction.person_add, transaction, change_time)
|
|
|
|
if old_data:
|
|
|
|
old_person = Person(old_data)
|
|
|
|
if (old_data[2] != person.gender or
|
|
|
|
old_data[3].first_name != person.primary_name.first_name):
|
|
|
|
self.genderStats.uncount_person(old_person)
|
|
|
|
self.genderStats.count_person(person,self)
|
|
|
|
else:
|
|
|
|
self.genderStats.count_person(person,self)
|
2005-08-18 11:28:28 +05:30
|
|
|
|
|
|
|
for attr in person.attribute_list:
|
|
|
|
self.individual_attributes.add(attr.type)
|
|
|
|
|
2004-08-24 09:18:15 +05:30
|
|
|
def commit_media_object(self,obj,transaction,change_time=None):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Commits the specified MediaObject to the database, storing the changes
|
|
|
|
as part of the transaction.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._commit_base(obj, self.media_map, MEDIA_KEY,
|
|
|
|
transaction.media_update, transaction.media_add,
|
|
|
|
transaction, change_time)
|
2005-04-05 05:22:46 +05:30
|
|
|
|
2004-08-24 09:18:15 +05:30
|
|
|
def commit_source(self,source,transaction,change_time=None):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Commits the specified Source to the database, storing the changes
|
|
|
|
as part of the transaction.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._commit_base(source, self.source_map, SOURCE_KEY,
|
|
|
|
transaction.source_update, transaction.source_add,
|
|
|
|
transaction, change_time)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-08-24 09:18:15 +05:30
|
|
|
def commit_place(self,place,transaction,change_time=None):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Commits the specified Place to the database, storing the changes
|
|
|
|
as part of the transaction.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._commit_base(place, self.place_map, PLACE_KEY,
|
|
|
|
transaction.place_update, transaction.place_add,
|
|
|
|
transaction, change_time)
|
|
|
|
|
2005-08-18 11:28:28 +05:30
|
|
|
def commit_personal_event(self,event,transaction,change_time=None):
|
|
|
|
self.individual_event_names.add(event.name)
|
|
|
|
self.commit_event(event,transaction,change_time)
|
|
|
|
|
|
|
|
def commit_family_event(self,event,transaction,change_time=None):
|
|
|
|
self.family_event_names.add(event.name)
|
|
|
|
self.commit_event(event,transaction,change_time)
|
|
|
|
|
2004-08-24 09:18:15 +05:30
|
|
|
def commit_event(self,event,transaction,change_time=None):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Commits the specified Event to the database, storing the changes
|
|
|
|
as part of the transaction.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._commit_base(event, self.event_map, EVENT_KEY,
|
|
|
|
transaction.event_update, transaction.event_add,
|
|
|
|
transaction, change_time)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-08-24 09:18:15 +05:30
|
|
|
def commit_family(self,family,transaction,change_time=None):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Commits the specified Family to the database, storing the changes
|
|
|
|
as part of the transaction.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._commit_base(family, self.family_map, FAMILY_KEY,
|
|
|
|
transaction.family_update, transaction.family_add,
|
|
|
|
transaction, change_time)
|
2005-04-01 11:03:22 +05:30
|
|
|
|
2005-08-18 11:28:28 +05:30
|
|
|
for attr in family.attribute_list:
|
|
|
|
self.family_attributes.add(attr.type)
|
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def commit_repository(self,repository,transaction,change_time=None):
|
|
|
|
"""
|
|
|
|
Commits the specified Repository to the database, storing the changes
|
|
|
|
as part of the transaction.
|
|
|
|
"""
|
|
|
|
self._commit_base(repository, self.repository_map, REPOSITORY_KEY,
|
|
|
|
transaction.repository_update, transaction.repository_add,
|
|
|
|
transaction, change_time)
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def find_next_person_gramps_id(self):
|
|
|
|
"""
|
|
|
|
Returns the next available GRAMPS' ID for a Person object based
|
|
|
|
off the person ID prefix.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
index = self.iprefix % self.pmap_index
|
|
|
|
while self.id_trans.get(str(index)):
|
|
|
|
self.pmap_index += 1
|
|
|
|
index = self.iprefix % self.pmap_index
|
|
|
|
self.pmap_index += 1
|
|
|
|
return index
|
|
|
|
|
2004-08-11 09:12:38 +05:30
|
|
|
def find_next_place_gramps_id(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the next available GRAMPS' ID for a Place object based
|
|
|
|
off the person ID prefix.
|
|
|
|
"""
|
2004-08-11 09:12:38 +05:30
|
|
|
index = self.pprefix % self.lmap_index
|
2004-08-24 09:18:15 +05:30
|
|
|
while self.pid_trans.get(str(index)):
|
2004-08-11 09:12:38 +05:30
|
|
|
self.lmap_index += 1
|
|
|
|
index = self.pprefix % self.lmap_index
|
|
|
|
self.lmap_index += 1
|
|
|
|
return index
|
|
|
|
|
|
|
|
def find_next_event_gramps_id(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the next available GRAMPS' ID for a Event object based
|
|
|
|
off the person ID prefix.
|
|
|
|
"""
|
2004-08-11 09:12:38 +05:30
|
|
|
index = self.eprefix % self.emap_index
|
2005-06-08 10:10:33 +05:30
|
|
|
while self.eid_trans.get(str(index)):
|
|
|
|
self.emap_index += 1
|
|
|
|
index = self.eprefix % self.emap_index
|
2004-08-11 09:12:38 +05:30
|
|
|
self.emap_index += 1
|
|
|
|
return index
|
|
|
|
|
|
|
|
def find_next_object_gramps_id(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the next available GRAMPS' ID for a MediaObject object based
|
|
|
|
off the person ID prefix.
|
|
|
|
"""
|
2004-08-11 09:12:38 +05:30
|
|
|
index = self.oprefix % self.omap_index
|
2004-08-24 09:18:15 +05:30
|
|
|
while self.oid_trans.get(str(index)):
|
2004-08-11 09:12:38 +05:30
|
|
|
self.omap_index += 1
|
|
|
|
index = self.oprefix % self.omap_index
|
|
|
|
self.omap_index += 1
|
|
|
|
return index
|
|
|
|
|
|
|
|
def find_next_source_gramps_id(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the next available GRAMPS' ID for a Source object based
|
|
|
|
off the person ID prefix.
|
|
|
|
"""
|
2004-08-11 09:12:38 +05:30
|
|
|
index = self.sprefix % self.smap_index
|
2004-08-24 09:18:15 +05:30
|
|
|
while self.sid_trans.get(str(index)):
|
2004-08-11 09:12:38 +05:30
|
|
|
self.smap_index += 1
|
|
|
|
index = self.sprefix % self.smap_index
|
2004-08-24 09:18:15 +05:30
|
|
|
self.smap_index += 1
|
2004-08-11 09:12:38 +05:30
|
|
|
return index
|
|
|
|
|
|
|
|
def find_next_family_gramps_id(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the next available GRAMPS' ID for a Family object based
|
|
|
|
off the person ID prefix.
|
|
|
|
"""
|
2004-08-11 09:12:38 +05:30
|
|
|
index = self.fprefix % self.fmap_index
|
2004-08-24 09:18:15 +05:30
|
|
|
while self.fid_trans.get(str(index)):
|
2004-08-11 09:12:38 +05:30
|
|
|
self.fmap_index += 1
|
|
|
|
index = self.fprefix % self.fmap_index
|
|
|
|
self.fmap_index += 1
|
|
|
|
return index
|
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def find_next_repository_gramps_id(self):
|
|
|
|
"""
|
|
|
|
Returns the next available GRAMPS' ID for a Respository object based
|
|
|
|
off the repository ID prefix.
|
|
|
|
"""
|
|
|
|
index = self.rprefix % self.rmap_index
|
|
|
|
while self.rid_trans.get(str(index)):
|
|
|
|
self.rmap_index += 1
|
|
|
|
index = self.rprefix % self.rmap_index
|
|
|
|
self.rmap_index += 1
|
|
|
|
return index
|
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def _get_from_handle(self, handle, class_type, data_map):
|
2005-09-16 18:48:52 +05:30
|
|
|
if not data_map:
|
|
|
|
return
|
2005-04-18 04:04:56 +05:30
|
|
|
data = data_map.get(str(handle))
|
2004-08-11 09:12:38 +05:30
|
|
|
if data:
|
2005-04-18 04:04:56 +05:30
|
|
|
newobj = class_type()
|
|
|
|
newobj.unserialize(data)
|
|
|
|
return newobj
|
2004-08-11 09:12:38 +05:30
|
|
|
return None
|
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def get_person_from_handle(self,handle):
|
|
|
|
"""
|
|
|
|
Finds a Person in the database from the passed gramps' ID.
|
|
|
|
If no such Person exists, None is returned.
|
|
|
|
"""
|
|
|
|
return self._get_from_handle(handle,Person,self.person_map)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def get_source_from_handle(self,handle):
|
|
|
|
"""
|
|
|
|
Finds a Source in the database from the passed gramps' ID.
|
|
|
|
If no such Source exists, None is returned.
|
|
|
|
"""
|
|
|
|
return self._get_from_handle(handle,Source,self.source_map)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
|
|
|
def get_object_from_handle(self,handle):
|
2005-04-18 04:04:56 +05:30
|
|
|
"""
|
|
|
|
Finds an Object in the database from the passed gramps' ID.
|
|
|
|
If no such Object exists, None is returned.
|
|
|
|
"""
|
|
|
|
return self._get_from_handle(handle,MediaObject,self.media_map)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
|
|
|
def get_place_from_handle(self,handle):
|
2005-04-18 04:04:56 +05:30
|
|
|
"""
|
|
|
|
Finds a Place in the database from the passed gramps' ID.
|
|
|
|
If no such Place exists, None is returned.
|
|
|
|
"""
|
|
|
|
return self._get_from_handle(handle,Place,self.place_map)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
|
|
|
def get_event_from_handle(self,handle):
|
2005-04-18 04:04:56 +05:30
|
|
|
"""
|
|
|
|
Finds a Event in the database from the passed gramps' ID.
|
|
|
|
If no such Event exists, None is returned.
|
|
|
|
"""
|
|
|
|
return self._get_from_handle(handle,Event,self.event_map)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
|
|
|
def get_family_from_handle(self,handle):
|
2005-04-18 04:04:56 +05:30
|
|
|
"""
|
|
|
|
Finds a Family in the database from the passed gramps' ID.
|
|
|
|
If no such Family exists, None is returned.
|
|
|
|
"""
|
|
|
|
return self._get_from_handle(handle,Family,self.family_map)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def get_repository_from_handle(self,handle):
|
|
|
|
"""
|
|
|
|
Finds a Repository in the database from the passed gramps' ID.
|
|
|
|
If no such Repository exists, None is returned.
|
|
|
|
"""
|
|
|
|
return self._get_from_handle(handle,Repository,self.repository_map)
|
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def _find_from_handle(self,handle,transaction,class_type,dmap,add_func):
|
|
|
|
obj = class_type()
|
2005-04-23 21:23:30 +05:30
|
|
|
handle = str(handle)
|
|
|
|
if dmap.get(handle):
|
|
|
|
obj.unserialize(dmap.get(handle))
|
2005-04-18 04:04:56 +05:30
|
|
|
else:
|
2005-04-23 21:23:30 +05:30
|
|
|
obj.set_handle(handle)
|
2005-04-18 04:04:56 +05:30
|
|
|
add_func(obj,transaction)
|
|
|
|
return obj
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-04-23 21:23:30 +05:30
|
|
|
def find_person_from_handle(self,handle,transaction):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Finds a Person in the database from the passed GRAMPS ID.
|
|
|
|
If no such Person exists, a new Person is added to the database.
|
|
|
|
"""
|
2005-04-23 21:23:30 +05:30
|
|
|
return self._find_from_handle(handle,transaction,Person,
|
2005-04-18 04:04:56 +05:30
|
|
|
self.person_map,self.add_person)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-04-23 21:23:30 +05:30
|
|
|
def find_source_from_handle(self,handle,transaction):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Finds a Source in the database from the passed GRAMPS ID.
|
|
|
|
If no such Source exists, a new Source is added to the database.
|
|
|
|
"""
|
2005-04-23 21:23:30 +05:30
|
|
|
return self._find_from_handle(handle,transaction,Source,
|
2005-04-18 04:04:56 +05:30
|
|
|
self.source_map,self.add_source)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-04-23 21:23:30 +05:30
|
|
|
def find_event_from_handle(self,handle,transaction):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2004-08-21 23:43:18 +05:30
|
|
|
Finds a Event in the database from the passed GRAMPS ID.
|
|
|
|
If no such Event exists, a new Event is added to the database.
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2005-04-23 21:23:30 +05:30
|
|
|
return self._find_from_handle(handle,transaction,Event,
|
2005-04-18 04:04:56 +05:30
|
|
|
self.event_map,self.add_event)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-04-23 21:33:24 +05:30
|
|
|
def find_object_from_handle(self,handle,transaction):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Finds an MediaObject in the database from the passed GRAMPS ID.
|
|
|
|
If no such MediaObject exists, a new Object is added to the database."""
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-04-23 21:23:30 +05:30
|
|
|
return self._find_from_handle(handle,transaction,MediaObject,
|
2005-04-18 04:04:56 +05:30
|
|
|
self.media_map,self.add_object)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-04-23 21:33:24 +05:30
|
|
|
def find_place_from_handle(self,handle,transaction):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Finds a Place in the database from the passed GRAMPS ID.
|
|
|
|
If no such Place exists, a new Place is added to the database.
|
|
|
|
"""
|
2005-04-23 21:23:30 +05:30
|
|
|
return self._find_from_handle(handle,transaction,Place,
|
2005-04-18 04:04:56 +05:30
|
|
|
self.place_map,self.add_place)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-04-23 21:23:30 +05:30
|
|
|
def find_family_from_handle(self,handle,transaction):
|
2005-04-18 04:04:56 +05:30
|
|
|
"""
|
|
|
|
Finds a Family in the database from the passed gramps' ID.
|
|
|
|
If no such Family exists, a new Family is added to the database.
|
|
|
|
"""
|
2005-04-23 21:23:30 +05:30
|
|
|
return self._find_from_handle(handle,transaction,Family,
|
2005-04-18 04:04:56 +05:30
|
|
|
self.family_map,self.add_family)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def find_repository_from_handle(self,handle,transaction):
|
|
|
|
"""
|
|
|
|
Finds a Repository in the database from the passed gramps' ID.
|
|
|
|
If no such Repository exists, a new Repository is added to the database.
|
|
|
|
"""
|
|
|
|
return self._find_from_handle(handle,transaction,Repository,
|
|
|
|
self.repository_map,self.add_repository)
|
|
|
|
|
2004-08-20 07:50:06 +05:30
|
|
|
def get_person_from_gramps_id(self,val):
|
|
|
|
"""
|
|
|
|
Finds a Person in the database from the passed GRAMPS ID.
|
|
|
|
If no such Person exists, None is returned.
|
|
|
|
|
|
|
|
Needs to be overridden by the derrived class.
|
|
|
|
"""
|
2004-09-11 04:10:00 +05:30
|
|
|
assert False, "Needs to be overridden in the derived class"
|
2004-08-20 07:50:06 +05:30
|
|
|
|
|
|
|
def get_family_from_gramps_id(self,val):
|
|
|
|
"""
|
|
|
|
Finds a Family in the database from the passed GRAMPS ID.
|
|
|
|
If no such Family exists, None is returned.
|
|
|
|
|
|
|
|
Needs to be overridden by the derrived class.
|
|
|
|
"""
|
2004-09-11 04:10:00 +05:30
|
|
|
assert False, "Needs to be overridden in the derived class"
|
2004-08-20 07:50:06 +05:30
|
|
|
|
2004-08-24 10:39:50 +05:30
|
|
|
def get_place_from_gramps_id(self,val):
|
|
|
|
"""finds a Place in the database from the passed gramps' ID.
|
|
|
|
If no such Place exists, a new Person is added to the database.
|
|
|
|
|
|
|
|
Needs to be overridden by the derrived class.
|
|
|
|
"""
|
2004-09-11 04:10:00 +05:30
|
|
|
assert False, "Needs to be overridden in the derived class"
|
2004-08-24 10:39:50 +05:30
|
|
|
|
|
|
|
def get_source_from_gramps_id(self,val):
|
|
|
|
"""finds a Source in the database from the passed gramps' ID.
|
|
|
|
If no such Source exists, a new Person is added to the database.
|
|
|
|
|
|
|
|
Needs to be overridden by the derrived class.
|
|
|
|
"""
|
2004-09-11 04:10:00 +05:30
|
|
|
assert False, "Needs to be overridden in the derived class"
|
2004-08-24 10:39:50 +05:30
|
|
|
|
|
|
|
def get_object_from_gramps_id(self,val):
|
|
|
|
"""finds a MediaObject in the database from the passed gramps' ID.
|
|
|
|
If no such MediaObject exists, a new Person is added to the database.
|
|
|
|
|
|
|
|
Needs to be overridden by the derrived class.
|
|
|
|
"""
|
2004-09-11 04:10:00 +05:30
|
|
|
assert False, "Needs to be overridden in the derived class"
|
2004-08-24 10:39:50 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def get_repository_from_gramps_id(self,val):
|
|
|
|
"""finds a Repository in the database from the passed gramps' ID.
|
|
|
|
If no such Repository exists, a new Repository is added to the database.
|
|
|
|
|
|
|
|
Needs to be overridden by the derrived class.
|
|
|
|
"""
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
2005-05-24 18:38:06 +05:30
|
|
|
def _add_object(self,obj,transaction,find_next_func,commit_func):
|
|
|
|
if not obj.gramps_id:
|
|
|
|
obj.gramps_id = find_next_func()
|
|
|
|
if not obj.handle:
|
|
|
|
obj.handle = self.create_id()
|
|
|
|
commit_func(obj,transaction)
|
2005-07-09 01:54:54 +05:30
|
|
|
if obj.__class__.__name__ == 'Person':
|
2005-08-06 08:27:37 +05:30
|
|
|
self.genderStats.count_person (obj, self)
|
2005-05-24 18:38:06 +05:30
|
|
|
return obj.handle
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-07-09 01:54:54 +05:30
|
|
|
def add_person(self,person,transaction):
|
|
|
|
"""
|
|
|
|
Adds a Person to the database, assigning internal IDs if they have
|
|
|
|
not already been defined.
|
|
|
|
"""
|
|
|
|
return self._add_object(person,transaction,
|
|
|
|
self.find_next_person_gramps_id,
|
|
|
|
self.commit_person)
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def add_family(self,family,transaction):
|
|
|
|
"""
|
|
|
|
Adds a Family to the database, assigning internal IDs if they have
|
|
|
|
not already been defined.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._add_object(family,transaction,
|
|
|
|
self.find_next_family_gramps_id,
|
|
|
|
self.commit_family)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def add_source(self,source,transaction):
|
|
|
|
"""
|
|
|
|
Adds a Source to the database, assigning internal IDs if they have
|
|
|
|
not already been defined.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._add_object(source,transaction,
|
|
|
|
self.find_next_source_gramps_id,
|
|
|
|
self.commit_source)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def add_event(self,event,transaction):
|
|
|
|
"""
|
|
|
|
Adds an Event to the database, assigning internal IDs if they have
|
|
|
|
not already been defined.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._add_object(event,transaction,
|
|
|
|
self.find_next_event_gramps_id,
|
|
|
|
self.commit_event)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def add_place(self,place,transaction):
|
|
|
|
"""
|
|
|
|
Adds a Place to the database, assigning internal IDs if they have
|
|
|
|
not already been defined.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._add_object(place,transaction,
|
|
|
|
self.find_next_place_gramps_id,
|
|
|
|
self.commit_place)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def add_object(self,obj,transaction):
|
|
|
|
"""
|
|
|
|
Adds a MediaObject to the database, assigning internal IDs if they have
|
|
|
|
not already been defined.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._add_object(obj,transaction,
|
|
|
|
self.find_next_object_gramps_id,
|
|
|
|
self.commit_media_object)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def add_repository(self,obj,transaction):
|
|
|
|
"""
|
|
|
|
Adds a Repository to the database, assigning internal IDs if they have
|
|
|
|
not already been defined.
|
|
|
|
"""
|
|
|
|
return self._add_object(obj,transaction,
|
|
|
|
self.find_next_repository_gramps_id,
|
|
|
|
self.commit_repository)
|
|
|
|
|
2004-10-01 00:02:56 +05:30
|
|
|
def get_name_group_mapping(self,name):
|
|
|
|
"""
|
|
|
|
Returns the default grouping name for a surname
|
|
|
|
"""
|
|
|
|
return self.name_group.get(str(name),name)
|
|
|
|
|
|
|
|
def get_name_group_keys(self):
|
|
|
|
"""
|
|
|
|
Returns the defined names that have been assigned to a default grouping
|
|
|
|
"""
|
|
|
|
return [unicode(k) for k in self.name_group.keys()]
|
|
|
|
|
|
|
|
def set_name_group_mapping(self,name,group):
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
Sets the default grouping name for a surname. Needs to be overridden
|
|
|
|
in the derived class.
|
2004-10-01 00:02:56 +05:30
|
|
|
"""
|
|
|
|
assert False, "Needs to be overridden in the derived class"
|
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
def get_number_of_people(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the number of people currently in the databse.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
return len(self.person_map)
|
|
|
|
|
2005-08-18 11:28:28 +05:30
|
|
|
def get_number_of_families(self):
|
|
|
|
"""
|
|
|
|
Returns the number of families currently in the databse.
|
|
|
|
"""
|
|
|
|
return len(self.family_map)
|
|
|
|
|
|
|
|
def get_number_of_events(self):
|
|
|
|
"""
|
|
|
|
Returns the number of events currently in the databse.
|
|
|
|
"""
|
|
|
|
return len(self.event_map)
|
|
|
|
|
|
|
|
def get_number_of_places(self):
|
|
|
|
"""
|
|
|
|
Returns the number of places currently in the databse.
|
|
|
|
"""
|
|
|
|
return len(self.place_map)
|
|
|
|
|
|
|
|
def get_number_of_sources(self):
|
|
|
|
"""
|
|
|
|
Returns the number of sources currently in the databse.
|
|
|
|
"""
|
|
|
|
return len(self.source_map)
|
|
|
|
|
|
|
|
def get_number_of_media_objects(self):
|
|
|
|
"""
|
|
|
|
Returns the number of media objects currently in the databse.
|
|
|
|
"""
|
|
|
|
return len(self.media_map)
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def get_person_handles(self,sort_handles=True):
|
|
|
|
"""
|
|
|
|
Returns a list of database handles, one handle for each Person in
|
|
|
|
the database. If sort_handles is True, the list is sorted by surnames
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
if self.person_map:
|
2004-08-13 10:04:07 +05:30
|
|
|
if sort_handles:
|
2004-12-20 04:25:41 +05:30
|
|
|
slist = []
|
|
|
|
cursor = self.get_person_cursor()
|
|
|
|
data = cursor.first()
|
|
|
|
while data:
|
|
|
|
slist.append((data[1][3].sname,data[0]))
|
|
|
|
data = cursor.next()
|
|
|
|
cursor.close()
|
|
|
|
slist.sort()
|
|
|
|
return map(lambda x: x[1], slist)
|
|
|
|
else:
|
|
|
|
return self.person_map.keys()
|
2004-08-11 09:12:38 +05:30
|
|
|
return []
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def get_place_handles(self,sort_handles=True):
|
|
|
|
"""
|
|
|
|
Returns a list of database handles, one handle for each Place in
|
|
|
|
the database. If sort_handles is True, the list is sorted by
|
|
|
|
Place title.
|
|
|
|
"""
|
|
|
|
if self.place_map:
|
|
|
|
if sort_handles:
|
2004-12-20 04:25:41 +05:30
|
|
|
slist = []
|
|
|
|
cursor = self.get_place_cursor()
|
|
|
|
data = cursor.first()
|
|
|
|
while data:
|
|
|
|
slist.append((data[1][2],data[0]))
|
|
|
|
data = cursor.next()
|
|
|
|
cursor.close()
|
|
|
|
slist.sort()
|
|
|
|
val = map(lambda x: x[1], slist)
|
|
|
|
return val
|
|
|
|
else:
|
|
|
|
return self.place_map.keys()
|
2004-08-11 09:12:38 +05:30
|
|
|
return []
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def get_source_handles(self,sort_handles=True):
|
|
|
|
"""
|
|
|
|
Returns a list of database handles, one handle for each Source in
|
|
|
|
the database. If sort_handles is True, the list is sorted by
|
|
|
|
Source title.
|
|
|
|
"""
|
|
|
|
if self.source_map:
|
|
|
|
handle_list = self.source_map.keys()
|
|
|
|
if sort_handles:
|
|
|
|
handle_list.sort(self._sortbysource)
|
|
|
|
return handle_list
|
|
|
|
return []
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def get_media_object_handles(self,sort_handles=True):
|
|
|
|
"""
|
|
|
|
Returns a list of database handles, one handle for each MediaObject in
|
|
|
|
the database. If sort_handles is True, the list is sorted by title.
|
|
|
|
"""
|
|
|
|
if self.media_map:
|
|
|
|
handle_list = self.media_map.keys()
|
|
|
|
if sort_handles:
|
|
|
|
handle_list.sort(self._sortbymedia)
|
|
|
|
return handle_list
|
2004-08-11 09:12:38 +05:30
|
|
|
return []
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def get_event_handles(self):
|
|
|
|
"""
|
|
|
|
Returns a list of database handles, one handle for each Event in
|
|
|
|
the database.
|
|
|
|
"""
|
|
|
|
if self.event_map:
|
|
|
|
return self.event_map.keys()
|
|
|
|
return []
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def get_family_handles(self):
|
|
|
|
"""
|
|
|
|
Returns a list of database handles, one handle for each Family in
|
|
|
|
the database.
|
|
|
|
"""
|
|
|
|
if self.family_map:
|
|
|
|
return self.family_map.keys()
|
|
|
|
return []
|
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def get_repository_handles(self):
|
|
|
|
"""
|
|
|
|
Returns a list of database handles, one handle for each Repository in
|
|
|
|
the database.
|
|
|
|
"""
|
|
|
|
if self.repository_map:
|
|
|
|
return self.repository_map.keys()
|
|
|
|
return []
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def set_person_id_prefix(self,val):
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
Sets the naming template for GRAMPS Person ID values. The string is
|
|
|
|
expected to be in the form of a simple text string, or in a format
|
|
|
|
that contains a C/Python style format string using %d, such as I%d
|
|
|
|
or I%04d.
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
if val:
|
|
|
|
if _id_reg.search(val):
|
|
|
|
self.iprefix = val
|
|
|
|
else:
|
|
|
|
self.iprefix = val + "%d"
|
|
|
|
else:
|
|
|
|
self.iprefix = "I%04d"
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def set_source_id_prefix(self,val):
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
Sets the naming template for GRAMPS Source ID values. The string is
|
|
|
|
expected to be in the form of a simple text string, or in a format
|
|
|
|
that contains a C/Python style format string using %d, such as S%d
|
|
|
|
or S%04d.
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
if val:
|
|
|
|
if _id_reg.search(val):
|
|
|
|
self.sprefix = val
|
|
|
|
else:
|
|
|
|
self.sprefix = val + "%d"
|
|
|
|
else:
|
|
|
|
self.sprefix = "S%04d"
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def set_object_id_prefix(self,val):
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
Sets the naming template for GRAMPS MediaObject ID values. The string
|
|
|
|
is expected to be in the form of a simple text string, or in a format
|
|
|
|
that contains a C/Python style format string using %d, such as O%d
|
|
|
|
or O%04d.
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
if val:
|
|
|
|
if _id_reg.search(val):
|
|
|
|
self.oprefix = val
|
|
|
|
else:
|
|
|
|
self.oprefix = val + "%d"
|
|
|
|
else:
|
|
|
|
self.oprefix = "O%04d"
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def set_place_id_prefix(self,val):
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
Sets the naming template for GRAMPS Place ID values. The string is
|
|
|
|
expected to be in the form of a simple text string, or in a format
|
|
|
|
that contains a C/Python style format string using %d, such as P%d
|
|
|
|
or P%04d.
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
if val:
|
|
|
|
if _id_reg.search(val):
|
|
|
|
self.pprefix = val
|
|
|
|
else:
|
|
|
|
self.pprefix = val + "%d"
|
|
|
|
else:
|
|
|
|
self.pprefix = "P%04d"
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def set_family_id_prefix(self,val):
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
Sets the naming template for GRAMPS Family ID values. The string is
|
|
|
|
expected to be in the form of a simple text string, or in a format
|
|
|
|
that contains a C/Python style format string using %d, such as F%d
|
|
|
|
or F%04d.
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
if val:
|
|
|
|
if _id_reg.search(val):
|
|
|
|
self.fprefix = val
|
|
|
|
else:
|
|
|
|
self.fprefix = val + "%d"
|
|
|
|
else:
|
|
|
|
self.fprefix = "F%04d"
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def set_event_id_prefix(self,val):
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
Sets the naming template for GRAMPS Event ID values. The string is
|
|
|
|
expected to be in the form of a simple text string, or in a format
|
|
|
|
that contains a C/Python style format string using %d, such as E%d
|
|
|
|
or E%04d.
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
if val:
|
|
|
|
if _id_reg.search(val):
|
|
|
|
self.eprefix = val
|
|
|
|
else:
|
|
|
|
self.eprefix = val + "%d"
|
|
|
|
else:
|
|
|
|
self.eprefix = "E%04d"
|
2005-05-27 23:13:04 +05:30
|
|
|
|
|
|
|
def set_repository_id_prefix(self,val):
|
|
|
|
"""
|
|
|
|
Sets the naming template for GRAMPS Repository ID values. The string is
|
|
|
|
expected to be in the form of a simple text string, or in a format
|
|
|
|
that contains a C/Python style format string using %d, such as E%d
|
|
|
|
or E%04d.
|
|
|
|
"""
|
|
|
|
if val:
|
|
|
|
if _id_reg.search(val):
|
|
|
|
self.rprefix = val
|
|
|
|
else:
|
|
|
|
self.rprefix = val + "%d"
|
|
|
|
else:
|
|
|
|
self.rprefix = "R%04d"
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def transaction_begin(self,msg=""):
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
Creates a new Transaction tied to the current UNDO database. The
|
|
|
|
transaction has no effect until it is committed using the
|
|
|
|
transaction_commit function of the this database object.
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
return Transaction(msg,self.undodb)
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def transaction_commit(self,transaction,msg):
|
|
|
|
"""
|
|
|
|
Commits the transaction to the assocated UNDO database.
|
|
|
|
"""
|
2005-02-17 04:19:54 +05:30
|
|
|
if not len(transaction) or self.readonly:
|
2004-08-01 09:51:31 +05:30
|
|
|
return
|
|
|
|
transaction.set_description(msg)
|
|
|
|
self.undoindex += 1
|
|
|
|
if self.undoindex == _UNDO_SIZE:
|
|
|
|
self.translist = transaction[0:-1] + [ transaction ]
|
|
|
|
else:
|
|
|
|
self.translist[self.undoindex] = transaction
|
2005-04-18 04:04:56 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
person_add = self._do_commit(transaction.person_add,self.person_map)
|
|
|
|
family_add = self._do_commit(transaction.family_add,self.family_map)
|
|
|
|
source_add = self._do_commit(transaction.source_add,self.source_map)
|
|
|
|
place_add = self._do_commit(transaction.place_add,self.place_map)
|
|
|
|
media_add = self._do_commit(transaction.media_add,self.media_map)
|
|
|
|
event_add = self._do_commit(transaction.event_add,self.event_map)
|
|
|
|
repository_add = self._do_commit(transaction.repository_add,self.repository_map)
|
|
|
|
|
|
|
|
person_upd = self._do_commit(transaction.person_update,self.person_map)
|
|
|
|
family_upd = self._do_commit(transaction.family_update,self.family_map)
|
|
|
|
source_upd = self._do_commit(transaction.source_update,self.source_map)
|
|
|
|
place_upd = self._do_commit(transaction.place_update,self.place_map)
|
|
|
|
media_upd = self._do_commit(transaction.media_update,self.media_map)
|
|
|
|
event_upd = self._do_commit(transaction.event_update,self.event_map)
|
|
|
|
repository_upd = self._do_commit(transaction.repository_update,self.repository_map)
|
2005-04-18 04:04:56 +05:30
|
|
|
|
|
|
|
self._do_emit('person', person_add, person_upd, transaction.person_del)
|
|
|
|
self._do_emit('family', family_add, family_upd, transaction.family_del)
|
|
|
|
self._do_emit('event', event_add, event_upd, transaction.event_del)
|
|
|
|
self._do_emit('source', source_add, source_upd, transaction.source_del)
|
|
|
|
self._do_emit('place', place_add, place_upd, transaction.place_del)
|
|
|
|
self._do_emit('media', media_add, media_upd, transaction.media_del)
|
2005-05-27 23:13:04 +05:30
|
|
|
self._do_emit('repository', repository_add, repository_upd, transaction.repository_del)
|
2005-04-18 04:04:56 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
self._do_del(transaction.person_del, self._del_person)
|
|
|
|
self._do_del(transaction.family_del, self._del_family)
|
|
|
|
self._do_del(transaction.place_del, self._del_place)
|
|
|
|
self._do_del(transaction.source_del, self._del_source)
|
|
|
|
self._do_del(transaction.event_del, self._del_event)
|
|
|
|
self._do_del(transaction.media_del, self._del_media)
|
|
|
|
self._do_del(transaction.repository_del, self._del_repository)
|
2005-04-18 04:04:56 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
if self.undo_callback:
|
|
|
|
self.undo_callback(_("_Undo %s") % transaction.get_description())
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def _do_emit(self, objtype, add_list, upd_list, del_list):
|
|
|
|
if add_list:
|
|
|
|
self.emit(objtype + '-add',(add_list,))
|
|
|
|
if upd_list:
|
|
|
|
self.emit(objtype + '-update',(upd_list,))
|
|
|
|
if del_list:
|
|
|
|
self.emit(objtype + '-delete',(del_list,))
|
|
|
|
|
|
|
|
def _do_del(self,del_list,func):
|
|
|
|
for handle in del_list:
|
|
|
|
func(handle)
|
|
|
|
return del_list
|
|
|
|
|
|
|
|
def _do_commit(self,add_list,db_map):
|
|
|
|
retlist = []
|
|
|
|
for (handle,data) in add_list:
|
|
|
|
db_map[handle] = data
|
|
|
|
retlist.append(str(handle))
|
|
|
|
return retlist
|
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
def undo(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Accesses the last committed transaction, and reverts the data to
|
|
|
|
the state before the transaction was committed.
|
|
|
|
"""
|
2005-02-17 04:19:54 +05:30
|
|
|
if self.undoindex == -1 or self.readonly:
|
2004-10-13 09:21:27 +05:30
|
|
|
return False
|
2004-08-01 09:51:31 +05:30
|
|
|
transaction = self.translist[self.undoindex]
|
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
mapbase = (self.person_map, self.family_map, self.source_map,
|
|
|
|
self.event_map, self.media_map, self.place_map)
|
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
self.undoindex -= 1
|
|
|
|
subitems = transaction.get_recnos()
|
|
|
|
subitems.reverse()
|
|
|
|
for record_id in subitems:
|
|
|
|
(key, handle, data) = transaction.get_record(record_id)
|
2005-04-18 04:04:56 +05:30
|
|
|
self.undo_data(data,handle,mapbase[key],_sigbase[key])
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
if self.undo_callback:
|
2004-08-01 09:51:31 +05:30
|
|
|
if self.undoindex == -1:
|
2004-08-13 10:04:07 +05:30
|
|
|
self.undo_callback(None)
|
2004-08-01 09:51:31 +05:30
|
|
|
else:
|
|
|
|
transaction = self.translist[self.undoindex]
|
2004-08-13 10:04:07 +05:30
|
|
|
self.undo_callback(_("_Undo %s") % transaction.get_description())
|
2004-10-13 09:21:27 +05:30
|
|
|
return True
|
2005-04-09 06:01:39 +05:30
|
|
|
|
|
|
|
def undo_data(self,data,handle,db_map,signal_root):
|
|
|
|
if data == None:
|
|
|
|
self.emit(signal_root + '-delete',([handle],))
|
|
|
|
del db_map[handle]
|
|
|
|
else:
|
|
|
|
if db_map.has_key(handle):
|
|
|
|
signal = signal_root + '-update'
|
|
|
|
else:
|
|
|
|
signal = signal_root + '-add'
|
|
|
|
db_map[handle] = data
|
|
|
|
self.emit(signal,([handle],))
|
2004-10-13 09:21:27 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def set_undo_callback(self,callback):
|
|
|
|
"""
|
|
|
|
Defines the callback function that is called whenever an undo operation
|
|
|
|
is executed. The callback function recieves a single argument that is a
|
|
|
|
text string that defines the operation.
|
|
|
|
"""
|
|
|
|
self.undo_callback = callback
|
|
|
|
|
|
|
|
def set_redo_callback(self,callback):
|
|
|
|
"""
|
|
|
|
Defines the callback function that is called whenever an redo operation
|
|
|
|
is executed. The callback function recieves a single argument that is a
|
|
|
|
text string that defines the operation.
|
|
|
|
"""
|
|
|
|
self.redo_callback = callback
|
|
|
|
|
|
|
|
def get_surname_list(self):
|
|
|
|
"""
|
|
|
|
Returns the list of surnames contained within the database.
|
|
|
|
The function must be overridden in the derived class.
|
|
|
|
"""
|
2004-09-11 04:10:00 +05:30
|
|
|
assert False, "Needs to be overridden in the derived class"
|
2004-08-13 10:04:07 +05:30
|
|
|
|
|
|
|
def get_person_event_type_list(self):
|
|
|
|
"""
|
|
|
|
Returns the list of personal event types contained within the
|
|
|
|
database. The function must be overridden in the derived class.
|
|
|
|
"""
|
2005-08-18 11:28:28 +05:30
|
|
|
return list(self.individual_event_names)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def get_bookmarks(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""returns the list of Person handles in the bookmarks"""
|
2004-08-01 09:51:31 +05:30
|
|
|
return self.bookmarks
|
|
|
|
|
|
|
|
def set_researcher(self,owner):
|
|
|
|
"""sets the information about the owner of the database"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self.owner.set(owner.get_name(), owner.get_address(),
|
|
|
|
owner.get_city(), owner.get_state(),
|
|
|
|
owner.get_country(), owner.get_postal_code(),
|
|
|
|
owner.get_phone(), owner.get_email())
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def get_researcher(self):
|
|
|
|
"""returns the Researcher instance, providing information about
|
|
|
|
the owner of the database"""
|
|
|
|
return self.owner
|
|
|
|
|
|
|
|
def set_default_person_handle(self,handle):
|
|
|
|
"""sets the default Person to the passed instance"""
|
2005-02-17 04:19:54 +05:30
|
|
|
if not self.readonly:
|
2005-04-18 04:04:56 +05:30
|
|
|
self.metadata['default'] = str(handle)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def get_default_person(self):
|
|
|
|
"""returns the default Person of the database"""
|
2005-04-18 04:04:56 +05:30
|
|
|
if self.metadata:
|
2005-04-19 09:50:17 +05:30
|
|
|
key = self.metadata.get('default')
|
|
|
|
data = self.person_map.get(key)
|
2004-12-03 07:19:09 +05:30
|
|
|
if data:
|
2005-04-18 04:04:56 +05:30
|
|
|
person = Person()
|
2004-12-03 07:19:09 +05:30
|
|
|
person.unserialize(data)
|
|
|
|
return person
|
2005-04-18 04:04:56 +05:30
|
|
|
elif not self.readonly:
|
2004-12-03 07:19:09 +05:30
|
|
|
self.metadata['default'] = None
|
|
|
|
return None
|
2004-08-01 09:51:31 +05:30
|
|
|
return None
|
|
|
|
|
|
|
|
def get_save_path(self):
|
|
|
|
"""returns the save path of the file, or "" if one does not exist"""
|
|
|
|
return self.path
|
|
|
|
|
|
|
|
def set_save_path(self,path):
|
|
|
|
"""sets the save path for the database"""
|
|
|
|
self.path = path
|
|
|
|
|
|
|
|
def get_person_event_types(self):
|
|
|
|
"""returns a list of all Event types assocated with Person
|
|
|
|
instances in the database"""
|
2005-08-18 11:28:28 +05:30
|
|
|
return list(self.individual_event_names)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def get_person_attribute_types(self):
|
|
|
|
"""returns a list of all Attribute types assocated with Person
|
|
|
|
instances in the database"""
|
2005-08-18 11:28:28 +05:30
|
|
|
return list(self.individual_attributes)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def get_family_attribute_types(self):
|
|
|
|
"""returns a list of all Attribute types assocated with Family
|
|
|
|
instances in the database"""
|
2005-08-18 11:28:28 +05:30
|
|
|
return list(self.family_attributes)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def get_family_event_types(self):
|
|
|
|
"""returns a list of all Event types assocated with Family
|
|
|
|
instances in the database"""
|
2005-08-18 11:28:28 +05:30
|
|
|
return list(self.family_event_names)
|
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
def get_media_attribute_types(self):
|
|
|
|
"""returns a list of all Attribute types assocated with Media
|
|
|
|
instances in the database"""
|
|
|
|
return []
|
|
|
|
|
|
|
|
def get_family_relation_types(self):
|
|
|
|
"""returns a list of all relationship types assocated with Family
|
|
|
|
instances in the database"""
|
|
|
|
return []
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def remove_person(self,handle,transaction):
|
|
|
|
"""
|
|
|
|
Removes the Person specified by the database handle from the
|
|
|
|
database, preserving the change in the passed transaction. This
|
|
|
|
method must be overridden in the derived class.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
if not self.readonly:
|
|
|
|
person = self.get_person_from_handle(handle)
|
|
|
|
self.genderStats.uncount_person (person)
|
|
|
|
if not transaction.batch:
|
|
|
|
transaction.add(PERSON_KEY,handle,person.serialize())
|
|
|
|
transaction.person_del.append(str(handle))
|
|
|
|
|
|
|
|
def _do_remove_object(self,handle,trans,dmap,key,del_list):
|
|
|
|
if not self.readonly:
|
|
|
|
handle = str(handle)
|
|
|
|
if not trans.batch:
|
|
|
|
old_data = dmap.get(handle)
|
2005-05-27 23:13:04 +05:30
|
|
|
trans.add(key,handle,old_data)
|
2005-04-18 04:04:56 +05:30
|
|
|
del_list.append(handle)
|
2004-08-13 10:04:07 +05:30
|
|
|
|
|
|
|
def remove_source(self,handle,transaction):
|
|
|
|
"""
|
|
|
|
Removes the Source specified by the database handle from the
|
|
|
|
database, preserving the change in the passed transaction. This
|
|
|
|
method must be overridden in the derived class.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._do_remove_object(handle,transaction,self.source_map,
|
|
|
|
SOURCE_KEY, transaction.source_del)
|
2004-08-13 10:04:07 +05:30
|
|
|
|
|
|
|
def remove_event(self,handle,transaction):
|
|
|
|
"""
|
|
|
|
Removes the Event specified by the database handle from the
|
|
|
|
database, preserving the change in the passed transaction. This
|
|
|
|
method must be overridden in the derived class.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._do_remove_object(handle,transaction,self.event_map,
|
|
|
|
EVENT_KEY, transaction.event_del)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def remove_object(self,handle,transaction):
|
|
|
|
"""
|
|
|
|
Removes the MediaObjectPerson specified by the database handle from the
|
|
|
|
database, preserving the change in the passed transaction. This
|
|
|
|
method must be overridden in the derived class.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._do_remove_object(handle,transaction,self.media_map,
|
|
|
|
MEDIA_KEY, transaction.media_del)
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def remove_place(self,handle,transaction):
|
|
|
|
"""
|
|
|
|
Removes the Place specified by the database handle from the
|
|
|
|
database, preserving the change in the passed transaction. This
|
|
|
|
method must be overridden in the derived class.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._do_remove_object(handle,transaction,self.place_map,
|
|
|
|
PLACE_KEY, transaction.place_del)
|
2004-08-13 10:04:07 +05:30
|
|
|
|
2004-12-03 07:19:09 +05:30
|
|
|
def remove_family(self,handle,transaction):
|
|
|
|
"""
|
|
|
|
Removes the Family specified by the database handle from the
|
|
|
|
database, preserving the change in the passed transaction. This
|
|
|
|
method must be overridden in the derived class.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._do_remove_object(handle,transaction,self.family_map,
|
|
|
|
FAMILY_KEY, transaction.family_del)
|
2004-12-03 07:19:09 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def remove_repository(self,handle,transaction):
|
|
|
|
"""
|
|
|
|
Removes the Repository specified by the database handle from the
|
|
|
|
database, preserving the change in the passed transaction. This
|
|
|
|
method must be overridden in the derived class.
|
|
|
|
"""
|
|
|
|
self._do_remove_object(handle,transaction,self.repository_map,
|
|
|
|
REPOSITORY_KEY, transaction.repository_del)
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def has_person_handle(self,handle):
|
|
|
|
"""
|
|
|
|
returns True if the handle exists in the current Person database.
|
|
|
|
"""
|
|
|
|
return self.person_map.has_key(str(handle))
|
|
|
|
|
|
|
|
def has_family_handle(self,handle):
|
|
|
|
"""
|
|
|
|
returns True if the handle exists in the current Family database.
|
|
|
|
"""
|
|
|
|
return self.family_map.has_key(str(handle))
|
2004-08-11 09:12:38 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def has_object_handle(self,handle):
|
|
|
|
"""
|
|
|
|
returns True if the handle exists in the current MediaObjectdatabase.
|
|
|
|
"""
|
|
|
|
return self.media_map.has_key(str(handle)) != None
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def has_repository_handle(self,handle):
|
|
|
|
"""
|
|
|
|
returns True if the handle exists in the current Repository database.
|
|
|
|
"""
|
|
|
|
return self.repository_map.has_key(str(handle)) != False
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def _sortbyname(self,f,s):
|
2004-09-29 07:36:46 +05:30
|
|
|
n1 = self.person_map.get(str(f))[3].sname
|
|
|
|
n2 = self.person_map.get(str(s))[3].sname
|
2004-08-27 03:24:14 +05:30
|
|
|
return locale.strcoll(n1,n2)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def _sortbyplace(self,f,s):
|
2004-10-09 09:24:42 +05:30
|
|
|
return locale.strcoll(self.place_map.get(str(f))[2],
|
|
|
|
self.place_map.get(str(s))[2])
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def _sortbysource(self,f,s):
|
2004-11-24 23:31:49 +05:30
|
|
|
fp = unicode(self.source_map[str(f)][2])
|
|
|
|
sp = unicode(self.source_map[str(s)][2])
|
2004-08-27 03:24:14 +05:30
|
|
|
return locale.strcoll(fp,sp)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def _sortbymedia(self,f,s):
|
2004-10-09 09:24:42 +05:30
|
|
|
fp = self.media_map[str(f)][4]
|
|
|
|
sp = self.media_map[str(s)][4]
|
2004-08-27 03:24:14 +05:30
|
|
|
return locale.strcoll(fp,sp)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def _set_column_order(self,col_list,name):
|
|
|
|
if self.metadata and not self.readonly:
|
|
|
|
self.metadata[name] = col_list
|
|
|
|
|
|
|
|
def set_person_column_order(self,col_list):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Stores the Person display common information in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._set_column_order(col_list,PERSON_COL_KEY)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def set_child_column_order(self,col_list):
|
2004-11-19 01:51:06 +05:30
|
|
|
"""
|
|
|
|
Stores the Person display common information in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._set_column_order(col_list,CHILD_COL_KEY)
|
2004-11-19 01:51:06 +05:30
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def set_place_column_order(self,col_list):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Stores the Place display common information in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._set_column_order(col_list,PLACE_COL_KEY)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def set_source_column_order(self,col_list):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Stores the Source display common information in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._set_column_order(col_list,SOURCE_COL_KEY)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-06-08 21:05:31 +05:30
|
|
|
def set_media_column_order(self,col_list):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Stores the Media display common information in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-04-18 04:04:56 +05:30
|
|
|
self._set_column_order(col_list,MEDIA_COL_KEY)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-06-08 21:05:31 +05:30
|
|
|
def set_event_column_order(self,col_list):
|
|
|
|
"""
|
|
|
|
Stores the Event display common information in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
|
|
|
self._set_column_order(col_list,EVENT_COL_KEY)
|
|
|
|
|
|
|
|
def set_repository_column_order(self,col_list):
|
2005-05-27 23:13:04 +05:30
|
|
|
"""
|
|
|
|
Stores the Repository display common information in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
|
|
|
self._set_column_order(col_list,REPOSITORY_COL_KEY)
|
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def _get_column_order(self,name,default):
|
2004-08-01 09:51:31 +05:30
|
|
|
if self.metadata == None:
|
|
|
|
return default
|
|
|
|
else:
|
2005-04-18 04:04:56 +05:30
|
|
|
cols = self.metadata.get(name,default)
|
2004-08-01 09:51:31 +05:30
|
|
|
if len(cols) != len(default):
|
|
|
|
return cols + default[len(cols):]
|
|
|
|
else:
|
|
|
|
return cols
|
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
def get_person_column_order(self):
|
|
|
|
"""
|
|
|
|
Returns the Person display common information stored in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
|
|
|
default = [(1,1),(1,2),(1,3),(0,4),(1,5),(0,6),(0,7),(0,8),(0,9,)]
|
|
|
|
return self._get_column_order(PERSON_COL_KEY,default)
|
|
|
|
|
2004-11-19 01:51:06 +05:30
|
|
|
def get_child_column_order(self):
|
|
|
|
"""
|
|
|
|
Returns the Person display common information stored in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
|
|
|
default = [(1,0),(1,1),(1,2),(1,3),(1,4),(1,5),(0,6),(0,7)]
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._get_column_order(CHILD_COL_KEY,default)
|
2004-11-19 01:51:06 +05:30
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
def get_place_column_order(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the Place display common information stored in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-01-12 19:11:54 +05:30
|
|
|
default = [(1,1),(1,2),(0,3),(0,4),(1,5),(0,6),(1,7),(0,8),(0,9),(0,10)]
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._get_column_order(PLACE_COL_KEY,default)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def get_source_column_order(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the Source display common information stored in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2004-11-27 05:01:50 +05:30
|
|
|
default = [(1,1),(1,2),(0,3),(1,4),(0,5)]
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._get_column_order(SOURCE_COL_KEY,default)
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def get_media_column_order(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the MediaObject display common information stored in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-06-08 21:05:31 +05:30
|
|
|
default = [(1,1),(1,2),(1,3),(1,5),(0,4)]
|
2005-04-18 04:04:56 +05:30
|
|
|
return self._get_column_order(MEDIA_COL_KEY,default)
|
2004-10-23 09:26:48 +05:30
|
|
|
|
2005-06-07 10:38:50 +05:30
|
|
|
def get_event_column_order(self):
|
|
|
|
"""
|
|
|
|
Returns the Event display common information stored in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-08-12 08:05:27 +05:30
|
|
|
default = [(1,1),(1,2),(1,3),(1,4),(1,5),(0,6)]
|
2005-06-07 10:38:50 +05:30
|
|
|
return self._get_column_order(EVENT_COL_KEY,default)
|
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
def get_repository_column_order(self):
|
|
|
|
"""
|
|
|
|
Returns the Repository display common information stored in the
|
|
|
|
database's metadata.
|
|
|
|
"""
|
2005-06-08 21:05:31 +05:30
|
|
|
default = [(1,1),(0,5),(0,6),(1,2),(1,3),(0,4),(0,7),(0,8),(0,9),(0,10)]
|
2005-05-27 23:13:04 +05:30
|
|
|
return self._get_column_order(REPOSITORY_COL_KEY,default)
|
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
class Transaction:
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Defines a group of database commits that define a single logical
|
|
|
|
operation.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
def __init__(self,msg,db):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Creates a new transaction. A Transaction instance should not be created
|
|
|
|
directly, but by the GrampsDbBase class or classes derived from
|
|
|
|
GrampsDbBase. The db parameter is a list-like interface that stores
|
|
|
|
the commit data. This could be a simple list, or a RECNO-style database
|
|
|
|
object.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
self.db = db
|
|
|
|
self.first = None
|
|
|
|
self.last = None
|
2005-04-01 11:03:22 +05:30
|
|
|
self.batch = False
|
2005-04-23 21:23:30 +05:30
|
|
|
self.length = 0
|
2004-08-01 09:51:31 +05:30
|
|
|
|
2005-04-18 04:04:56 +05:30
|
|
|
self.person_add = []
|
|
|
|
self.person_del = []
|
|
|
|
self.person_update = []
|
|
|
|
|
|
|
|
self.family_add = []
|
|
|
|
self.family_del = []
|
|
|
|
self.family_update = []
|
|
|
|
|
|
|
|
self.source_add = []
|
|
|
|
self.source_del = []
|
|
|
|
self.source_update = []
|
|
|
|
|
|
|
|
self.event_add = []
|
|
|
|
self.event_del = []
|
|
|
|
self.event_update = []
|
|
|
|
|
|
|
|
self.media_add = []
|
|
|
|
self.media_del = []
|
|
|
|
self.media_update = []
|
|
|
|
|
|
|
|
self.place_add = []
|
|
|
|
self.place_del = []
|
|
|
|
self.place_update = []
|
|
|
|
|
2005-05-27 23:13:04 +05:30
|
|
|
self.repository_add = []
|
|
|
|
self.repository_del = []
|
|
|
|
self.repository_update = []
|
|
|
|
|
|
|
|
|
2005-04-01 11:03:22 +05:30
|
|
|
def set_batch(self,batch):
|
|
|
|
self.batch = batch
|
|
|
|
|
|
|
|
def get_batch(self):
|
|
|
|
return self.batch
|
|
|
|
|
2004-08-01 09:51:31 +05:30
|
|
|
def get_description(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the text string that describes the logical operation
|
|
|
|
performed by the Transaction.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
return self.msg
|
|
|
|
|
|
|
|
def set_description(self,msg):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Sets the text string that describes the logical operation
|
|
|
|
performed by the Transaction.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
self.msg = msg
|
|
|
|
|
|
|
|
def add(self, type, handle, data):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Adds a commit operation to the Transaction. The type is a constant
|
|
|
|
that indicates what type of PrimaryObject is being added. The handle
|
|
|
|
is the object's database handle, and the data is the tuple returned
|
|
|
|
by the object's serialize method.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
self.last = self.db.append(cPickle.dumps((type,handle,data),1))
|
|
|
|
if self.first == None:
|
|
|
|
self.first = self.last
|
|
|
|
|
|
|
|
def get_recnos(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns a list of record numbers associated with the transaction.
|
|
|
|
While the list is an arbitrary index of integers, it can be used
|
|
|
|
to indicate record numbers for a database.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
return range (self.first, self.last+1)
|
|
|
|
|
2004-08-13 10:04:07 +05:30
|
|
|
def get_record(self,recno):
|
|
|
|
"""
|
|
|
|
Returns a tuple representing the PrimaryObject type, database handle
|
|
|
|
for the PrimaryObject, and a tuple representing the data created by
|
|
|
|
the object's serialize method.
|
|
|
|
"""
|
|
|
|
return cPickle.loads(self.db[recno])
|
2004-08-01 09:51:31 +05:30
|
|
|
|
|
|
|
def __len__(self):
|
2004-08-13 10:04:07 +05:30
|
|
|
"""
|
|
|
|
Returns the number of commits associated with the Transaction.
|
|
|
|
"""
|
2004-08-01 09:51:31 +05:30
|
|
|
if self.last and self.first:
|
|
|
|
return self.last - self.first + 1
|
|
|
|
return 0
|
2005-08-12 08:20:56 +05:30
|
|
|
|
|
|
|
class DbState(GrampsDBCallback.GrampsDBCallback):
|
|
|
|
|
|
|
|
__signals__ = {
|
|
|
|
'database-changed' : (GrampsDbBase,),
|
|
|
|
'active-changed' : (str,),
|
|
|
|
'no-database' : None,
|
|
|
|
}
|
|
|
|
|
|
|
|
def __init__(self):
|
|
|
|
GrampsDBCallback.GrampsDBCallback.__init__(self)
|
|
|
|
self.db = GrampsDbBase()
|
2005-08-14 10:01:29 +05:30
|
|
|
self.open = False
|
2005-08-12 08:20:56 +05:30
|
|
|
self.active = None
|
|
|
|
|
|
|
|
def change_active_person(self,person):
|
|
|
|
self.active = person
|
|
|
|
if person:
|
|
|
|
try:
|
|
|
|
self.emit('active-changed',(person.handle,))
|
|
|
|
except:
|
|
|
|
self.emit('active-changed',("",))
|
|
|
|
|
|
|
|
def change_active_handle(self,handle):
|
|
|
|
self.change_active_person(self.db.get_person_from_handle(handle))
|
|
|
|
|
|
|
|
def get_active_person(self):
|
|
|
|
return self.active
|
|
|
|
|
|
|
|
def change_database(self,db):
|
|
|
|
self.db = db
|
2005-08-14 10:01:29 +05:30
|
|
|
self.open = True
|
2005-08-12 08:20:56 +05:30
|
|
|
self.emit('database-changed',(self.db,))
|
|
|
|
|
|
|
|
def no_database(self):
|
|
|
|
self.db = GrampsDbBase()
|
2005-08-14 10:01:29 +05:30
|
|
|
self.open = False
|
2005-08-12 08:20:56 +05:30
|
|
|
self.emit('no-database')
|