# Gramps - a GTK+/GNOME based genealogy program # # Copyright (C) 2009 Douglas S. Blank # # 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 import cPickle import base64 #------------------------------------------------------------------------ # # Gramps Modules # #------------------------------------------------------------------------ import webapp.grampsdb.models as models from django.contrib.contenttypes.models import ContentType import webapp 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 = dbdjango.DbDjango().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_next_id(self, obj, prefix): """ Get next gramps_id >>> dji.get_next_id(Person, "P") 'P0002' >>> dji.get_next_id(Media, "M") 'M2349' """ ids = [o["gramps_id"] for o in obj.objects.values("gramps_id")] count = 1 while "%s%04d" % (prefix, count) in ids: count += 1 return "%s%04d" % (prefix, count) def get_model(self, name): if hasattr(models, name.title()): return getattr(models, name.title()) else: raise AttributeError("no such model: '%s'" % name.title()) # ----------------------------------------------- # 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 map(self.pack_attribute, attribute_list) def get_primary_name(self, person): names = person.name_set.filter(preferred=True).order_by("order") if len(names) > 0: return gen.lib.Name.create(self.pack_name(names[0])) else: return gen.lib.Name() def get_alternate_names(self, person): names = person.name_set.filter(preferred=False).order_by("order") return [gen.lib.Name.create(self.pack_name(n)) for n in names] 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_source_datamap(self, source): return dict([map.key, map.value] for map in source.sourcedatamap_set.all()) def get_citation_datamap(self, citation): return dict([map.key, map.value] for map in citation.citationdatamap_set.all()) 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) return map(self.pack_media_ref, mediarefs) 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) return [noteref.ref_object.handle for noteref in noterefs] 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") return [self.pack_address(address, with_parish) for address in addresses] 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") return map(self.pack_child_ref, childrefs) def get_citation_list(self, obj): obj_type = ContentType.objects.get_for_model(obj) citationrefs = models.CitationRef.objects.filter(object_id=obj.id, object_type=obj_type).order_by("order") return [citationref.citation.handle for citationref in citationrefs] 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") return map(self.pack_event_ref, eventrefs) 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) private = event.private note_list = self.get_note_list(event) citation_list = self.get_citation_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, citation_list, note_list, media_list, attribute_list, change, 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.make_tag_list()), 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) citation_list = self.get_citation_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, citation_list, note_list, totime(family.last_changed), tuple(family.make_tag_list()), 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), repository.private) def get_citation(self, citation): note_list = self.get_note_list(citation) media_list = self.get_media_list(citation) datamap = self.get_citation_datamap(citation) date = self.get_date(citation) # I guess citations can have no source if citation.source: handle = citation.source.handle else: handle = None return (str(citation.handle), citation.gramps_id, date, citation.page, citation.confidence, handle, note_list, media_list, datamap, totime(citation.last_changed), citation.private) def get_source(self, source): note_list = self.get_note_list(source) media_list = self.get_media_list(source) datamap = self.get_source_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, source.private) def get_media(self, media): attribute_list = self.get_attribute_list(media) citation_list = self.get_citation_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, citation_list, note_list, totime(media.last_changed), date, tuple(media.make_tag_list()), 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) pcitation_list = self.get_citation_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 = person.death_ref_index birth_ref_index = person.birth_ref_index 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, pcitation_list, pnote_list, totime(person.last_changed), tuple(person.make_tag_list()), 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) citation_list = self.get_citation_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, citation_list, note_list, totime(place.last_changed), place.private) # --------------------------------- # Packers # --------------------------------- ## The packers build GRAMPS raw unserialized data. ## Reference packers def pack_child_ref(self, child_ref): citation_list = self.get_citation_list(child_ref) note_list = self.get_note_list(child_ref) return (child_ref.private, citation_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): citation_list = self.get_citation_list(personref) note_list = self.get_note_list(personref) return (personref.private, citation_list, note_list, personref.ref_object.handle, personref.description) def pack_media_ref(self, media_ref): citation_list = self.get_citation_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, citation_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) citation_list = self.get_citation_list(media_ref) return (media_ref.private, citation_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_citation(self, citation): handle = citation.handle gid = citation.gramps_id date = self.get_date(citation) page = citation.page confidence = citation.confidence source_handle = citation.source.handle note_list = self.get_note_list(citation) media_list = self.get_media_list(citation) datamap = self.get_citation_datamap(citation) changed = totime(citation.last_changed) private = citation.private return (handle, gid, date, page, confidence, source_handle, note_list, media_list, datamap, changed, private) def pack_address(self, address, with_parish): citation_list = self.get_citation_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, citation_list, note_list, date, location) def pack_lds(self, lds): citation_list = self.get_citation_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 (citation_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_source_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, source.private) def pack_name(self, name): citation_list = self.get_citation_list(name) note_list = self.get_note_list(name) date = self.get_date(name) return (name.private, citation_list, note_list, date, name.first_name, name.make_surname_list(), name.suffix, name.title, tuple(name.name_type), name.group_as, name.sort_as.val, name.display_as.val, name.call, name.nick, name.famnick) def pack_location(self, loc, with_parish): if with_parish: return ((loc.street, loc.locality, loc.city, loc.county, loc.state, loc.country, loc.postal, loc.phone), loc.parish) else: return (loc.street, loc.locality, 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): citation_list = self.get_citation_list(attribute) note_list = self.get_note_list(attribute) return (attribute.private, citation_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_citation_list(self, obj, citation_list): for citation_handle in citation_list: self.add_citation_ref(obj, citation_handle) 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_surname_list(self, name, surname_list): order = 1 for data in surname_list: (surname_text, prefix, primary, origin_type, connector) = data surname = models.Surname() surname.surname = surname_text surname.prefix = prefix surname.primary = primary surname.name_origin_type = models.get_type(models.NameOriginType, origin_type) surname.connector = connector surname.name = name surname.order = order surname.save() order += 1 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_default(self, obj, person, private=False, desc=None): count = person.references.count() person_ref = models.PersonRef(referenced_by=obj, ref_object=person, private=private, order=count + 1, description=desc) person_ref.save() def add_person_ref(self, obj, person_ref_data): (private, citation_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_citation_list(person_ref, citation_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_default(self, obj, media, private=False, role=None): 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() def add_media_ref(self, obj, media_ref_data): (private, citation_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_citation_list(media_ref, citation_list) def add_citation_ref(self, obj, handle): try: citation = models.Citation.objects.get(handle=handle) except: print >> sys.stderr, ("ERROR: Citation does not exist: '%s'" % handle) return count = models.CitationRef.objects.filter(object_id=obj.id,object_type=obj).count() citation_ref = models.CitationRef(private=False, referenced_by=obj, citation=citation, order=count + 1) citation_ref.save() def add_citation(self, citation_data): (handle, gid, date, page, confidence, source_handle, note_list, media_list, datamap, changed, private) = citation_data citation = models.Citation( handle=handle, gramps_id=gid, private=private, last_changed=todate(changed), confidence=confidence, page=page) citation.save() def add_citation_detail(self, citation_data): (handle, gid, date, page, confidence, source_handle, note_list, media_list, datamap, change, private) = citation_data try: citation = models.Citation.objects.get(handle=handle) except: print >> sys.stderr, ("ERROR: Citation does not exist: '%s'" % handle) return try: source = models.Source.objects.get(handle=source_handle) except: print >> sys.stderr, ("ERROR: Source does not exist: '%s'" % source_handle) return citation.source = source self.add_date(citation, date) citation.save() self.add_note_list(citation, note_list) self.add_media_ref_list(citation, media_list) self.add_citation_datamap_dict(citation, datamap) def add_child_ref(self, obj, data): (private, citation_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_citation_list(child_ref, citation_list) self.add_note_list(child_ref, note_list) def add_event_ref_default(self, obj, event, private=False, role=models.EventRoleType._DEFAULT): 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() 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_source_datamap_dict(self, source, datamap_dict): for key in datamap_dict: value = datamap_dict[key] datamap = models.SourceDatamap(key=key, value=value) datamap.source = source datamap.save() def add_citation_datamap_dict(self, citation, datamap_dict): for key in datamap_dict: value = datamap_dict[key] datamap = models.CitationDatamap(key=key, value=value) datamap.citation = citation datamap.save() def add_lds(self, field, obj, data, order): (lcitation_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_citation_list(lds, lcitation_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, acitation_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_citation_list(address, acitation_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, citation_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_citation_list(attribute, citation_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, citation_list, note_list, date, first_name, surname_list, suffix, title, name_type, group_as, sort_as, display_as, call, nick, famnick) = 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.suffix = suffix name.title = title name.name_type = models.get_type(models.NameType, name_type) 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 name.nick = nick name.famnick = famnick # we know person exists # needs to have an ID for key name.person = person self.add_date(name, date) name.save() self.add_surname_list(name, surname_list) self.add_note_list(name, note_list) self.add_citation_list(name, citation_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 pcitation_list, # 15 pnote_list, # 16 change, # 17 tag_list, # 18 private, # 19 person_ref_list, # 20 ) = data person = models.Person(handle=handle, gramps_id=gid, last_changed=todate(change), private=private, gender_type=models.get_type(models.GenderType, gender)) #person.cache = base64.encodestring(cPickle.dumps(data)) 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 pcitation_list, # 15 pnote_list, # 16 change, # 17 tag_list, # 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_citation_list(person, pcitation_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) all_events = self.get_event_ref_list(person) if events: person.birth = events[0].ref_object person.birth_ref_index = lookup_role_index(models.EventType.BIRTH, all_events) 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.death_ref_index = lookup_role_index(models.EventType.DEATH, all_events) 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, tag_list, 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, note_type=models.get_type(models.NoteType, note_type)) #n.cache = base64.encodestring(cPickle.dumps(data)) 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, citation_list, note_list, change, tag_list, private) = data family = models.Family(handle=handle, gramps_id=gid, family_rel_type = models.get_type(models.FamilyRelType, the_type), last_changed=todate(change), private=private) #family.cache = base64.encodestring(cPickle.dumps(data)) 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, citation_list, note_list, change, tag_list, 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_citation_list(family, citation_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, 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.cache = base64.encodestring(cPickle.dumps(data)) source.save() def add_source_detail(self, data): (handle, gid, title, author, pubinfo, note_list, media_list, abbrev, change, datamap, reporef_list, 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_source_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, private) = data repository = models.Repository(handle=handle, gramps_id=gid, last_changed=todate(change), private=private, repository_type=models.get_type(models.RepositoryType, the_type), name=name) #repository.cache = base64.encodestring(cPickle.dumps(data)) repository.save() def add_repository_detail(self, data): (handle, gid, the_type, name, note_list, address_list, url_list, change, 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): # location now has 8 items # street, locality, city, county, state, # country, postal, phone, parish if location_data == None: return if len(location_data) == 8: (street, locality, city, county, state, country, postal, phone) = location_data parish = None elif len(location_data) == 2: ((street, locality, city, county, state, country, postal, phone), parish) = location_data else: print >> sys.stderr, ("ERROR: unknown location: '%s'" % location_data) (street, locality, city, county, state, country, postal, phone, parish) = \ ("", "", "", "", "", "", "", "", "") location = models.Location(street = street, locality = locality, 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, citation_list, note_list, change, private) = data place = models.Place(handle=handle, gramps_id=gid, title=title, long=long, lat=lat, last_changed=todate(change), private=private) #place.cache = base64.encodestring(cPickle.dumps(data)) place.save() def add_place_detail(self, data): (handle, gid, title, long, lat, main_loc, alt_location_list, url_list, media_list, citation_list, note_list, change, 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_citation_list(place, citation_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_tag(self, data): print "FIXME: libdjango.add_tag()" def add_media(self, data): (handle, gid, path, mime, desc, attribute_list, citation_list, note_list, change, date, tag_list, private) = data media = models.Media(handle=handle, gramps_id=gid, path=path, mime=mime, desc=desc, last_changed=todate(change), private=private) #media.cache = base64.encodestring(cPickle.dumps(data)) self.add_date(media, date) media.save() def add_media_detail(self, data): (handle, gid, path, mime, desc, attribute_list, citation_list, note_list, change, date, tag_list, 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_citation_list(media, citation_list) self.add_attribute_list(media, attribute_list) def add_event(self, data): (handle, gid, the_type, date, description, place_handle, citation_list, note_list, media_list, attribute_list, change, private) = data event = models.Event(handle=handle, gramps_id=gid, event_type=models.get_type(models.EventType, the_type), private=private, description=description, last_changed=todate(change)) #event.cache = base64.encodestring(cPickle.dumps(data)) self.add_date(event, date) event.save() def add_event_detail(self, data): (handle, gid, the_type, date, description, place_handle, citation_list, note_list, media_list, attribute_list, change, 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_citation_list(event, citation_list) def get_raw(self, item): """ Build and return the raw, serialized data of an object. """ if isinstance(item, models.Person): raw = self.get_person(item) elif isinstance(item, models.Family): raw = self.get_family(item) elif isinstance(item, models.Place): raw = self.get_place(item) elif isinstance(item, models.Media): raw = self.get_media(item) elif isinstance(item, models.Source): raw = self.get_source(item) elif isinstance(item, models.Citation): raw = self.get_citation(item) elif isinstance(item, models.Repository): raw = self.get_repository(item) elif isinstance(item, models.Note): raw = self.get_note(item) elif isinstance(item, models.Event): raw = self.get_event(item) else: raise Exception("Don't know how to get raw '%s'" % type(item)) return raw def reset_cache(self, item): """ Resets the cache version of an object, but doesn't save it to the database. """ raw = self.get_raw(item) item.cache = base64.encodestring(cPickle.dumps(raw)) def rebuild_cache(self, item): """ Resets the cache version of an object, and saves it to the database. """ raw = self.get_raw(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() def rebuild_caches(self, callback=None): """ Call this to rebuild the caches for all primary models. """ if not callable(callback): callback = lambda (percent): None # dummy callback(0) count = 0.0 total = (self.Note.all().count() + self.Person.all().count() + self.Event.all().count() + self.Family.all().count() + self.Repository.all().count() + self.Place.all().count() + self.Media.all().count() + self.Source.all().count()) for item in self.Person.all(): raw = self.get_person(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() callback(100 * count/total) count += 1 for item in self.Family.all(): raw = self.get_family(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() callback(100 * count/total) count += 1 for item in self.Source.all(): raw = self.get_source(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() callback(100 * count/total) count += 1 for item in self.Event.all(): raw = self.get_event(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() callback(100 * count/total) count += 1 for item in self.Repository.all(): raw = self.get_repository(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() callback(100 * count/total) count += 1 for item in self.Place.all(): raw = self.get_place(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() callback(100 * count/total) count += 1 for item in self.Media.all(): raw = self.get_media(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() callback(100 * count/total) count += 1 for item in self.Note.all(): raw = self.get_note(item) item.cache = base64.encodestring(cPickle.dumps(raw)) item.save() callback(100 * count/total) count += 1 callback(100)