示例#1
0
 def add_note(self, note, trans, set_gid=True):
     if not note.handle:
         note.handle = create_id()
     if not note.gramps_id and set_gid:
         note.gramps_id = self.find_next_note_gramps_id()
     self.commit_note(note, trans)
     return note.handle
示例#2
0
 def add_place(self, place, trans, set_gid=True):
     if not place.handle:
         place.handle = create_id()
     if not place.gramps_id and set_gid:
         place.gramps_id = self.find_next_place_gramps_id()
     self.commit_place(place, trans)
     return place.handle
示例#3
0
 def add_source(self, source, trans, set_gid=True):
     if not source.handle:
         source.handle = create_id()
     if not source.gramps_id and set_gid:
         source.gramps_id = self.find_next_source_gramps_id()
     self.commit_source(source, trans)
     return source.handle
 def create_event(self, description=_("Estimated date"),
                  type=None, date=None, source=None,
                  note_text="", modifier=None):
     event = Event()
     event.set_description(description)
     note = Note()
     note.handle = create_id()
     note.type.set(NoteType.EVENT)
     note.set(note_text)
     self.db.add_note(note, self.trans)
     event.add_note(note.handle)
     if type:
         event.set_type(EventType(type))
     if date:
         if modifier:
             date.set_modifier(modifier)
         date.set_quality(Date.QUAL_ESTIMATED)
         date.set_yr_mon_day(date.get_year(), 0, 0)
         event.set_date_object(date)
     if source:
         citation = Citation()
         citation.set_reference_handle(source.get_handle())
         self.db.add_citation(citation, self.trans)
         event.add_citation(citation.get_handle())
         self.db.commit_source(source, self.trans)
     self.db.add_event(event, self.trans)
     return event
示例#5
0
def export_date(db, from_type, from_handle, data):
    if data is None: return
    (calendar, modifier, quality, dateval, text, sortval, newyear) = data
    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 ("ERROR: date dateval format", dateval)
    date_handle = create_id()
    db.query("""INSERT INTO date (
                  handle,
                  calendar, 
                  modifier, 
                  quality,
                  day1, 
                  month1, 
                  year1, 
                  slash1,
                  day2, 
                  month2, 
                  year2, 
                  slash2,
                  text, 
                  sortval, 
                  newyear) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 
                                   ?, ?, ?, ?, ?, ?);""",
             date_handle, calendar, modifier, quality, 
             day1, month1, year1, slash1, 
             day2, month2, year2, slash2,
             text, sortval, newyear)
    # And finally, make a link from parent to new object
    export_link(db, from_type, from_handle, "date", date_handle)
示例#6
0
 def add_citation(self, citation, trans, set_gid=True):
     if not citation.handle:
         citation.handle = create_id()
     if not citation.gramps_id and set_gid:
         citation.gramps_id = self.find_next_citation_gramps_id()
     self.commit_citation(citation, trans)
     return citation.handle
示例#7
0
def export_location(db, from_type, from_handle, location):
    if location == None: return
    if len(location) == 8:
        (street, locality, city, county, state, country, postal, phone) = location 
        parish = None
    elif len(location) == 2:
        ((street, locality, city, county, state, country, postal, phone), parish) = location 
    else:
        print("ERROR: what kind of location is this?", location)
        return
    handle = create_id()
    db.query("""INSERT INTO location (
                 handle,
                 street, 
                 locality,
                 city, 
                 county, 
                 state, 
                 country, 
                 postal, 
                 phone,
                 parish) VALUES (?,?,?,?,?,?,?,?,?,?);""",
             handle, street, locality, city, county, state, country, postal, phone, parish)
    # finally, link the parent to the address
    export_link(db, from_type, from_handle, "location", handle)
 def create_event(self, description=_("Estimated date"),
                  type=None, date=None, source=None,
                  note_text="", modifier=None):
     event = Event()
     event.set_description(description)
     note = Note()
     note.handle = create_id()
     note.type.set(NoteType.EVENT)
     note.set(note_text)
     self.db.add_note(note, self.trans)
     event.add_note(note.handle)
     if type:
         event.set_type(EventType(type))
     if date:
         if modifier:
             date.set_modifier(modifier)
         date.set_quality(Date.QUAL_ESTIMATED)
         date.set_yr_mon_day(date.get_year(), 0, 0)
         event.set_date_object(date)
     if source:
         citation = Citation()
         citation.set_reference_handle(source.get_handle())
         self.db.add_citation(citation, self.trans)
         event.add_citation(citation.get_handle())
         self.db.commit_source(source, self.trans)
     self.db.add_event(event, self.trans)
     return event
示例#9
0
def export_date(db, from_type, from_handle, data):
    if data is None: return
    (calendar, modifier, quality, dateval, text, sortval, newyear) = data
    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 ("ERROR: date dateval format", dateval)
    date_handle = create_id()
    db.query(
        """INSERT INTO date (
                  handle,
                  calendar,
                  modifier,
                  quality,
                  day1,
                  month1,
                  year1,
                  slash1,
                  day2,
                  month2,
                  year2,
                  slash2,
                  text,
                  sortval,
                  newyear) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,
                                   ?, ?, ?, ?, ?, ?);""", date_handle,
        calendar, modifier, quality, day1, month1, year1, slash1, day2, month2,
        year2, slash2, text, sortval, newyear)
    export_link(db, from_type, from_handle, "date", date_handle)
示例#10
0
    def _local_init(self):
        """
        Performs basic initialization, including setting up widgets and the
        glade interface.

        Local initialization function.
        This is called by the base class of EditPrimary, and overridden here.

        """
        self.width_key = "interface.person-width"
        self.height_key = "interface.person-height"
        self.pname = self.obj.get_primary_name()
        self.should_guess_gender = not self.obj.get_gramps_id() and self.obj.get_gender() == Person.UNKNOWN

        self.added = self.obj.handle is None
        if self.added:
            self.obj.handle = create_id()

        self.top = Glade()

        self.set_window(self.top.toplevel, None, self.get_menu_title())

        self.obj_photo = self.top.get_object("personPix")
        self.frame_photo = self.top.get_object("frame5")
        self.eventbox = self.top.get_object("eventbox1")
        self.singsurnfr = SingSurn(self.top)
        self.multsurnfr = self.top.get_object("hboxmultsurnames")
        self.singlesurn_active = True
        self.surntab = SurnameTab(
            self.dbstate, self.uistate, self.track, self.obj.get_primary_name(), on_change=self._changed_name
        )

        self.set_contexteventbox(self.top.get_object("eventboxtop"))
示例#11
0
def export_place_ref(db, handle, place_ref):
    (to_place_handle, date) = place_ref
    ref_handle = create_id()
    db.query("insert into place_ref"
             " (handle, from_place_handle, to_place_handle) VALUES (?, ?, ?);",
             ref_handle, handle, to_place_handle)
    export_date(db, "place_ref", ref_handle, date)
示例#12
0
def export_place_name(db, handle, place_name):
    # alt_place_name_list = [('Ohio', None, ''), ...] [(value, date, lang)...]
    (value, date, lang) = place_name
    ref_handle = create_id()
    db.query("insert into place_name (handle, from_handle, value, lang)"
             " VALUES (?, ?, ?, ?);", ref_handle, handle, value, lang)
    export_date(db, "place_name", ref_handle, date)
示例#13
0
def export_name(db, from_type, from_handle, primary, data):
    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
        handle = create_id()
        db.query(
            """INSERT into name (
                  handle,
                  primary_name,
                  private,
                  first_name,
                  suffix,
                  title,
                  name_type0,
                  name_type1,
                  group_as,
                  sort_as,
                  display_as,
                  call,
                  nick,
                  famnick
                    ) values (?, ?, ?, ?, ?, ?, ?,
                              ?, ?, ?, ?, ?, ?, ?);""", handle, primary,
            private, first_name, suffix, title, name_type[0], name_type[1],
            group_as, sort_as, display_as, call, nick, famnick)
        export_surname(db, handle, surname_list)
        export_date(db, "name", handle, date)
        export_list(db, "name", handle, "note", note_list)
        export_citation_list(db, "name", handle, citation_list)
        # And finally, make a link from parent to new object
        export_link(db, from_type, from_handle, "name", handle)
示例#14
0
 def add_event(self, event, trans, set_gid=True):
     if not event.handle:
         event.handle = create_id()
     if not event.gramps_id and set_gid:
         event.gramps_id = self.find_next_event_gramps_id()
     self.commit_event(event, trans)
     return event.handle
示例#15
0
 def add_person(self, person, trans, set_gid=True):
     if not person.handle:
         person.handle = create_id()
     if not person.gramps_id and set_gid:
         person.gramps_id = self.find_next_person_gramps_id()
     self.commit_person(person, trans)
     return person.handle
示例#16
0
def export_name(db, from_type, from_handle, primary, data):
    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
        handle = create_id()
        db.query("""INSERT into name (
                  handle,
                  primary_name,
                  private, 
                  first_name, 
                  suffix, 
                  title, 
                  name_type0, 
                  name_type1, 
                  group_as, 
                  sort_as,
                  display_as, 
                  call,
                  nick,
                  famnick
                    ) values (?, ?, ?, ?, ?, ?, ?,  
                              ?, ?, ?, ?, ?, ?, ?);""",
                 handle, primary, private, first_name, suffix, title,
                 name_type[0], name_type[1], group_as, 
                 sort_as, display_as, call, nick, famnick)
        export_surname(db, handle, surname_list)
        export_date(db, "name", handle, date) 
        export_list(db, "name", handle, "note", note_list)
        export_citation_list(db, "name", handle, citation_list)
        # And finally, make a link from parent to new object
        export_link(db, from_type, from_handle, "name", handle)
示例#17
0
 def add_family(self, family, trans, set_gid=True):
     if not family.handle:
         family.handle = create_id()
     if not family.gramps_id and set_gid:
         family.gramps_id = self.find_next_family_gramps_id()
     self.commit_family(family, trans)
     return family.handle
示例#18
0
def add_object(
    db_handle: DbWriteBase,
    obj: GrampsObject,
    trans: DbTxn,
    fail_if_exists: bool = False,
):
    """Commit a Gramps object to the database.

    If `fail_if_exists` is true, raises a ValueError if an object of
    the same type exists with the same handle or same Gramps ID.

    In the case of a family object, also updates the referenced handles
    in the corresponding person objects.
    """
    if db_handle.readonly:
        # adding objects is forbidden on a read-only db!
        abort(HTTPStatus.FORBIDDEN)
    obj_class = obj.__class__.__name__.lower()
    if fail_if_exists:
        if has_handle(db_handle, obj):
            raise ValueError("Handle already exists.")
        if has_gramps_id(db_handle, obj):
            raise ValueError("Gramps ID already exists.")
    try:
        add_method = db_handle.method("add_%s", obj_class)
        if obj_class == "family":
            # need to add handle if not present yet!
            if not obj.handle:
                obj.handle = create_id()
            add_family_update_refs(db_handle=db_handle, obj=obj, trans=trans)
        return add_method(obj, trans)
    except AttributeError:
        raise ValueError("Database does not support writing.")
示例#19
0
 def add_repository(self, repository, trans, set_gid=True):
     if not repository.handle:
         repository.handle = create_id()
     if not repository.gramps_id and set_gid:
         repository.gramps_id = self.find_next_repository_gramps_id()
     self.commit_repository(repository, trans)
     return repository.handle
示例#20
0
    def _local_init(self):
        """
        Performs basic initialization, including setting up widgets and the
        glade interface.

        Local initialization function.
        This is called by the base class of EditPrimary, and overridden here.

        """
        self.pname = self.obj.get_primary_name()
        self.should_guess_gender = (not self.obj.get_gramps_id() and
                                    self.obj.get_gender () ==
                                    Person.UNKNOWN)

        self.added = self.obj.handle is None
        if self.added:
            self.obj.handle = create_id()

        self.top = Glade()

        self.set_window(self.top.toplevel, None,
                        self.get_menu_title())
        self.setup_configs('interface.person', 750, 550)

        self.obj_photo = self.top.get_object("personPix")
        self.frame_photo = self.top.get_object("frame5")
        self.eventbox = self.top.get_object("eventbox1")
        self.singsurnfr = SingSurn(self.top)
        self.multsurnfr = self.top.get_object("hboxmultsurnames")
        self.singlesurn_active = True

        self.set_contexteventbox(self.top.get_object("eventboxtop"))
示例#21
0
def export_location(db, from_type, from_handle, location):
    if location == None: return
    if len(location) == 8:
        (street, locality, city, county, state, country, postal,
         phone) = location
        parish = None
    elif len(location) == 2:
        ((street, locality, city, county, state, country, postal, phone),
         parish) = location
    else:
        print("ERROR: what kind of location is this?", location)
        return
    handle = create_id()
    db.query(
        """INSERT INTO location (
                 handle,
                 street,
                 locality,
                 city,
                 county,
                 state,
                 country,
                 postal,
                 phone,
                 parish) VALUES (?,?,?,?,?,?,?,?,?,?);""", handle, street,
        locality, city, county, state, country, postal, phone, parish)
    # finally, link the parent to the address
    export_link(db, from_type, from_handle, "location", handle)
示例#22
0
    def _local_init(self):
        self.added = self.obj.handle is None
        if self.added:
            self.obj.handle = create_id()

        self.build_interface()
        self.load_data()
示例#23
0
def export_place_ref(db, handle, place_ref):
    (to_place_handle, date) = place_ref
    ref_handle = create_id()
    db.query("""insert into place_ref (handle, from_place_handle, to_place_handle) 
                   VALUES (?, ?, ?)
    ;""", ref_handle, handle, to_place_handle)
    export_date(db, "place_ref", ref_handle, date)
示例#24
0
    def _local_init(self):
        self.added = self.obj.handle is None
        if self.added:
            self.obj.handle = create_id()

        self.build_interface()
        self.load_data()
示例#25
0
def export_place_name(db, handle, place_name):
    # alt_place_name_list = [('Ohio', None, ''), ...] [(value, date, lang)...]
    (value, date, lang) = place_name
    ref_handle = create_id()
    db.query("""insert into place_name (handle, from_handle, value, lang) 
                   VALUES (?, ?, ?, ?)
    ;""", ref_handle, handle, value, lang)
    export_date(db, "place_name", ref_handle, date)
示例#26
0
 def buildTag(self, tname, thandle=None):
     if thandle == None:
         thandle = id.create_id()  # 26-merkkinen tunniste
     tag = Tag()
     tag.set_name(tname)
     tag.set_change_time(self.chgtime)
     #        tag.set_color("#EF2929")
     tag.set_handle(thandle)
     #        print ("Tag ") ; print(tag.to_struct())
     return ([tag, thandle])
示例#27
0
def export_datamap_dict(db, from_type, from_handle, datamap):
    for key_field in datamap:
        handle = create_id()
        value_field = datamap[key_field]
        db.query("""INSERT INTO datamap (
                      handle,
                      key_field, 
                      value_field) values (?, ?, ?)""",
                 handle, key_field, value_field)
        export_link(db, from_type, from_handle, "datamap", handle)
示例#28
0
def export_address(db, from_type, from_handle, address):
    (private, acitation_list, anote_list, date, location) = address
    addr_handle = create_id()
    db.query("""INSERT INTO address (
                handle,
                private) VALUES (?, ?);""", addr_handle, private)
    export_location(db, "address", addr_handle, location)
    export_date(db, "address", addr_handle, date)
    export_list(db, "address", addr_handle, "note", anote_list)
    export_citation_list(db, "address", addr_handle, acitation_list)
    # finally, link the parent to the address
    export_link(db, from_type, from_handle, "address", addr_handle)
示例#29
0
def export_address(db, from_type, from_handle, address):
    (private, acitation_list, anote_list, date, location) = address
    addr_handle = create_id()
    db.query("""INSERT INTO address (
                handle,
                private) VALUES (?, ?);""", addr_handle, private)
    export_location(db, "address", addr_handle, location)
    export_date(db, "address", addr_handle, date)
    export_list(db, "address", addr_handle, "note", anote_list) 
    export_citation_list(db, "address", addr_handle, acitation_list)
    # finally, link the parent to the address
    export_link(db, from_type, from_handle, "address", addr_handle)
示例#30
0
 def add_object(self, obj, transaction, set_gid=True):
     """
     Add a MediaObject to the database, assigning internal IDs if they have
     not already been defined.
     
     If not set_gid, then gramps_id is not set.
     """
     if not obj.handle:
         obj.handle = create_id()
     if not obj.gramps_id and set_gid:
         obj.gramps_id = self.find_next_object_gramps_id()
     self.commit_media_object(obj, transaction)
     return obj.handle
示例#31
0
def export_markup(db, from_type, from_handle, markup_code0, markup_code1,
                  value, start_stop_list):
    markup_handle = create_id()
    db.query(
        """INSERT INTO markup (
                 handle,
                 markup0,
                 markup1,
                 value,
                 start_stop_list) VALUES (?,?,?,?,?);""", markup_handle,
        markup_code0, markup_code1, value, start_stop_list)
    # And finally, make a link from parent to new object
    export_link(db, from_type, from_handle, "markup", markup_handle)
示例#32
0
def export_markup(db, from_type, from_handle,  markup_code0, markup_code1, value, 
                  start_stop_list):
    markup_handle = create_id()
    db.query("""INSERT INTO markup (
                 handle, 
                 markup0, 
                 markup1, 
                 value, 
                 start_stop_list) VALUES (?,?,?,?,?);""",
             markup_handle, markup_code0, markup_code1, value, 
             start_stop_list)
    # And finally, make a link from parent to new object
    export_link(db, from_type, from_handle, "markup", markup_handle)
示例#33
0
def export_lds(db, from_type, from_handle, data):
    (lcitation_list, lnote_list, date, type, place,
     famc, temple, status, private) = data
    lds_handle = create_id()
    db.query("""INSERT into lds (handle, type, place, famc, temple, status, private) 
             VALUES (?,?,?,?,?,?,?);""",
             lds_handle, type, place, famc, temple, status, private)
    export_link(db, "lds", lds_handle, "place", place)
    export_list(db, "lds", lds_handle, "note", lnote_list)
    export_date(db, "lds", lds_handle, date)
    export_citation_list(db, "lds", lds_handle, lcitation_list)
    # And finally, make a link from parent to new object
    export_link(db, from_type, from_handle, "lds", lds_handle)
示例#34
0
def export_attribute(db, from_type, from_handle, attribute):
    (private, citation_list, note_list, the_type, value) = attribute
    handle = create_id()
    db.query("""INSERT INTO attribute (
                 handle,
                 the_type0,
                 the_type1,
                 value,
                 private) VALUES (?,?,?,?,?);""",
             handle, the_type[0], the_type[1], value, private)
    export_citation_list(db, "attribute", handle, citation_list)
    export_list(db, "attribute", handle, "note", note_list)
    # finally, link the parent to the address
    export_link(db, from_type, from_handle, "attribute", handle)
示例#35
0
def export_lds(db, from_type, from_handle, data):
    (lcitation_list, lnote_list, date, type, place, famc, temple, status,
     private) = data
    lds_handle = create_id()
    db.query(
        """INSERT into lds (handle, type, place, famc, temple, status, private)
             VALUES (?,?,?,?,?,?,?);""", lds_handle, type, place, famc, temple,
        status, private)
    export_link(db, "lds", lds_handle, "place", place)
    export_list(db, "lds", lds_handle, "note", lnote_list)
    export_date(db, "lds", lds_handle, date)
    export_citation_list(db, "lds", lds_handle, lcitation_list)
    # And finally, make a link from parent to new object
    export_link(db, from_type, from_handle, "lds", lds_handle)
示例#36
0
def export_attribute(db, from_type, from_handle, attribute):
    (private, citation_list, note_list, the_type, value) = attribute
    handle = create_id()
    db.query("""INSERT INTO attribute (
                 handle,
                 the_type0, 
                 the_type1, 
                 value, 
                 private) VALUES (?,?,?,?,?);""",
             handle, the_type[0], the_type[1], value, private)
    export_citation_list(db, "attribute", handle, citation_list)
    export_list(db, "attribute", handle, "note", note_list)
    # finally, link the parent to the address
    export_link(db, from_type, from_handle, "attribute", handle)
示例#37
0
def export_child_ref_list(db, from_type, from_handle, to_type, ref_list):
    for child_ref in ref_list:
        # family -> child_ref
        # (False, [], [], u'b305e96e39652d8f08c', (1, u''), (1, u''))
        (private, citation_list, note_list, ref, frel, mrel) = child_ref
        handle = create_id()
        db.query(
            """INSERT INTO child_ref (handle,
                     ref, frel0, frel1, mrel0, mrel1, private)
                        VALUES (?, ?, ?, ?, ?, ?, ?);""", handle, ref, frel[0],
            frel[1], mrel[0], mrel[1], private)
        export_citation_list(db, "child_ref", handle, citation_list)
        export_list(db, "child_ref", handle, "note", note_list)
        # And finally, make a link from parent to new object
        export_link(db, from_type, from_handle, "child_ref", handle)
示例#38
0
def export_surname(db, name_handle, surname_list):
    for data in surname_list:
        surname_handle = create_id()
        (surname, prefix, primary, origin_type, connector) = data
        db.query("""INSERT INTO surname (
                  handle,
                  surname,
                  prefix,
                  primary_surname,
                  origin_type0,
                  origin_type1,
                  connector) VALUES (?,?,?,?,?,?,?);""",
                 surname_handle, surname, prefix, primary, origin_type[0],
                 origin_type[1], connector)
        export_link(db, "name", name_handle, "surname", surname_handle)
示例#39
0
def export_child_ref_list(db, from_type, from_handle, to_type, ref_list):
    for child_ref in ref_list:
        # family -> child_ref
        # (False, [], [], u'b305e96e39652d8f08c', (1, u''), (1, u''))
        (private, citation_list, note_list, ref, frel, mrel) = child_ref
        handle = create_id()
        db.query("""INSERT INTO child_ref (handle, 
                     ref, frel0, frel1, mrel0, mrel1, private)
                        VALUES (?, ?, ?, ?, ?, ?, ?);""",
                 handle, ref, frel[0], frel[1], 
                 mrel[0], mrel[1], private)
        export_citation_list(db, "child_ref", handle, citation_list)
        export_list(db, "child_ref", handle, "note", note_list)
        # And finally, make a link from parent to new object
        export_link(db, from_type, from_handle, "child_ref", handle)
def export_person_ref_list(db, from_type, from_handle, person_ref_list):
    for person_ref in person_ref_list:
        (private, citation_list, note_list, handle, desc) = person_ref
        ref_handle = create_id()
        db.query(
            """INSERT INTO person_ref (
                    handle,
                    ref,
                    description,
                    private) VALUES (?, ?, ?, ?);""", ref_handle, handle, desc,
            private)
        export_list(db, "person_ref", ref_handle, "note", note_list)
        export_citation_list(db, "person_ref", ref_handle, citation_list)
        # And finally, make a link from parent to new object
        export_link(db, from_type, from_handle, "person_ref", ref_handle)
示例#41
0
def export_event_ref(db, from_type, from_handle, event_ref):
    (private, note_list, attribute_list, ref, role) = event_ref
    handle = create_id()
    db.query(
        """insert INTO event_ref (
                 handle,
                 ref,
                 role0,
                 role1,
                 private) VALUES (?,?,?,?,?);""", handle, ref, role[0],
        role[1], private)
    export_list(db, "event_ref", handle, "note", note_list)
    export_attribute_list(db, "event_ref", handle, attribute_list)
    # finally, link this to parent
    export_link(db, from_type, from_handle, "event_ref", handle)
示例#42
0
def export_surname(db, name_handle, surname_list):
    for data in surname_list:
        surname_handle = create_id()
        (surname, prefix, primary, origin_type, connector) = data
        db.query("""INSERT INTO surname (
                  handle,
                  surname,
                  prefix,
                  primary_surname,
                  origin_type0,
                  origin_type1,
                  connector) VALUES (?,?,?,?,?,?,?);""",
                 surname_handle, surname, prefix, primary, origin_type[0],
                 origin_type[1], connector)
        export_link(db, "name", name_handle, "surname", surname_handle)
示例#43
0
    def buildRepository(self, ridno, rname, tag, rtype, rhandle=None):
        if rhandle == None:
            rhandle = id.create_id()  # 26-merkkinen tunniste
        repositoryType = RepositoryType()
        repositoryType.set(rtype)

        repository = Repository()
        repository.set_type(repositoryType)
        repository.set_handle(rhandle)
        repository.set_gramps_id(ridno)
        repository.set_name(rname)
        repository.set_change_time(self.chgtime)
        #       repository.set_color("#000000")
        repository.add_tag(tag.get_handle())
        #        print ("Repository ") ; print(repository.to_struct())
        return ([repository, rhandle])
示例#44
0
def export_url_list(db, from_type, from_handle, urls):
    for url in urls:
        # (False, u'http://www.gramps-project.org/', u'loleach', (0, u'kaabgo'))
        (private, path, desc, type) = url
        handle = create_id()
        db.query(
            """insert INTO url (
                 handle,
                 path,
                 desc,
                 type0,
                 type1,
                 private) VALUES (?, ?, ?, ?, ?, ?);
                 """, handle, path, desc, type[0], type[1], private)
        # finally, link this to parent
        export_link(db, from_type, from_handle, "url", handle)
示例#45
0
def export_repository_ref_list(db, from_type, from_handle, reporef_list):
    for repo in reporef_list:
        (note_list, ref, call_number, source_media_type, private) = repo
        handle = create_id()
        db.query(
            """insert INTO repository_ref (
                     handle,
                     ref,
                     call_number,
                     source_media_type0,
                     source_media_type1,
                     private) VALUES (?,?,?,?,?,?);""", handle, ref,
            call_number, source_media_type[0], source_media_type[1], private)
        export_list(db, "repository_ref", handle, "note", note_list)
        # finally, link this to parent
        export_link(db, from_type, from_handle, "repository_ref", handle)
示例#46
0
 def get_or_create_family(self, family_ref, husband, wife):
     "Return the family object for the give family ID."
     # if a gramps_id and exists:
     LOG.debug("get_or_create_family")
     if family_ref.startswith("[") and family_ref.endswith("]"):
         id_ = self.db.fid2user_format(family_ref[1:-1])
         family = self.db.get_family_from_gramps_id(id_)
         if family:
             # don't delete, only add
             fam_husband_handle = family.get_father_handle()
             fam_wife_handle = family.get_mother_handle()
             if husband:
                 if husband.get_handle() != fam_husband_handle:
                     # this husband is not the same old one! Add him!
                     family.set_father_handle(husband.get_handle())
             if wife:
                 if wife.get_handle() != fam_wife_handle:
                     # this wife is not the same old one! Add her!
                     family.set_mother_handle(wife.get_handle())
             LOG.debug("   returning existing family")
             return family
     # if not, create one:
     family = Family()
     # was marked with a gramps_id, but didn't exist, so we'll use it:
     if family_ref.startswith("[") and family_ref.endswith("]"):
         id_ = self.db.fid2user_format(family_ref[1:-1])
         family.set_gramps_id(id_)
     # add it:
     family.set_handle(create_id())
     if self.default_tag:
         family.add_tag(self.default_tag.handle)
     if husband:
         family.set_father_handle(husband.get_handle())
         husband.add_family_handle(family.get_handle())
     if wife:
         family.set_mother_handle(wife.get_handle())
         wife.add_family_handle(family.get_handle())
     if husband and wife:
         family.set_relationship(FamilyRelType.MARRIED)
     self.db.add_family(family, self.trans)
     if husband:
         self.db.commit_person(husband, self.trans)
     if wife:
         self.db.commit_person(wife, self.trans)
     self.fam_count += 1
     return family
示例#47
0
def export_event_ref(db, from_type, from_handle, event_ref):
    (private, note_list, attribute_list, ref, role) = event_ref
    handle = create_id()
    db.query("""insert INTO event_ref (
                 handle, 
                 ref, 
                 role0, 
                 role1, 
                 private) VALUES (?,?,?,?,?);""",
             handle, 
             ref, 
             role[0], 
             role[1], 
             private) 
    export_list(db, "event_ref", handle, "note", note_list)
    export_attribute_list(db, "event_ref", handle, attribute_list)
    # finally, link this to parent
    export_link(db, from_type, from_handle, "event_ref", handle)
示例#48
0
def export_url_list(db, from_type, from_handle, urls):
    for url in urls:
        # (False, u'http://www.gramps-project.org/', u'loleach', (0, u'kaabgo'))
        (private, path, desc, type) = url
        handle = create_id()
        db.query("""insert INTO url (
                 handle,
                 path, 
                 desc, 
                 type0,                  
                 type1,                  
                 private) VALUES (?, ?, ?, ?, ?, ?);
                 """,
                 handle,
                 path,
                 desc,
                 type[0],
                 type[1],
                 private)
        # finally, link this to parent
        export_link(db, from_type, from_handle, "url", handle)
示例#49
0
def export_media_ref(db, from_type, from_handle, media):
    (private, citation_list, note_list, attribute_list, ref, role) = media
    # handle is the media_ref handle
    # ref is the media handle
    handle = create_id()
    if role is None:
        role = (-1, -1, -1, -1)
    db.query("""INSERT into media_ref (
                 handle,
                 ref,
                 role0,
                 role1,
                 role2,
                 role3,
                 private) VALUES (?,?,?,?,?,?,?);""",
             handle, ref, role[0], role[1], role[2], role[3], private) 
    export_list(db, "media_ref", handle, "note", note_list)
    export_attribute_list(db, "media_ref", handle, attribute_list)
    export_citation_list(db, "media_ref", handle, citation_list)
    # And finally, make a link from parent to new object
    export_link(db, from_type, from_handle, "media_ref", handle)
示例#50
0
def export_repository_ref_list(db, from_type, from_handle, reporef_list):
    for repo in reporef_list:
        (note_list, 
         ref,
         call_number, 
         source_media_type,
         private) = repo
        handle = create_id()
        db.query("""insert INTO repository_ref (
                     handle, 
                     ref, 
                     call_number, 
                     source_media_type0,
                     source_media_type1,
                     private) VALUES (?,?,?,?,?,?);""",
                 handle, 
                 ref, 
                 call_number, 
                 source_media_type[0],
                 source_media_type[1],
                 private) 
        export_list(db, "repository_ref", handle, "note", note_list)
        # finally, link this to parent
        export_link(db, from_type, from_handle, "repository_ref", handle)
示例#51
0
 def _parse_family(self, line_number, row, col):
     "Parse the content of a family line"
     family_ref   = rd(line_number, row, col, "family")
     if family_ref is None:
         LOG.warn("no family reference found for family on line %d" %
                  line_number)
         return # required
     child   = rd(line_number, row, col, "child")
     source  = rd(line_number, row, col, "source")
     note  = rd(line_number, row, col, "note")
     gender  = rd(line_number, row, col, "gender")
     child = self.lookup("person", child)
     family = self.lookup("family", family_ref)
     if family is None:
         LOG.warn("no matching family reference found for family "
                  "on line %d" % line_number)
         return
     if child is None:
         LOG.warn("no matching child reference found for family "
                  "on line %d" % line_number)
         return
     # is this child already in this family? If so, don't add
     LOG.debug("children: %s", [ref.ref for ref in
                                family.get_child_ref_list()])
     LOG.debug("looking for: %s", child.get_handle())
     if child.get_handle() not in [ref.ref for ref in
                                   family.get_child_ref_list()]:
         # add child to family
         LOG.debug("   adding child [%s] to family [%s]",
                   child.get_gramps_id(), family.get_gramps_id())
         childref = ChildRef()
         childref.set_reference_handle(child.get_handle())
         family.add_child_ref( childref)
         self.db.commit_family(family, self.trans)
         child.add_parent_family_handle(family.get_handle())
     if gender:
         # replace
         gender = gender.lower()
         if gender == gender_map[Person.MALE].lower():
             gender = Person.MALE
         elif gender == gender_map[Person.FEMALE].lower():
             gender = Person.FEMALE
         else:
             gender = Person.UNKNOWN
         child.set_gender(gender)
     if source:
         # add, if new
         dummy_new, source = self.get_or_create_source(source)
         self.find_and_set_citation(child, source)
     # put note on child
     if note:
         # append notes, if previous notes
         previous_notes_list = child.get_note_list()
         updated_note = False
         for note_handle in previous_notes_list:
             previous_note = self.db.get_note_from_handle(note_handle)
             if previous_note.type == NoteType.PERSON:
                 previous_text = previous_note.get()
                 if note not in previous_text:
                     note = previous_text + "\n" + note
                 previous_note.set(note)
                 self.db.commit_note(previous_note, self.trans)
                 updated_note = True
                 break
         if not updated_note:
             # add new note here
             new_note = Note()
             new_note.handle = create_id()
             new_note.type.set(NoteType.PERSON)
             new_note.set(note)
             if self.default_tag:
                 new_note.add_tag(self.default_tag.handle)
             self.db.add_note(new_note, self.trans)
             child.add_note(new_note.handle)
     self.db.commit_person(child, self.trans)
示例#52
0
 def _parse_marriage(self, line_number, row, col):
     "Parse the content of a Marriage,Husband,Wife line."
     marriage_ref   = rd(line_number, row, col, "marriage")
     husband  = rd(line_number, row, col, "husband")
     wife     = rd(line_number, row, col, "wife")
     marriagedate = rd(line_number, row, col, "date")
     marriageplace = rd(line_number, row, col, "place")
     marriageplace_id = rd(line_number, row, col, "place_id")
     marriagesource = rd(line_number, row, col, "source")
     note = rd(line_number, row, col, "note")
     wife = self.lookup("person", wife)
     husband = self.lookup("person", husband)
     if husband is None and wife is None:
         # might have children, so go ahead and add
         LOG.warn("no parents on line %d; adding family anyway" %
                  line_number)
     family = self.get_or_create_family(marriage_ref, husband, wife)
     # adjust gender, if not already provided
     if husband:
         # this is just a guess, if unknown
         if husband.get_gender() == Person.UNKNOWN:
             husband.set_gender(Person.MALE)
             self.db.commit_person(husband, self.trans)
     if wife:
         # this is just a guess, if unknown
         if wife.get_gender() == Person.UNKNOWN:
             wife.set_gender(Person.FEMALE)
             self.db.commit_person(wife, self.trans)
     if marriage_ref:
         self.storeup("family", marriage_ref.lower(), family)
     if marriagesource:
         # add, if new
         new, marriagesource = self.get_or_create_source(marriagesource)
     if marriageplace and marriageplace_id:
         raise Error("Error in marriage: can't have a place and place_id")
     if marriageplace:
         # add, if new
         new, marriageplace = self.get_or_create_place(marriageplace)
     elif marriageplace_id:
         # better exist already, locally or in database:
         marriageplace = self.lookup("place", marriageplace_id)
     if marriagedate:
         marriagedate = _dp.parse(marriagedate)
     if marriagedate or marriageplace or marriagesource or note:
         # add, if new; replace, if different
         new, marriage = self.get_or_create_event(family,
                 EventType.MARRIAGE, marriagedate,
                 marriageplace, marriagesource)
         if new:
             mar_ref = EventRef()
             mar_ref.set_reference_handle(marriage.get_handle())
             family.add_event_ref(mar_ref)
             self.db.commit_family(family, self.trans)
         # only add note to event:
         # append notes, if previous notes
         if note:
             previous_notes_list = marriage.get_note_list()
             updated_note = False
             for note_handle in previous_notes_list:
                 previous_note = self.db.get_note_from_handle(
                         note_handle)
                 if previous_note.type == NoteType.EVENT:
                     previous_text = previous_note.get()
                     if note not in previous_text:
                         note = previous_text + "\n" + note
                     previous_note.set(note)
                     self.db.commit_note(previous_note, self.trans)
                     updated_note = True
                     break
             if not updated_note:
                 # add new note here
                 new_note = Note()
                 new_note.handle = create_id()
                 new_note.type.set(NoteType.EVENT)
                 new_note.set(note)
                 if self.default_tag:
                     new_note.add_tag(self.default_tag.handle)
                 self.db.add_note(new_note, self.trans)
                 marriage.add_note(new_note.handle)
             self.db.commit_event(marriage, self.trans)
示例#53
0
文件: family.py 项目: ondrokrc/gramps
def process_family(request, context, handle, act, add_to=None): # view, edit, save
    """
    Process act on person. Can return a redirect.
    """
    context["tview"] = _("Family")
    context["tviews"] = _("Familes")

    if handle == "add":
        act = "add"
    if "action" in request.POST:
        act = request.POST.get("action")

    # Handle: edit, view, add, create, save, delete, share, save-share
    if act == "share":
        # Adds a person to an existing family
        item, handle = add_to
        context["pickform"] = PickForm("Pick family", 
                                       Family, 
                                       (),
                                       request.POST)     
        context["object_handle"] = handle
        context["object_type"] = "person"
        return render_to_response("pick.html", context)
    elif act == "save-share":
        item, handle = add_to 
        pickform = PickForm("Pick family", 
                            Family, 
                            (),
                            request.POST)
        if pickform.data["picklist"]:
            person = Person.objects.get(handle=handle) # to add
            ref_handle = pickform.data["picklist"]
            ref_obj = Family.objects.get(handle=ref_handle) 
            if item == "child":
                dji.add_child_ref_default(ref_obj, person) # add person to family
                #person.parent_families.add(ref_obj) # add family to child
                pfo = MyParentFamilies(person=person, family=ref_obj, 
                                       order=len(person.parent_families.all())+1)
                pfo.save()
            elif item == "spouse":
                if person.gender_type.name == "Female":
                    ref_obj.mother = person
                elif person.gender_type.name == "Male":
                    ref_obj.father = person
                else:
                    ref_obj.father = person # FIXME: Unknown gender, add to open
                #person.families.add(ref_obj) # add family to person
                pfo = MyFamilies(person=person, family=ref_obj, 
                                 order=len(person.families.all())+1)
                pfo.save()
            ref_obj.save()
            person.save()
            return redirect("/%s/%s%s#tab-references" % ("person", handle, build_search(request)))
        else:
            context["pickform"] = pickform
            context["object_handle"] = handle
            context["object_type"] = "person"
            return render_to_response("pick.html", context)
    elif act == "add":
        family = Family(
            gramps_id=dji.get_next_id(Family, "F"),
            family_rel_type=FamilyRelType.objects.get(
                val=FamilyRelType._DEFAULT[0]))
        if add_to:
            what, phandle = add_to
            person = Person.objects.get(handle=phandle)
            gender = person.gender_type.name # Male, Female, Unknown
            if what == "spouse":
                if gender == "Male":
                    family.father = person
                elif gender == "Female":
                    family.mother = person
                else: # You have to pick one!
                    family.father = person
            elif what == "child":
                pass # FIXME: can't show child in table? 
                     # Table from children_table
            else: # unknown what!
                raise Exception("can't add_to: '%s'" % what)
        familyform = FamilyForm(instance=family)
        familyform.model = family
    elif act in ["view", "edit"]: 
        family = Family.objects.get(handle=handle)
        familyform = FamilyForm(instance=family)
        familyform.model = family
    elif act == "save": # editing an existing family
        family = Family.objects.get(handle=handle)
        old_family_mother = family.mother
        old_family_father = family.father
        familyform = FamilyForm(request.POST, instance=family)
        familyform.model = family
        if familyform.is_valid():
            update_last_changed(family, request.user.username)
            family = familyform.save()
            # Remove family from previous mother/father if changed
            if familyform.cleaned_data["mother"] != old_family_mother and old_family_mother:
                MyFamilies.objects.get(person=old_family_mother, family=family).delete()
            if familyform.cleaned_data["father"] != old_family_father and old_family_father:
                MyFamilies.objects.get(person=old_family_father, family=family).delete()
            # Add family to newly selected mother/father if needed:
            if familyform.cleaned_data["mother"]:
                if family not in familyform.cleaned_data["mother"].families.all():
                    #family.mother.families.add(family)
                    pfo = MyFamilies(person=familyform.cleaned_data["mother"], family=family, 
                                     order=len(familyform.cleaned_data["mother"].families.all())+1)
                    pfo.save()
            if familyform.cleaned_data["father"]:
                if family not in familyform.cleaned_data["father"].families.all():
                    #family.father.families.add(family)
                    pfo = MyFamilies(person=family.father, family=family, 
                                     order=len(familyform.cleaned_data["father"].families.all())+1)
                    pfo.save()
            familyform.save()
            act = "view"
        else:
            act = "edit"
    elif act == "create": 
        family = Family(family_rel_type=FamilyRelType.objects.get(
                val=FamilyRelType._DEFAULT[0]),
                        handle=create_id())
        familyform = FamilyForm(request.POST, instance=family)
        familyform.model = family
        if familyform.is_valid():
            update_last_changed(family, request.user.username)
            family = familyform.save()
            if family.mother:
                #family.mother.families.add(family)
                pfo = MyFamilies(person=family.mother, family=family, 
                                 order=len(family.mother.families.all())+1)
                pfo.save()
            if family.father:
                #family.father.families.add(family)
                pfo = MyFamilies(person=family.father, family=family,
                                 order=len(family.father.families.all())+1)
                pfo.save()
            family.save_cache()
            if add_to: # add child or spouse to family
                item, handle = add_to
                person = Person.objects.get(handle=handle)
                if item == "child":
                    dji.add_child_ref_default(family, person) # add person to family
                    ##person.parent_families.add(family) # add family to child
                    pfo = MyParentFamilies(person=person, family=family,
                                           order=len(person.parent_families.all())+1)
                    pfo.save()
                #elif item == "spouse":
                # already added by selecting
                    person.save()
                return redirect("/%s/%s%s#tab-references" % ("person", handle, build_search(request)))
            act = "view"
        else:
            act = "add"
    elif act == "delete": 
        family = Family.objects.get(handle=handle)
        family.delete()
        return redirect("/family/")
    else:
        raise Exception("Unhandled act: '%s'" % act)

    context["familyform"] = familyform
    context["object"] = family
    context["family"] = family
    context["action"] = act
    view_template = "view_family_detail.html"
    
    return render_to_response(view_template, context)
示例#54
0
 def _parse_person(self, line_number, row, col):
     "Parse the content of a Person line."
     surname   = rd(line_number, row, col, "surname")
     firstname = rd(line_number, row, col, "firstname", "")
     callname  = rd(line_number, row, col, "callname")
     title     = rd(line_number, row, col, "title")
     prefix    = rd(line_number, row, col, "prefix")
     suffix    = rd(line_number, row, col, "suffix")
     gender    = rd(line_number, row, col, "gender")
     source    = rd(line_number, row, col, "source")
     note      = rd(line_number, row, col, "note")
     birthplace  = rd(line_number, row, col, "birthplace")
     birthplace_id  = rd(line_number, row, col, "birthplace_id")
     birthdate   = rd(line_number, row, col, "birthdate")
     birthsource = rd(line_number, row, col, "birthsource")
     baptismplace  = rd(line_number, row, col, "baptismplace")
     baptismplace_id  = rd(line_number, row, col, "baptismplace_id")
     baptismdate   = rd(line_number, row, col, "baptismdate")
     baptismsource = rd(line_number, row, col, "baptismsource")
     burialplace  = rd(line_number, row, col, "burialplace")
     burialplace_id  = rd(line_number, row, col, "burialplace_id")
     burialdate   = rd(line_number, row, col, "burialdate")
     burialsource = rd(line_number, row, col, "burialsource")
     deathplace  = rd(line_number, row, col, "deathplace")
     deathplace_id  = rd(line_number, row, col, "deathplace_id")
     deathdate   = rd(line_number, row, col, "deathdate")
     deathsource = rd(line_number, row, col, "deathsource")
     deathcause  = rd(line_number, row, col, "deathcause")
     grampsid    = rd(line_number, row, col, "grampsid")
     person_ref  = rd(line_number, row, col, "person")
     #########################################################
     # if this person already exists, don't create them
     person = self.lookup("person", person_ref)
     if person is None:
         if surname is None:
             LOG.warn("empty surname for new person on line %d" %
                      line_number)
             surname = ""
         # new person
         person = self.create_person()
         name = Name()
         name.set_type(NameType(NameType.BIRTH))
         name.set_first_name(firstname)
         surname_obj = Surname()
         surname_obj.set_surname(surname)
         name.add_surname(surname_obj)
         person.set_primary_name(name)
     else:
         name = person.get_primary_name()
     #########################################################
     if person_ref is not None:
         self.storeup("person", person_ref, person)
     # replace
     if surname is not None:
         name.get_primary_surname().set_surname(surname)
     if firstname is not None:
         name.set_first_name(firstname)
     if callname is not None:
         name.set_call_name(callname)
     if title is not None:
         name.set_title(title)
     if prefix is not None:
         name.get_primary_surname().set_prefix(prefix)
         name.group_as = '' # HELP? what should I do here?
     if suffix is not None:
         name.set_suffix(suffix)
     if note is not None:
         # append notes, if previous notes
         previous_notes_list = person.get_note_list()
         updated_note = False
         for note_handle in previous_notes_list:
             previous_note = self.db.get_note_from_handle(note_handle)
             if previous_note.type == NoteType.PERSON:
                 previous_text = previous_note.get()
                 if note not in previous_text:
                     note = previous_text + "\n" + note
                 previous_note.set(note)
                 self.db.commit_note(previous_note, self.trans)
                 updated_note = True
                 break
         if not updated_note:
             # add new note here
             new_note = Note()
             new_note.handle = create_id()
             new_note.type.set(NoteType.PERSON)
             new_note.set(note)
             if self.default_tag:
                 new_note.add_tag(self.default_tag.handle)
             self.db.add_note(new_note, self.trans)
             person.add_note(new_note.handle)
     if grampsid is not None:
         person.gramps_id = grampsid
     elif person_ref is not None:
         if person_ref.startswith("[") and person_ref.endswith("]"):
             person.gramps_id = self.db.id2user_format(person_ref[1:-1])
     if (person.get_gender() == Person.UNKNOWN and
             gender is not None):
         gender = gender.lower()
         if gender == gender_map[Person.MALE].lower():
             gender = Person.MALE
         elif gender == gender_map[Person.FEMALE].lower():
             gender = Person.FEMALE
         else:
             gender = Person.UNKNOWN
         person.set_gender(gender)
     #########################################################
     # add if new, replace if different
     # Birth:
     if birthdate is not None:
         birthdate = _dp.parse(birthdate)
     if birthplace and birthplace_id:
         raise Error("Error in person: can't have a birthplace and birthplace_id")
     if birthplace is not None:
         new, birthplace = self.get_or_create_place(birthplace)
     elif birthplace_id:
         # better exist already, locally or in database:
         birthplace = self.lookup("place", birthplace_id)
     if birthsource is not None:
         new, birthsource = self.get_or_create_source(birthsource)
     if birthdate or birthplace or birthsource:
         new, birth = self.get_or_create_event(person,
              EventType.BIRTH, birthdate,
              birthplace, birthsource)
         birth_ref = person.get_birth_ref()
         if birth_ref is None:
             # new
             birth_ref = EventRef()
         birth_ref.set_reference_handle( birth.get_handle())
         person.set_birth_ref( birth_ref)
     # Baptism:
     if baptismdate is not None:
         baptismdate = _dp.parse(baptismdate)
     if baptismplace and baptismplace_id:
         raise Error("Error in person: can't have a baptismplace and baptismplace_id")
     if baptismplace is not None:
         new, baptismplace = self.get_or_create_place(baptismplace)
     elif baptismplace_id:
         # better exist already, locally or in database:
         baptismplace = self.lookup("place", baptismplace_id)
     if baptismsource is not None:
         new, baptismsource = self.get_or_create_source(baptismsource)
     if baptismdate or baptismplace or baptismsource:
         new, baptism = self.get_or_create_event(person,
              EventType.BAPTISM, baptismdate,
              baptismplace, baptismsource)
         baptism_ref = get_primary_event_ref_from_type(self.db, person,
                                                       "Baptism")
         if baptism_ref is None:
             # new
             baptism_ref = EventRef()
         baptism_ref.set_reference_handle( baptism.get_handle())
         person.add_event_ref( baptism_ref)
     # Death:
     if deathdate is not None:
         deathdate = _dp.parse(deathdate)
     if deathplace and deathplace_id:
         raise Error("Error in person: can't have a deathplace and deathplace_id")
     if deathplace is not None:
         new, deathplace = self.get_or_create_place(deathplace)
     elif deathplace_id:
         # better exist already, locally or in database:
         deathplace = self.lookup("place", deathplace_id)
     if deathsource is not None:
         new, deathsource = self.get_or_create_source(deathsource)
     if deathdate or deathplace or deathsource or deathcause:
         new, death = self.get_or_create_event(person,
                 EventType.DEATH, deathdate, deathplace,
                 deathsource)
         if deathcause:
             death.set_description(deathcause)
             self.db.commit_event(death, self.trans)
         death_ref = person.get_death_ref()
         if death_ref is None:
             # new
             death_ref = EventRef()
         death_ref.set_reference_handle(death.get_handle())
         person.set_death_ref(death_ref)
     # Burial:
     if burialdate is not None:
         burialdate = _dp.parse(burialdate)
     if burialplace and burialplace_id:
         raise Error("Error in person: can't have a burialplace and burialplace_id")
     if burialplace is not None:
         new, burialplace = self.get_or_create_place(burialplace)
     elif burialplace_id:
         # better exist already, locally or in database:
         burialplace = self.lookup("place", burialplace_id)
     if burialsource is not None:
         new, burialsource = self.get_or_create_source(burialsource)
     if burialdate or burialplace or burialsource:
         new, burial = self.get_or_create_event(person,
              EventType.BURIAL, burialdate,
              burialplace, burialsource)
         burial_ref = get_primary_event_ref_from_type(self.db, person,
                                                      "Burial")
         if burial_ref is None:
             # new
             burial_ref = EventRef()
         burial_ref.set_reference_handle( burial.get_handle())
         person.add_event_ref( burial_ref)
     if source:
         # add, if new
         new, source = self.get_or_create_source(source)
         self.find_and_set_citation(person, source)
     self.db.commit_person(person, self.trans)