1f2469b09f
change [x for x in y if x] to filter(None, y) change [f(x) for x in y] to map(f, x) change [x for x in y] to list(y) These changes reduce source code size and complexity and produce some minor performance gains svn: r14104
1399 lines
53 KiB
Python
1399 lines
53 KiB
Python
# Gramps - a GTK+/GNOME based genealogy program
|
|
#
|
|
# Copyright (C) 2009 Douglas S. Blank <doug.blank@gmail.com>
|
|
#
|
|
# 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$
|
|
#
|
|
|
|
""" Interface to Django models """
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# Python Modules
|
|
#
|
|
#------------------------------------------------------------------------
|
|
import time
|
|
import sys
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# Gramps Modules
|
|
#
|
|
#------------------------------------------------------------------------
|
|
import web.grampsdb.models as models
|
|
from django.contrib.contenttypes.models import ContentType
|
|
import web
|
|
import gen
|
|
|
|
# To get a django person from a django database:
|
|
# djperson = dji.Person.get(handle='djhgsdh324hjg234hj24')
|
|
#
|
|
# To turn the djperson into a Gramps Person:
|
|
# tuple = dji.get_person(djperson)
|
|
# gperson = lib.gen.Person(tuple)
|
|
# OR
|
|
# gperson = djangodb.DjangoDb().get_person_from_handle(handle)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Import functions
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def lookup_role_index(role0, event_ref_list):
|
|
"""
|
|
Find the handle in a unserialized event_ref_list and return code.
|
|
"""
|
|
if role0 is None:
|
|
return -1
|
|
else:
|
|
count = 0
|
|
for event_ref in event_ref_list:
|
|
(private, note_list, attribute_list, ref, erole) = event_ref
|
|
try:
|
|
event = models.Event.objects.get(handle=ref)
|
|
except:
|
|
return -1
|
|
if event.event_type[0] == role0:
|
|
return count
|
|
count += 1
|
|
return -1
|
|
|
|
def totime(dtime):
|
|
if dtime:
|
|
return int(time.mktime(dtime.timetuple()))
|
|
else:
|
|
return 0
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Export functions
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def todate(t):
|
|
return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(t))
|
|
|
|
def lookup(index, event_ref_list):
|
|
"""
|
|
Get the unserialized event_ref in an list of them and return it.
|
|
"""
|
|
if index < 0:
|
|
return None
|
|
else:
|
|
count = 0
|
|
for event_ref in event_ref_list:
|
|
(private, note_list, attribute_list, ref, role) = event_ref
|
|
if index == count:
|
|
return ref
|
|
count += 1
|
|
return None
|
|
|
|
def get_datamap(grampsclass):
|
|
return [x[0] for x in grampsclass._DATAMAP if x[0] != grampsclass.CUSTOM]
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Django Interface
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
class DjangoInterface(object):
|
|
"""
|
|
DjangoInterface for interoperating between Gramps and Django.
|
|
|
|
This interface comes in a number of parts:
|
|
get_ITEMS()
|
|
add_ITEMS()
|
|
|
|
get_ITEM(ITEM)
|
|
|
|
Given an ITEM from a Django table, construct a Gramps Raw Data tuple.
|
|
|
|
add_ITEM(data)
|
|
|
|
Given a Gramps Raw Data tuple, add the data to the Django tables.
|
|
|
|
|
|
"""
|
|
def __init__(self):
|
|
self.debug = 0
|
|
|
|
def __getattr__(self, name):
|
|
"""
|
|
Django Objects database interface.
|
|
|
|
>>> self.Person.all()
|
|
>>> self.Person.get(id=1)
|
|
>>> self.Person.get(handle='gh71234dhf3746347734')
|
|
"""
|
|
if hasattr(models, name):
|
|
return getattr(models, name).objects
|
|
else:
|
|
raise AttributeError("no such model: '%s'" % name)
|
|
|
|
def get_model(self, name):
|
|
if hasattr(models, name):
|
|
return getattr(models, name)
|
|
else:
|
|
raise AttributeError("no such model: '%s'" % name)
|
|
|
|
# -----------------------------------------------
|
|
# Get methods to retrieve list data from the tables
|
|
# -----------------------------------------------
|
|
|
|
def clear_tables(self, *args):
|
|
return models.clear_tables(*args)
|
|
|
|
def get_attribute_list(self, obj):
|
|
obj_type = ContentType.objects.get_for_model(obj)
|
|
attribute_list = models.Attribute.objects.filter(object_id=obj.id,
|
|
object_type=obj_type)
|
|
return [self.pack_attribute(attribute) for attribute
|
|
in attribute_list]
|
|
|
|
def get_names(self, person, preferred):
|
|
names = person.name_set.filter(preferred=preferred).order_by("order")
|
|
if preferred:
|
|
if len(names) > 0:
|
|
return self.pack_name(names[0])
|
|
else:
|
|
return gen.lib.Name().serialize()
|
|
else:
|
|
return map(self.pack_name, names)
|
|
|
|
def get_datamap(self, obj): # obj is source
|
|
datamap_dict = {}
|
|
datamap_list = obj.datamap_set.all()
|
|
for datamap in datamap_list:
|
|
datamap_dict[datamap.key] = datamap.value
|
|
return datamap_dict
|
|
|
|
def get_media_list(self, obj):
|
|
obj_type = ContentType.objects.get_for_model(obj)
|
|
mediarefs = models.MediaRef.objects.filter(object_id=obj.id,
|
|
object_type=obj_type)
|
|
retval = []
|
|
for mediaref in mediarefs:
|
|
retval.append(self.pack_media_ref(mediaref))
|
|
return retval
|
|
|
|
def get_note_list(self, obj):
|
|
obj_type = ContentType.objects.get_for_model(obj)
|
|
noterefs = models.NoteRef.objects.filter(object_id=obj.id,
|
|
object_type=obj_type)
|
|
retval = []
|
|
for noteref in noterefs:
|
|
retval.append( noteref.ref_object.handle)
|
|
return retval
|
|
|
|
def get_repository_ref_list(self, obj):
|
|
obj_type = ContentType.objects.get_for_model(obj)
|
|
reporefs = models.RepositoryRef.objects.filter(object_id=obj.id,
|
|
object_type=obj_type)
|
|
return map(self.pack_repository_ref, reporefs)
|
|
|
|
def get_url_list(self, obj):
|
|
return map(self.pack_url, obj.url_set.all().order_by("order"))
|
|
|
|
def get_address_list(self, obj, with_parish): # person or repository
|
|
addresses = obj.address_set.all().order_by("order")
|
|
retval = []
|
|
count = 1
|
|
for address in addresses:
|
|
retval.append(self.pack_address(address, with_parish))
|
|
count += 1
|
|
return retval
|
|
|
|
def get_child_ref_list(self, family):
|
|
obj_type = ContentType.objects.get_for_model(family)
|
|
childrefs = models.ChildRef.objects.filter(object_id=family.id, \
|
|
object_type=obj_type).order_by("order")
|
|
retval = []
|
|
for childref in childrefs:
|
|
retval.append(self.pack_child_ref(childref))
|
|
return retval
|
|
|
|
def get_source_ref_list(self, obj):
|
|
obj_type = ContentType.objects.get_for_model(obj)
|
|
sourcerefs = models.SourceRef.objects.filter(object_id=obj.id, \
|
|
object_type=obj_type).order_by("order")
|
|
retval = []
|
|
for sourceref in sourcerefs:
|
|
retval.append(self.pack_source_ref(sourceref))
|
|
return retval
|
|
|
|
def get_event_refs(self, obj, order="order"):
|
|
obj_type = ContentType.objects.get_for_model(obj)
|
|
eventrefs = models.EventRef.objects.filter(object_id=obj.id, \
|
|
object_type=obj_type).order_by(order)
|
|
return eventrefs
|
|
|
|
def get_event_ref_list(self, obj):
|
|
obj_type = ContentType.objects.get_for_model(obj)
|
|
eventrefs = models.EventRef.objects.filter(object_id=obj.id, \
|
|
object_type=obj_type).order_by("order")
|
|
retval = []
|
|
for eventref in eventrefs:
|
|
retval.append(self.pack_event_ref(eventref))
|
|
return retval
|
|
|
|
def get_family_list(self, person): # person has families
|
|
return [fam.handle for fam in person.families.all()]
|
|
|
|
def get_parent_family_list(self, person):
|
|
return [fam.handle for fam in person.parent_families.all()]
|
|
|
|
def get_person_ref_list(self, person):
|
|
obj_type = ContentType.objects.get_for_model(person)
|
|
return map(self.pack_person_ref,
|
|
models.PersonRef.objects.filter(object_id=person.id,
|
|
object_type=obj_type))
|
|
|
|
def get_lds_list(self, obj): # person or family
|
|
return map(self.pack_lds, obj.lds_set.all().order_by("order"))
|
|
|
|
def get_place_handle(self, obj): # obj is event
|
|
if obj.place:
|
|
return obj.place.handle
|
|
return ''
|
|
|
|
## Packers:
|
|
|
|
def get_event(self, event):
|
|
handle = event.handle
|
|
gid = event.gramps_id
|
|
the_type = tuple(event.event_type)
|
|
description = event.description
|
|
change = totime(event.last_changed)
|
|
marker = tuple(event.marker_type)
|
|
private = event.private
|
|
note_list = self.get_note_list(event)
|
|
source_list = self.get_source_ref_list(event)
|
|
media_list = self.get_media_list(event)
|
|
attribute_list = self.get_attribute_list(event)
|
|
date = self.get_date(event)
|
|
place = self.get_place_handle(event)
|
|
return (str(handle), gid, the_type, date, description, place,
|
|
source_list, note_list, media_list, attribute_list,
|
|
change, marker, private)
|
|
|
|
def get_note(self, note):
|
|
styled_text = [note.text, []]
|
|
markups = models.Markup.objects.filter(note=note).order_by("order")
|
|
for markup in markups:
|
|
value = markup.string
|
|
start_stop_list = markup.start_stop_list
|
|
ss_list = eval(start_stop_list)
|
|
styled_text[1] += [(tuple(markup.markup_type),
|
|
value, ss_list)]
|
|
changed = totime(note.last_changed)
|
|
return (str(note.handle),
|
|
note.gramps_id,
|
|
styled_text,
|
|
note.preformatted,
|
|
tuple(note.note_type),
|
|
changed,
|
|
tuple(note.marker_type),
|
|
note.private)
|
|
|
|
def get_family(self, family):
|
|
child_ref_list = self.get_child_ref_list(family)
|
|
event_ref_list = self.get_event_ref_list(family)
|
|
media_list = self.get_media_list(family)
|
|
attribute_list = self.get_attribute_list(family)
|
|
lds_seal_list = self.get_lds_list(family)
|
|
source_list = self.get_source_ref_list(family)
|
|
note_list = self.get_note_list(family)
|
|
if family.father:
|
|
father_handle = family.father.handle
|
|
else:
|
|
father_handle = ''
|
|
if family.mother:
|
|
mother_handle = family.mother.handle
|
|
else:
|
|
mother_handle = ''
|
|
return (str(family.handle), family.gramps_id,
|
|
father_handle, mother_handle,
|
|
child_ref_list, tuple(family.family_rel_type),
|
|
event_ref_list, media_list,
|
|
attribute_list, lds_seal_list,
|
|
source_list, note_list,
|
|
totime(family.last_changed),
|
|
tuple(family.marker_type),
|
|
family.private)
|
|
|
|
def get_repository(self, repository):
|
|
note_list = self.get_note_list(repository)
|
|
address_list = self.get_address_list(repository, with_parish=False)
|
|
url_list = self.get_url_list(repository)
|
|
return (str(repository.handle),
|
|
repository.gramps_id,
|
|
tuple(repository.repository_type),
|
|
repository.name,
|
|
note_list,
|
|
address_list,
|
|
url_list,
|
|
totime(repository.last_changed),
|
|
tuple(repository.marker_type),
|
|
repository.private)
|
|
|
|
def get_source(self, source):
|
|
note_list = self.get_note_list(source)
|
|
media_list = self.get_media_list(source)
|
|
datamap = self.get_datamap(source)
|
|
reporef_list = self.get_repository_ref_list(source)
|
|
return (str(source.handle),
|
|
source.gramps_id,
|
|
source.title,
|
|
source.author,
|
|
source.pubinfo,
|
|
note_list,
|
|
media_list,
|
|
source.abbrev,
|
|
totime(source.last_changed),
|
|
datamap,
|
|
reporef_list,
|
|
tuple(source.marker_type),
|
|
source.private)
|
|
|
|
def get_media(self, media):
|
|
attribute_list = self.get_attribute_list(media)
|
|
source_list = self.get_source_ref_list(media)
|
|
note_list = self.get_note_list(media)
|
|
date = self.get_date(media)
|
|
return (str(media.handle),
|
|
media.gramps_id,
|
|
media.path,
|
|
media.mime,
|
|
media.desc,
|
|
attribute_list,
|
|
source_list,
|
|
note_list,
|
|
totime(media.last_changed),
|
|
date,
|
|
tuple(media.marker_type),
|
|
media.private)
|
|
|
|
def get_person(self, person):
|
|
primary_name = self.get_names(person, True) # one
|
|
alternate_names = self.get_names(person, False) # list
|
|
event_ref_list = self.get_event_ref_list(person)
|
|
family_list = self.get_family_list(person)
|
|
parent_family_list = self.get_parent_family_list(person)
|
|
media_list = self.get_media_list(person)
|
|
address_list = self.get_address_list(person, with_parish=False)
|
|
attribute_list = self.get_attribute_list(person)
|
|
url_list = self.get_url_list(person)
|
|
lds_ord_list = self.get_lds_list(person)
|
|
psource_list = self.get_source_ref_list(person)
|
|
pnote_list = self.get_note_list(person)
|
|
person_ref_list = self.get_person_ref_list(person)
|
|
# This looks up the events for the first EventType given:
|
|
death_ref_index = lookup_role_index(models.EventType.DEATH,
|
|
event_ref_list)
|
|
birth_ref_index = lookup_role_index(models.EventType.BIRTH,
|
|
event_ref_list)
|
|
return (str(person.handle),
|
|
person.gramps_id,
|
|
tuple(person.gender_type)[0],
|
|
primary_name,
|
|
alternate_names,
|
|
death_ref_index,
|
|
birth_ref_index,
|
|
event_ref_list,
|
|
family_list,
|
|
parent_family_list,
|
|
media_list,
|
|
address_list,
|
|
attribute_list,
|
|
url_list,
|
|
lds_ord_list,
|
|
psource_list,
|
|
pnote_list,
|
|
totime(person.last_changed),
|
|
tuple(person.marker_type),
|
|
person.private,
|
|
person_ref_list)
|
|
|
|
def get_date(self, obj):
|
|
if ((obj.calendar == obj.modifier == obj.quality == obj.sortval == obj.newyear == 0) and
|
|
obj.text == "" and (not obj.slash1) and (not obj.slash2) and
|
|
(obj.day1 == obj.month1 == obj.year1 == 0) and
|
|
(obj.day2 == obj.month2 == obj.year2 == 0)):
|
|
return None
|
|
elif ((not obj.slash1) and (not obj.slash2) and
|
|
(obj.day2 == obj.month2 == obj.year2 == 0)):
|
|
dateval = (obj.day1, obj.month1, obj.year1, obj.slash1)
|
|
else:
|
|
dateval = (obj.day1, obj.month1, obj.year1, obj.slash1,
|
|
obj.day2, obj.month2, obj.year2, obj.slash2)
|
|
return (obj.calendar, obj.modifier, obj.quality, dateval,
|
|
obj.text, obj.sortval, obj.newyear)
|
|
|
|
def get_place(self, place):
|
|
locations = place.location_set.all().order_by("order")
|
|
main_loc = None
|
|
alt_location_list = []
|
|
for location in locations:
|
|
if main_loc is None:
|
|
main_loc = self.pack_location(location, True)
|
|
else:
|
|
alt_location_list.append(self.pack_location(location, True))
|
|
url_list = self.get_url_list(place)
|
|
media_list = self.get_media_list(place)
|
|
source_list = self.get_source_ref_list(place)
|
|
note_list = self.get_note_list(place)
|
|
return (str(place.handle),
|
|
place.gramps_id,
|
|
place.title,
|
|
place.long,
|
|
place.lat,
|
|
main_loc,
|
|
alt_location_list,
|
|
url_list,
|
|
media_list,
|
|
source_list,
|
|
note_list,
|
|
totime(place.last_changed),
|
|
tuple(place.marker_type),
|
|
place.private)
|
|
|
|
# ---------------------------------
|
|
# Packers
|
|
# ---------------------------------
|
|
|
|
## The packers build GRAMPS raw unserialized data.
|
|
|
|
## Reference packers
|
|
|
|
def pack_child_ref(self, child_ref):
|
|
source_list = self.get_source_ref_list(child_ref)
|
|
note_list = self.get_note_list(child_ref)
|
|
return (child_ref.private, source_list, note_list, child_ref.ref_object.handle,
|
|
tuple(child_ref.father_rel_type), tuple(child_ref.mother_rel_type))
|
|
|
|
def pack_person_ref(self, personref):
|
|
source_list = self.get_source_ref_list(personref)
|
|
note_list = self.get_note_list(personref)
|
|
return (personref.private,
|
|
source_list,
|
|
note_list,
|
|
personref.ref_object.handle,
|
|
personref.description)
|
|
|
|
def pack_media_ref(self, media_ref):
|
|
source_list = self.get_source_ref_list(media_ref)
|
|
note_list = self.get_note_list(media_ref)
|
|
attribute_list = self.get_attribute_list(media_ref)
|
|
if ((media_ref.x1 == media_ref.y1 == media_ref.x2 == media_ref.y2 == -1) or
|
|
(media_ref.x1 == media_ref.y1 == media_ref.x2 == media_ref.y2 == 0)):
|
|
role = None
|
|
else:
|
|
role = (media_ref.x1, media_ref.y1, media_ref.x2, media_ref.y2)
|
|
return (media_ref.private, source_list, note_list, attribute_list,
|
|
media_ref.ref_object.handle, role)
|
|
|
|
def pack_repository_ref(self, repo_ref):
|
|
note_list = self.get_note_list(repo_ref)
|
|
return (note_list,
|
|
repo_ref.ref_object.handle,
|
|
repo_ref.call_number,
|
|
tuple(repo_ref.source_media_type),
|
|
repo_ref.private)
|
|
|
|
def pack_media_ref(self, media_ref):
|
|
note_list = self.get_note_list(media_ref)
|
|
attribute_list = self.get_attribute_list(media_ref)
|
|
source_list = self.get_source_ref_list(media_ref)
|
|
return (media_ref.private, source_list, note_list, attribute_list,
|
|
media_ref.ref_object.handle, (media_ref.x1,
|
|
media_ref.y1,
|
|
media_ref.x2,
|
|
media_ref.y2))
|
|
|
|
def pack_event_ref(self, event_ref):
|
|
note_list = self.get_note_list(event_ref)
|
|
attribute_list = self.get_attribute_list(event_ref)
|
|
return (event_ref.private, note_list, attribute_list,
|
|
event_ref.ref_object.handle, tuple(event_ref.role_type))
|
|
|
|
def pack_source_ref(self, source_ref):
|
|
ref = source_ref.ref_object.handle
|
|
confidence = source_ref.confidence
|
|
page = source_ref.page
|
|
private = source_ref.private
|
|
date = self.get_date(source_ref)
|
|
note_list = self.get_note_list(source_ref)
|
|
return (date, private, note_list, confidence, ref, page)
|
|
|
|
def pack_address(self, address, with_parish):
|
|
source_list = self.get_source_ref_list(address)
|
|
date = self.get_date(address)
|
|
note_list = self.get_note_list(address)
|
|
locations = address.location_set.all().order_by("order")
|
|
if len(locations) > 0:
|
|
location = self.pack_location(locations[0], with_parish)
|
|
else:
|
|
if with_parish:
|
|
location = (("", "", "", "", "", "", ""), "")
|
|
else:
|
|
location = ("", "", "", "", "", "", "")
|
|
return (address.private, source_list, note_list, date, location)
|
|
|
|
def pack_lds(self, lds):
|
|
source_list = self.get_source_ref_list(lds)
|
|
note_list = self.get_note_list(lds)
|
|
date = self.get_date(lds)
|
|
if lds.famc:
|
|
famc = lds.famc.handle
|
|
else:
|
|
famc = None
|
|
place = self.get_place_handle(lds)
|
|
return (source_list, note_list, date, lds.lds_type[0], place,
|
|
famc, lds.temple, lds.status[0], lds.private)
|
|
|
|
def pack_source(self, source):
|
|
note_list = self.get_note_list(source)
|
|
media_list = self.get_media_list(source)
|
|
reporef_list = self.get_repository_ref_list(source)
|
|
datamap = self.get_datamap(source)
|
|
return (source.handle, source.gramps_id, source.title,
|
|
source.author, source.pubinfo,
|
|
note_list,
|
|
media_list,
|
|
source.abbrev,
|
|
totime(last_changed), datamap,
|
|
reporef_list,
|
|
tuple(source.marker_type), source.private)
|
|
|
|
def pack_name(self, name):
|
|
source_list = self.get_source_ref_list(name)
|
|
note_list = self.get_note_list(name)
|
|
date = self.get_date(name)
|
|
return (name.private, source_list, note_list, date,
|
|
name.first_name, name.surname, name.suffix, name.title,
|
|
tuple(name.name_type), name.prefix, name.patronymic,
|
|
name.group_as, name.sort_as.val, name.display_as.val, name.call)
|
|
|
|
def pack_location(self, loc, with_parish):
|
|
if with_parish:
|
|
return ((loc.street, loc.city, loc.county, loc.state, loc.country,
|
|
loc.postal, loc.phone), loc.parish)
|
|
else:
|
|
return (loc.street, loc.city, loc.county, loc.state, loc.country,
|
|
loc.postal, loc.phone)
|
|
|
|
def pack_url(self, url):
|
|
return (url.private, url.path, url.desc, tuple(url.url_type))
|
|
|
|
def pack_attribute(self, attribute):
|
|
source_list = self.get_source_ref_list(attribute)
|
|
note_list = self.get_note_list(attribute)
|
|
return (attribute.private,
|
|
source_list,
|
|
note_list,
|
|
tuple(attribute.attribute_type),
|
|
attribute.value)
|
|
|
|
|
|
## Export lists:
|
|
|
|
def add_child_ref_list(self, obj, ref_list):
|
|
## Currently, only Family references children
|
|
for child_data in ref_list:
|
|
self.add_child_ref(obj, child_data)
|
|
|
|
def add_source_ref_list(self, obj, source_list):
|
|
for source_data in source_list:
|
|
self.add_source_ref(obj, source_data)
|
|
|
|
def add_event_ref_list(self, obj, event_ref_list):
|
|
for event_ref in event_ref_list:
|
|
self.add_event_ref(obj, event_ref)
|
|
|
|
def add_note_list(self, obj, note_list):
|
|
for handle in note_list:
|
|
# Just the handle
|
|
try:
|
|
note = models.Note.objects.get(handle=handle)
|
|
self.add_note_ref(obj, note)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Note does not exist: '%s'" %
|
|
handle)
|
|
|
|
def add_alternate_name_list(self, person, alternate_names):
|
|
for name in alternate_names:
|
|
if name:
|
|
self.add_name(person, name, False)
|
|
|
|
def add_parent_family_list(self, person, parent_family_list):
|
|
for parent_family_data in parent_family_list:
|
|
self.add_parent_family(person, parent_family_data)
|
|
|
|
def add_media_ref_list(self, person, media_list):
|
|
for media_data in media_list:
|
|
self.add_media_ref(person, media_data)
|
|
|
|
def add_attribute_list(self, obj, attribute_list):
|
|
for attribute_data in attribute_list:
|
|
self.add_attribute(obj, attribute_data)
|
|
|
|
def add_url_list(self, field, obj, url_list):
|
|
if not url_list: return None
|
|
count = 1
|
|
for url_data in url_list:
|
|
self.add_url(field, obj, url_data, count)
|
|
count += 1
|
|
|
|
def add_person_ref_list(self, obj, person_ref_list):
|
|
for person_ref_data in person_ref_list:
|
|
self.add_person_ref(obj, person_ref_data)
|
|
|
|
def add_address_list(self, field, obj, address_list):
|
|
count = 1
|
|
for address_data in address_list:
|
|
self.add_address(field, obj, address_data, count)
|
|
count += 1
|
|
|
|
def add_lds_list(self, field, obj, lds_ord_list):
|
|
count = 1
|
|
for ldsord in lds_ord_list:
|
|
lds = self.add_lds(field, obj, ldsord, count)
|
|
#obj.lds_list.add(lds)
|
|
#obj.save()
|
|
count += 1
|
|
|
|
def add_repository_ref_list(self, obj, reporef_list):
|
|
for data in reporef_list:
|
|
self.add_repository_ref(obj, data)
|
|
|
|
def add_family_ref_list(self, person, family_list):
|
|
for family_handle in family_list:
|
|
self.add_family_ref(person, family_handle)
|
|
|
|
## Export reference objects:
|
|
|
|
def add_person_ref(self, obj, person_ref_data):
|
|
(private,
|
|
source_list,
|
|
note_list,
|
|
handle,
|
|
desc) = person_ref_data
|
|
try:
|
|
person = models.Person.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Person does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
|
|
count = person.references.count()
|
|
person_ref = models.PersonRef(referenced_by=obj,
|
|
ref_object=person,
|
|
private=private,
|
|
order=count + 1,
|
|
description=desc)
|
|
person_ref.save()
|
|
self.add_note_list(person_ref, note_list)
|
|
self.add_source_ref_list(person_ref, source_list)
|
|
|
|
def add_note_ref(self, obj, note):
|
|
count = note.references.count()
|
|
note_ref = models.NoteRef(referenced_by=obj,
|
|
ref_object=note,
|
|
private=False,
|
|
order=count + 1)
|
|
note_ref.save()
|
|
|
|
def add_media_ref(self, obj, media_ref_data):
|
|
(private, source_list, note_list, attribute_list,
|
|
ref, role) = media_ref_data
|
|
try:
|
|
media = models.Media.objects.get(handle=ref)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Media does not exist: '%s'" %
|
|
ref)
|
|
return
|
|
count = media.references.count()
|
|
if not role:
|
|
role = (0,0,0,0)
|
|
media_ref = models.MediaRef(referenced_by=obj,
|
|
ref_object=media,
|
|
x1=role[0],
|
|
y1=role[1],
|
|
x2=role[2],
|
|
y2=role[3],
|
|
private=private,
|
|
order=count + 1)
|
|
media_ref.save()
|
|
self.add_note_list(media_ref, note_list)
|
|
self.add_attribute_list(media_ref, attribute_list)
|
|
self.add_source_ref_list(media_ref, source_list)
|
|
|
|
def add_source_ref(self, obj, source_data):
|
|
(date, private, note_list, confidence, ref, page) = source_data
|
|
try:
|
|
source = models.Source.objects.get(handle=ref)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Source does not exist: '%s'" %
|
|
ref)
|
|
return
|
|
count = source.references.count()
|
|
source_ref = models.SourceRef(private=private,
|
|
confidence=confidence,
|
|
page=page,
|
|
order=count + 1,
|
|
referenced_by=obj,
|
|
ref_object=source)
|
|
self.add_date(source_ref, date)
|
|
source_ref.save()
|
|
self.add_note_list(source_ref, note_list)
|
|
|
|
def add_child_ref(self, obj, data):
|
|
(private, source_list, note_list, ref, frel, mrel) = data
|
|
try:
|
|
child = models.Person.objects.get(handle=ref)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Person does not exist: '%s'" %
|
|
ref)
|
|
return
|
|
count = models.ChildRef.objects.filter(object_id=obj.id,object_type=obj).count()
|
|
child_ref = models.ChildRef(private=private,
|
|
referenced_by=obj,
|
|
ref_object=child,
|
|
order=count + 1,
|
|
father_rel_type=models.get_type(models.ChildRefType, frel),
|
|
mother_rel_type=models.get_type(models.ChildRefType, mrel))
|
|
child_ref.save()
|
|
self.add_source_ref_list(child_ref, source_list)
|
|
self.add_note_list(child_ref, note_list)
|
|
|
|
def add_event_ref(self, obj, event_data):
|
|
(private, note_list, attribute_list, ref, role) = event_data
|
|
try:
|
|
event = models.Event.objects.get(handle=ref)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Event does not exist: '%s'" %
|
|
ref)
|
|
return
|
|
count = models.EventRef.objects.filter(object_id=obj.id,object_type=obj).count()
|
|
event_ref = models.EventRef(private=private,
|
|
referenced_by=obj,
|
|
ref_object=event,
|
|
order=count + 1,
|
|
role_type = models.get_type(models.EventRoleType, role))
|
|
event_ref.save()
|
|
self.add_note_list(event_ref, note_list)
|
|
self.add_attribute_list(event_ref, attribute_list)
|
|
|
|
def add_repository_ref(self, obj, reporef_data):
|
|
(note_list,
|
|
ref,
|
|
call_number,
|
|
source_media_type,
|
|
private) = reporef_data
|
|
try:
|
|
repository = models.Repository.objects.get(handle=ref)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Repository does not exist: '%s'" %
|
|
ref)
|
|
return
|
|
count = models.RepositoryRef.objects.filter(object_id=obj.id,object_type=obj).count()
|
|
repos_ref = models.RepositoryRef(private=private,
|
|
referenced_by=obj,
|
|
call_number=call_number,
|
|
source_media_type=models.get_type(models.SourceMediaType,
|
|
source_media_type),
|
|
ref_object=repository,
|
|
order=count + 1)
|
|
repos_ref.save()
|
|
self.add_note_list(repos_ref, note_list)
|
|
|
|
def add_family_ref(self, obj, handle):
|
|
try:
|
|
family = models.Family.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Family does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
obj.families.add(family)
|
|
obj.save()
|
|
|
|
## Export individual objects:
|
|
|
|
def add_datamap_dict(self, source, datamap_dict):
|
|
for key in datamap_dict:
|
|
value = datamap_dict[key]
|
|
datamap = models.Datamap(key=key, value=value)
|
|
datamap.source = source
|
|
datamap.save()
|
|
#source.datamaps.add(datamap)
|
|
#source.save()
|
|
|
|
def add_lds(self, field, obj, data, order):
|
|
(lsource_list, lnote_list, date, type, place_handle,
|
|
famc_handle, temple, status, private) = data
|
|
if place_handle:
|
|
try:
|
|
place = models.Place.objects.get(handle=place_handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Place does not exist: '%s'" %
|
|
place_handle)
|
|
place = None
|
|
else:
|
|
place = None
|
|
if famc_handle:
|
|
try:
|
|
famc = models.Family.objects.get(handle=famc_handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Family does not exist: '%s'" %
|
|
famc_handle)
|
|
famc = None
|
|
else:
|
|
famc = None
|
|
lds = models.Lds(lds_type = models.get_type(models.LdsType, type),
|
|
temple=temple,
|
|
place=place,
|
|
famc=famc,
|
|
order=order,
|
|
status = models.get_type(models.LdsStatus, status),
|
|
private=private)
|
|
self.add_date(lds, date)
|
|
lds.save()
|
|
self.add_note_list(lds, lnote_list)
|
|
self.add_source_ref_list(lds, lsource_list)
|
|
if field == "person":
|
|
lds.person = obj
|
|
elif field == "family":
|
|
lds.family = obj
|
|
else:
|
|
raise AttributeError("invalid field '%s' to attach lds" %
|
|
field)
|
|
lds.save()
|
|
return lds
|
|
|
|
def add_address(self, field, obj, address_data, order):
|
|
(private, asource_list, anote_list, date, location) = address_data
|
|
address = models.Address(private=private, order=order)
|
|
self.add_date(address, date)
|
|
address.save()
|
|
self.add_location("address", address, location, 1)
|
|
self.add_note_list(address, anote_list)
|
|
self.add_source_ref_list(address, asource_list)
|
|
if field == "person":
|
|
address.person = obj
|
|
elif field == "repository":
|
|
address.repository = obj
|
|
else:
|
|
raise AttributeError("invalid field '%s' to attach address" %
|
|
field)
|
|
address.save()
|
|
#obj.save()
|
|
#obj.addresses.add(address)
|
|
#obj.save()
|
|
|
|
def add_attribute(self, obj, attribute_data):
|
|
(private, source_list, note_list, the_type, value) = attribute_data
|
|
attribute_type = models.get_type(models.AttributeType, the_type)
|
|
attribute = models.Attribute(private=private,
|
|
attribute_of=obj,
|
|
attribute_type=attribute_type,
|
|
value=value)
|
|
attribute.save()
|
|
self.add_source_ref_list(attribute, source_list)
|
|
self.add_note_list(attribute, note_list)
|
|
#obj.attributes.add(attribute)
|
|
#obj.save()
|
|
|
|
def add_url(self, field, obj, url_data, order):
|
|
(private, path, desc, type) = url_data
|
|
url = models.Url(private=private,
|
|
path=path,
|
|
desc=desc,
|
|
order=order,
|
|
url_type=models.get_type(models.UrlType, type))
|
|
if field == "person":
|
|
url.person = obj
|
|
elif field == "repository":
|
|
url.repository = obj
|
|
elif field == "place":
|
|
url.place = obj
|
|
else:
|
|
raise AttributeError("invalid field '%s' to attach to url" %
|
|
field)
|
|
url.save()
|
|
#obj.url_list.add(url)
|
|
#obj.save()
|
|
|
|
def add_place_ref(self, event, place_handle):
|
|
if place_handle:
|
|
try:
|
|
place = models.Place.objects.get(handle=place_handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Place does not exist: '%s'" %
|
|
place_handle)
|
|
return
|
|
event.place = place
|
|
event.save()
|
|
|
|
def add_parent_family(self, person, parent_family_handle):
|
|
try:
|
|
family = models.Family.objects.get(handle=parent_family_handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Family does not exist: '%s'" %
|
|
parent_family_handle)
|
|
return
|
|
person.parent_families.add(family)
|
|
person.save()
|
|
|
|
def add_date(self, obj, date):
|
|
if date is None:
|
|
(calendar, modifier, quality, text, sortval, newyear) = \
|
|
(0, 0, 0, "", 0, 0)
|
|
day1, month1, year1, slash1 = 0, 0, 0, 0
|
|
day2, month2, year2, slash2 = 0, 0, 0, 0
|
|
else:
|
|
(calendar, modifier, quality, dateval, text, sortval, newyear) = date
|
|
if len(dateval) == 4:
|
|
day1, month1, year1, slash1 = dateval
|
|
day2, month2, year2, slash2 = 0, 0, 0, 0
|
|
elif len(dateval) == 8:
|
|
day1, month1, year1, slash1, day2, month2, year2, slash2 = dateval
|
|
else:
|
|
raise AttributeError("ERROR: dateval format '%s'" % dateval)
|
|
obj.calendar = calendar
|
|
obj.modifier = modifier
|
|
obj.quality = quality
|
|
obj.text = text
|
|
obj.sortval = sortval
|
|
obj.newyear = newyear
|
|
obj.day1 = day1
|
|
obj.month1 = month1
|
|
obj.year1 = year1
|
|
obj.slash1 = slash1
|
|
obj.day2 = day2
|
|
obj.month2 = month2
|
|
obj.year2 = year2
|
|
obj.slash2 = slash2
|
|
|
|
def add_name(self, person, data, preferred):
|
|
if data:
|
|
(private, source_list, note_list, date,
|
|
first_name, surname, suffix, title,
|
|
name_type, prefix, patronymic,
|
|
group_as, sort_as, display_as, call) = data
|
|
|
|
count = person.name_set.count()
|
|
name = models.Name()
|
|
name.order = count + 1
|
|
name.preferred = preferred
|
|
name.private = private
|
|
name.first_name = first_name
|
|
name.surname = surname
|
|
name.suffix = suffix
|
|
name.title = title
|
|
name.name_type = models.get_type(models.NameType, name_type)
|
|
name.prefix = prefix
|
|
name.patronymic = patronymic
|
|
name.group_as = group_as
|
|
name.sort_as = models.get_type(models.NameFormatType, sort_as)
|
|
name.display_as = models.get_type(models.NameFormatType, display_as)
|
|
name.call = call
|
|
# we know person exists
|
|
# needs to have an ID for key
|
|
name.person = person
|
|
self.add_date(name, date)
|
|
name.save()
|
|
self.add_note_list(name, note_list)
|
|
self.add_source_ref_list(name, source_list)
|
|
#person.save()
|
|
|
|
## Export primary objects:
|
|
|
|
def add_person(self, data):
|
|
# Unpack from the BSDDB:
|
|
(handle, # 0
|
|
gid, # 1
|
|
gender, # 2
|
|
primary_name, # 3
|
|
alternate_names, # 4
|
|
death_ref_index, # 5
|
|
birth_ref_index, # 6
|
|
event_ref_list, # 7
|
|
family_list, # 8
|
|
parent_family_list, # 9
|
|
media_list, # 10
|
|
address_list, # 11
|
|
attribute_list, # 12
|
|
url_list, # 13
|
|
lds_ord_list, # 14
|
|
psource_list, # 15
|
|
pnote_list, # 16
|
|
change, # 17
|
|
marker, # 18
|
|
private, # 19
|
|
person_ref_list, # 20
|
|
) = data
|
|
|
|
person = models.Person(handle=handle,
|
|
gramps_id=gid,
|
|
last_changed=todate(change),
|
|
private=private,
|
|
marker_type = models.get_type(models.MarkerType, marker),
|
|
gender_type = models.get_type(models.GenderType, gender))
|
|
person.save()
|
|
|
|
def add_person_detail(self, data):
|
|
# Unpack from the BSDDB:
|
|
(handle, # 0
|
|
gid, # 1
|
|
gender, # 2
|
|
primary_name, # 3
|
|
alternate_names, # 4
|
|
death_ref_index, # 5
|
|
birth_ref_index, # 6
|
|
event_ref_list, # 7
|
|
family_list, # 8
|
|
parent_family_list, # 9
|
|
media_list, # 10
|
|
address_list, # 11
|
|
attribute_list, # 12
|
|
url_list, # 13
|
|
lds_ord_list, # 14
|
|
psource_list, # 15
|
|
pnote_list, # 16
|
|
change, # 17
|
|
marker, # 18
|
|
private, # 19
|
|
person_ref_list, # 20
|
|
) = data
|
|
|
|
try:
|
|
person = models.Person.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Person does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
if primary_name:
|
|
self.add_name(person, primary_name, True)
|
|
self.add_alternate_name_list(person, alternate_names)
|
|
self.add_event_ref_list(person, event_ref_list)
|
|
self.add_family_ref_list(person, family_list)
|
|
self.add_parent_family_list(person, parent_family_list)
|
|
self.add_media_ref_list(person, media_list)
|
|
self.add_note_list(person, pnote_list)
|
|
self.add_attribute_list(person, attribute_list)
|
|
self.add_url_list("person", person, url_list)
|
|
self.add_person_ref_list(person, person_ref_list)
|
|
self.add_source_ref_list(person, psource_list)
|
|
self.add_address_list("person", person, address_list)
|
|
self.add_lds_list("person", person, lds_ord_list)
|
|
# set person.birth and birth.death to correct events:
|
|
|
|
obj_type = ContentType.objects.get_for_model(person)
|
|
events = models.EventRef.objects.filter(
|
|
object_id=person.id,
|
|
object_type=obj_type,
|
|
ref_object__event_type__val=models.EventType.BIRTH)
|
|
if events:
|
|
person.birth = events[0].ref_object
|
|
events = models.EventRef.objects.filter(
|
|
object_id=person.id,
|
|
object_type=obj_type,
|
|
ref_object__event_type__val=models.EventType.DEATH)
|
|
if events:
|
|
person.death = events[0].ref_object
|
|
person.save()
|
|
return person
|
|
|
|
def add_note_detail(self, data):
|
|
"""
|
|
Dummy method for consistency with other two-pass adds.
|
|
"""
|
|
pass
|
|
|
|
def add_note(self, data):
|
|
# Unpack from the BSDDB:
|
|
(handle, gid, styled_text, format, note_type,
|
|
change, marker, private) = data
|
|
text, markup_list = styled_text
|
|
n = models.Note(handle=handle,
|
|
gramps_id=gid,
|
|
last_changed=todate(change),
|
|
private=private,
|
|
preformatted=format,
|
|
text=text,
|
|
marker_type = models.get_type(models.MarkerType, marker),
|
|
note_type = models.get_type(models.NoteType, note_type))
|
|
n.save()
|
|
count = 1
|
|
for markup in markup_list:
|
|
markup_code, value, start_stop_list = markup
|
|
m = models.Markup(note=n, order=count,
|
|
markup_type=models.get_type(models.MarkupType,
|
|
markup_code,
|
|
get_or_create=True),
|
|
string=value,
|
|
start_stop_list=str(start_stop_list))
|
|
m.save()
|
|
|
|
def add_family(self, data):
|
|
# Unpack from the BSDDB:
|
|
(handle, gid, father_handle, mother_handle,
|
|
child_ref_list, the_type, event_ref_list, media_list,
|
|
attribute_list, lds_seal_list, source_list, note_list,
|
|
change, marker, private) = data
|
|
|
|
family = models.Family(handle=handle, gramps_id=gid,
|
|
family_rel_type = models.get_type(models.FamilyRelType, the_type),
|
|
last_changed=todate(change),
|
|
marker_type = models.get_type(models.MarkerType, marker),
|
|
private=private)
|
|
family.save()
|
|
|
|
def add_family_detail(self, data):
|
|
# Unpack from the BSDDB:
|
|
(handle, gid, father_handle, mother_handle,
|
|
child_ref_list, the_type, event_ref_list, media_list,
|
|
attribute_list, lds_seal_list, source_list, note_list,
|
|
change, marker, private) = data
|
|
|
|
try:
|
|
family = models.Family.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Family does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
# father_handle and/or mother_handle can be None
|
|
if father_handle:
|
|
try:
|
|
family.father = models.Person.objects.get(handle=father_handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Father does not exist: '%s'" %
|
|
father_handle)
|
|
family.father = None
|
|
if mother_handle:
|
|
try:
|
|
family.mother = models.Person.objects.get(handle=mother_handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Mother does not exist: '%s'" %
|
|
mother_handle)
|
|
family.mother = None
|
|
family.save()
|
|
self.add_child_ref_list(family, child_ref_list)
|
|
self.add_note_list(family, note_list)
|
|
self.add_attribute_list(family, attribute_list)
|
|
self.add_source_ref_list(family, source_list)
|
|
self.add_media_ref_list(family, media_list)
|
|
self.add_event_ref_list(family, event_ref_list)
|
|
self.add_lds_list("family", family, lds_seal_list)
|
|
|
|
def add_source(self, data):
|
|
(handle, gid, title,
|
|
author, pubinfo,
|
|
note_list,
|
|
media_list,
|
|
abbrev,
|
|
change, datamap,
|
|
reporef_list,
|
|
marker, private) = data
|
|
source = models.Source(handle=handle, gramps_id=gid, title=title,
|
|
author=author, pubinfo=pubinfo, abbrev=abbrev,
|
|
last_changed=todate(change), private=private)
|
|
source.marker_type = models.get_type(models.MarkerType, marker)
|
|
source.save()
|
|
|
|
def add_source_detail(self, data):
|
|
(handle, gid, title,
|
|
author, pubinfo,
|
|
note_list,
|
|
media_list,
|
|
abbrev,
|
|
change, datamap,
|
|
reporef_list,
|
|
marker, private) = data
|
|
try:
|
|
source = models.Source.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Source does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
self.add_note_list(source, note_list)
|
|
self.add_media_ref_list(source, media_list)
|
|
self.add_datamap_dict(source, datamap)
|
|
self.add_repository_ref_list(source, reporef_list)
|
|
|
|
def add_repository(self, data):
|
|
(handle, gid, the_type, name, note_list,
|
|
address_list, url_list, change, marker, private) = data
|
|
|
|
repository = models.Repository(handle=handle,
|
|
gramps_id=gid,
|
|
marker_type=models.get_type(models.MarkerType, marker),
|
|
last_changed=todate(change),
|
|
private=private,
|
|
repository_type=models.get_type(models.RepositoryType, the_type),
|
|
name=name)
|
|
repository.save()
|
|
|
|
def add_repository_detail(self, data):
|
|
(handle, gid, the_type, name, note_list,
|
|
address_list, url_list, change, marker, private) = data
|
|
try:
|
|
repository = models.Repository.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Repository does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
self.add_note_list(repository, note_list)
|
|
self.add_url_list("repository", repository, url_list)
|
|
self.add_address_list("repository", repository, address_list)
|
|
|
|
def add_location(self, field, obj, location_data, order):
|
|
if location_data == None: return
|
|
if len(location_data) == 7:
|
|
(street, city, county, state, country, postal, phone) = location_data
|
|
parish = None
|
|
elif len(location_data) == 2:
|
|
((street, city, county, state, country, postal, phone), parish) = location_data
|
|
else:
|
|
print >> sys.stderr, ("ERROR: unknown location: '%s'" %
|
|
location_data)
|
|
(street, city, county, state, country, postal, phone, parish) = \
|
|
("", "", "", "", "", "", "", "")
|
|
location = models.Location(street = street,
|
|
city = city,
|
|
county = county,
|
|
state = state,
|
|
country = country,
|
|
postal = postal,
|
|
phone = phone,
|
|
parish = parish,
|
|
order = order)
|
|
if field == "address":
|
|
location.address = obj
|
|
elif field == "place":
|
|
location.place = obj
|
|
else:
|
|
raise AttributeError("invalid field '%s' to attach to location" %
|
|
field)
|
|
location.save()
|
|
#obj.locations.add(location)
|
|
#obj.save()
|
|
|
|
def add_place(self, data):
|
|
(handle, gid, title, long, lat,
|
|
main_loc, alt_location_list,
|
|
url_list,
|
|
media_list,
|
|
source_list,
|
|
note_list,
|
|
change, marker, private) = data
|
|
place = models.Place(handle=handle, gramps_id=gid, title=title,
|
|
long=long, lat=lat, last_changed=todate(change),
|
|
marker_type=models.get_type(models.MarkerType, marker),
|
|
private=private)
|
|
place.save()
|
|
|
|
def add_place_detail(self, data):
|
|
(handle, gid, title, long, lat,
|
|
main_loc, alt_location_list,
|
|
url_list,
|
|
media_list,
|
|
source_list,
|
|
note_list,
|
|
change, marker, private) = data
|
|
try:
|
|
place = models.Place.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Place does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
self.add_url_list("place", place, url_list)
|
|
self.add_media_ref_list(place, media_list)
|
|
self.add_source_ref_list(place, source_list)
|
|
self.add_note_list(place, note_list)
|
|
self.add_location("place", place, main_loc, 1)
|
|
count = 2
|
|
for loc_data in alt_location_list:
|
|
self.add_location("place", place, loc_data, count)
|
|
count + 1
|
|
|
|
def add_media(self, data):
|
|
(handle, gid, path, mime, desc,
|
|
attribute_list,
|
|
source_list,
|
|
note_list,
|
|
change,
|
|
date,
|
|
marker,
|
|
private) = data
|
|
media = models.Media(handle=handle, gramps_id=gid,
|
|
path=path, mime=mime,
|
|
desc=desc, last_changed=todate(change),
|
|
marker_type=models.get_type(models.MarkerType, marker),
|
|
private=private)
|
|
self.add_date(media, date)
|
|
media.save()
|
|
|
|
def add_media_detail(self, data):
|
|
(handle, gid, path, mime, desc,
|
|
attribute_list,
|
|
source_list,
|
|
note_list,
|
|
change,
|
|
date,
|
|
marker,
|
|
private) = data
|
|
try:
|
|
media = models.Media.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Media does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
self.add_note_list(media, note_list)
|
|
self.add_source_ref_list(media, source_list)
|
|
self.add_attribute_list(media, attribute_list)
|
|
|
|
def add_event(self, data):
|
|
(handle, gid, the_type, date, description, place_handle,
|
|
source_list, note_list, media_list, attribute_list,
|
|
change, marker, private) = data
|
|
event = models.Event(handle=handle,
|
|
gramps_id=gid,
|
|
event_type=models.get_type(models.EventType, the_type),
|
|
private=private,
|
|
marker_type=models.get_type(models.MarkerType, marker),
|
|
description=description,
|
|
last_changed=todate(change))
|
|
self.add_date(event, date)
|
|
event.save()
|
|
|
|
def add_event_detail(self, data):
|
|
(handle, gid, the_type, date, description, place_handle,
|
|
source_list, note_list, media_list, attribute_list,
|
|
change, marker, private) = data
|
|
try:
|
|
event = models.Event.objects.get(handle=handle)
|
|
except:
|
|
print >> sys.stderr, ("ERROR: Event does not exist: '%s'" %
|
|
handle)
|
|
return
|
|
self.add_place_ref(event, place_handle)
|
|
self.add_note_list(event, note_list)
|
|
self.add_attribute_list(event, attribute_list)
|
|
self.add_media_ref_list(event, media_list)
|
|
self.add_source_ref_list(event, source_list)
|
|
|