# # Gramps - a GTK+/GNOME based genealogy program # # Copyright (C) 2000-2007 Donald N. Allingham # Copyright (C) 2008 Brian G. Matherly # Copyright (C) 2010 Jakim Friant # Copyright (C) 2011 Tim G L Lyons # # 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$ """Tools/Database Repair/Check and Repair Database""" #------------------------------------------------------------------------- # # python modules # #------------------------------------------------------------------------- from __future__ import print_function from __future__ import with_statement import os import sys import cStringIO from gen.ggettext import gettext as _ from gen.ggettext import ngettext from collections import defaultdict #------------------------------------------------------------------------ # # Set up logging # #------------------------------------------------------------------------ import logging LOG_OBJ = logging.getLogger(".CheckRepair") #------------------------------------------------------------------------- # # gtk modules # #------------------------------------------------------------------------- import gtk #------------------------------------------------------------------------- # # GRAMPS modules # #------------------------------------------------------------------------- import gen.lib from gen.db import DbTxn import config import Utils from gui.utils import ProgressMeter import ManagedWindow from gui.plug import tool from QuestionDialog import OkDialog, MissingMediaDialog from gen.display.name import displayer as _nd from glade import Glade # table for handling control chars in notes. # All except 09, 0A, 0D are replaced with space. strip_dict = dict.fromkeys(range(9)+range(11,13)+range(14, 32), u" ") # This is assigned so that it can be either LOG_OBJ.debug or print, depending on # which is deemed to better interface for Gramps LOG = print #------------------------------------------------------------------------- # # Low Level repair # #------------------------------------------------------------------------- def cross_table_duplicates(db): """ Function to find the presence of identical handles that occur in different database tables. Assumes there are no intable duplicates, see low_level function. :param db: the database to check :type db: :class:`gen.db.read.DbBsddbRead` :returns: the presence of cross table duplicate handles :rtype: bool """ progress = ProgressMeter(_('Checking Database'),'') progress.set_pass(_('Looking for cross table duplicates'), 9) LOG('Looking for cross table duplicates') total_nr_handles = 0 all_handles = set([]) for the_map in [db.person_map, db.family_map, db.event_map, db.place_map, db.source_map, db.citation_map, db.media_map, db.repository_map, db.note_map]: handle_list = the_map.keys() total_nr_handles += len(handle_list) all_handles.update(handle_list) progress.step() progress.close() num_errors = total_nr_handles - len(all_handles) LOG(' OK: No cross table duplicates' if num_errors == 0 else ' FAIL: Found %d cross table duplicates' % num_errors) return total_nr_handles > len(all_handles) #------------------------------------------------------------------------- # # runTool # #------------------------------------------------------------------------- class Check(tool.BatchTool): def __init__(self, dbstate, uistate, options_class, name, callback=None): tool.BatchTool.__init__(self, dbstate, options_class, name) if self.fail: return cli = uistate is None if self.db.readonly: # TODO: split plugin in a check and repair part to support # checking of a read only database return # The low-level repair is bypassing the transaction mechanism. # As such, we run it before starting the transaction. # We only do this for the dbdir backend. if self.db.__class__.__name__ == 'DbBsddb': if cross_table_duplicates(self.db): Report(uistate, _( "Your family tree contains cross table duplicate handles.\n " "This is bad and can be fixed by making a backup of your\n" "family tree and importing that backup in an empty family\n" "tree. The rest of the checking is skipped, the Check and\n" "Repair tool should be run anew on this new family tree."), cli) return with DbTxn(_("Check Integrity"), self.db, batch=True) as trans: self.db.disable_signals() checker = CheckIntegrity(dbstate, uistate, trans) # start with empty objects, broken links can be corrected below # then. This is done before fixing encoding and missing photos, # since otherwise we will be trying to fix empty records which are # then going to be deleted. checker.cleanup_empty_objects() checker.fix_encoding() checker.fix_ctrlchars_in_notes() checker.cleanup_missing_photos(cli) checker.cleanup_deleted_name_formats() prev_total = -1 total = 0 while prev_total != total: prev_total = total checker.check_for_broken_family_links() checker.check_parent_relationships() checker.cleanup_empty_families(cli) checker.cleanup_duplicate_spouses() total = checker.family_errors() checker.check_events() checker.check_person_references() checker.check_family_references() checker.check_place_references() checker.check_source_and_citation_references() checker.check_media_references() checker.check_repo_references() checker.check_note_references() self.db.enable_signals() self.db.request_rebuild() errs = checker.build_report(uistate) if errs: Report(uistate, checker.text.getvalue(), cli) #------------------------------------------------------------------------- # # # #------------------------------------------------------------------------- class CheckIntegrity(object): def __init__(self, dbstate, uistate, trans): self.db = dbstate.db self.trans = trans self.bad_photo = [] self.replaced_photo = [] self.removed_photo = [] self.empty_family = [] self.broken_links = [] self.duplicate_links = [] self.broken_parent_links = [] self.fam_rel = [] self.invalid_events = [] self.invalid_birth_events = [] self.invalid_death_events = [] self.invalid_person_references = [] self.invalid_family_references = [] self.invalid_place_references = [] self.invalid_source_references = [] self.invalid_citation_references = [] self.invalid_repo_references = [] self.invalid_media_references = [] self.invalid_note_references = [] self.invalid_dates = [] self.removed_name_format = [] self.empty_objects = defaultdict(list) self.last_img_dir = config.get('behavior.addmedia-image-dir') self.progress = ProgressMeter(_('Checking Database'),'') def family_errors(self): return (len(self.broken_parent_links) + len(self.broken_links) + len(self.empty_family) + len(self.duplicate_links) ) def cleanup_deleted_name_formats(self): """ Permanently remove deleted name formats from db. When user deletes custom name format those are not removed only marked as "inactive". This method does the cleanup of the name format table, as well as fixes the display_as, sort_as values for each Name in the db. """ self.progress.set_pass(_('Looking for invalid name format references'), self.db.get_number_of_people()) LOG('Looking for invalid name format references') deleted_name_formats = [number for (number, name, fmt_str,act) in self.db.name_formats if not act] # remove the invalid references from all Name objects for person_handle in self.db.get_person_handles(): person = self.db.get_person_from_handle(person_handle) p_changed = False name = person.get_primary_name() if name.get_sort_as() in deleted_name_formats: name.set_sort_as(gen.lib.Name.DEF) p_changed = True if name.get_display_as() in deleted_name_formats: name.set_display_as(gen.lib.Name.DEF) p_changed = True if p_changed: person.set_primary_name(name) a_changed = False name_list = [] for name in person.get_alternate_names(): if name.get_sort_as() in deleted_name_formats: name.set_sort_as(gen.lib.Name.DEF) a_changed = True if name.get_display_as() in deleted_name_formats: name.set_display_as(gen.lib.Name.DEF) a_changed = True name_list.append(name) if a_changed: person.set_alternate_names(name_list) if p_changed or a_changed: self.db.commit_person(person, self.trans) self.removed_name_format.append(person_handle) self.progress.step() # update the custom name name format table for number in deleted_name_formats: _nd.del_name_format(number) self.db.name_formats = _nd.get_name_format(only_custom=True, only_active=False) if len(self.removed_name_format) == 0: LOG(' OK: no invalid name formats found found') def cleanup_duplicate_spouses(self): self.progress.set_pass(_('Looking for duplicate spouses'), self.db.get_number_of_people()) LOG('Looking for duplicate spouses') previous_errors = len(self.duplicate_links) for handle in self.db.person_map.keys(): value = self.db.person_map[handle] p = gen.lib.Person(value) splist = p.get_family_handle_list() if len(splist) != len(set(splist)): new_list = [] for value in splist: if value not in new_list: new_list.append(value) self.duplicate_links.append((handle, value)) p.set_family_handle_list(new_list) self.db.commit_person(p, self.trans) self.progress.step() if previous_errors == len(self.duplicate_links): LOG(' OK: no duplicate spouses found') def fix_encoding(self): self.progress.set_pass(_('Looking for character encoding errors'), self.db.get_number_of_media_objects()) LOG('Looking for character encoding errors') error_count = 0 for handle in self.db.media_map.keys(): data = self.db.media_map[handle] if not isinstance(data[2], unicode) or not isinstance(data[4], unicode): obj = self.db.get_object_from_handle(handle) obj.path = Utils.fix_encoding( obj.path, errors='ignore') obj.desc = Utils.fix_encoding( obj.desc, errors='ignore') self.db.commit_media_object(obj, self.trans) if not isinstance(data[2], unicode): LOG(' FAIL: encoding error on media object "%s"' ' path "%s"' % (obj.gramps_id, obj.path)) if not isinstance(data[2], unicode): LOG(' FAIL: encoding error on media object "%s"' ' description "%s"' % (obj.gramps_id, obj.desc)) error_count += 1 # Once we are here, fix the mime string if not str if not isinstance(data[3], str): obj = self.db.get_object_from_handle(handle) try: if data[3] == str(data[3]): obj.mime = str(data[3]) else: obj.mime = "" except: obj.mime = "" self.db.commit_media_object(obj, self.trans) LOG(' FAIL: encoding error on media object "%s"' ' mime "%s"' % (obj.desc, obj.mime)) error_count += 1 self.progress.step() if error_count == 0: LOG(' OK: no encoding errors found') def fix_ctrlchars_in_notes(self): self.progress.set_pass(_('Looking for ctrl characters in notes'), self.db.get_number_of_notes()) LOG('Looking for ctrl characters in notes') error_count = 0 for handle in self.db.note_map.keys(): note = self.db.get_note_from_handle(handle) stext = note.get_styledtext() old_text = unicode(stext) new_text = old_text.translate(strip_dict) if old_text != new_text: LOG(' FAIL: control characters found in note "%s"' % self.db.note_map[handle][1]) error_count += 1 # Commit only if ctrl char found. note.set_styledtext(gen.lib.StyledText(text=new_text, tags=stext.get_tags())) self.db.commit_note(note, self.trans) self.progress.step() if error_count == 0: LOG(' OK: no ctrl characters in notes found') def check_for_broken_family_links(self): # Check persons referenced by the family objects fhandle_list = self.db.get_family_handles() self.progress.set_pass(_('Looking for broken family links'), len(fhandle_list) + self.db.get_number_of_people()) LOG('Looking for broken family links') previous_errors = len(self.broken_parent_links + self.broken_links) for family_handle in fhandle_list: family = self.db.get_family_from_handle(family_handle) father_handle = family.get_father_handle() mother_handle = family.get_mother_handle() if father_handle: father = self.db.get_person_from_handle(father_handle) if not father: # The person referenced by the father handle does not exist # in the database # This is tested by TestcaseGenerator where the mother is # "Broken6" family.set_father_handle(None) self.db.commit_family(family, self.trans) self.broken_parent_links.append((father_handle, family_handle)) LOG(" FAIL: family '%s' father handle '%s'" " does not exist" % (family.gramps_id, father_handle)) father_handle = None if mother_handle: mother = self.db.get_person_from_handle(mother_handle) if not mother: # The person referenced by the mother handle does not exist # in the database # This is tested by TestcaseGenerator where the mother is # "Broken7" family.set_mother_handle(None) self.db.commit_family(family, self.trans) self.broken_parent_links.append((mother_handle, family_handle)) LOG(" FAIL: family '%s' mother handle '%s'" " does not exist" % (family.gramps_id, mother_handle)) mother_handle = None if father_handle and father and \ family_handle not in father.get_family_handle_list(): # The referenced father has no reference back to the family # This is tested by TestcaseGenerator where the father is # "Broken1" self.broken_parent_links.append((father_handle, family_handle)) father.add_family_handle(family_handle) self.db.commit_person(father, self.trans) LOG(" FAIL: family '%s' father '%s'" " does not refer back to the family" % (family.gramps_id, father_handle)) if mother_handle and mother and \ family_handle not in mother.get_family_handle_list(): # The referenced mother has no reference back to the family. # This is tested by TestcaseGenerator where the father is # "Broken4" self.broken_parent_links.append((mother_handle, family_handle)) mother.add_family_handle(family_handle) self.db.commit_person(mother, self.trans) LOG(" FAIL: family '%s' mother '%s'" " does not refer back to the family" % (family.gramps_id, mother_handle)) for child_ref in family.get_child_ref_list(): child_handle = child_ref.ref child = self.db.get_person_from_handle(child_handle) if child: if child_handle in [father_handle, mother_handle]: # The child is one of the parents: impossible Remove # such child from the family # This is tested by TestcaseGenerator where the father # is "Broken19" LOG(" FAIL: family '%s' child '%s'" " is one of the parents" % (family.gramps_id, child.gramps_id)) family.remove_child_ref(child_ref) self.db.commit_family(family, self.trans) self.broken_links.append((child_handle, family_handle)) continue if family_handle == child.get_main_parents_family_handle(): continue if family_handle not in \ child.get_parent_family_handle_list(): # The referenced child has no reference to the family # This is tested by TestcaseGenerator where the father # is "Broken8" LOG(" FAIL: family '%s' child '%s'" " has no reference to the family" % (family.gramps_id, child.gramps_id)) family.remove_child_ref(child_ref) self.db.commit_family(family, self.trans) self.broken_links.append((child_handle, family_handle)) else: # The person referenced by the child handle # does not exist in the database # This is tested by TestcaseGenerator where the father # is "Broken20" LOG(" FAIL: family '%s' child '%s'" " does not exist in the database" % (family.gramps_id, child_handle)) family.remove_child_ref(child_ref) self.db.commit_family(family, self.trans) self.broken_links.append((child_handle, family_handle)) new_ref_list = [] new_ref_handles = [] replace = False for child_ref in family.get_child_ref_list(): child_handle = child_ref.ref if child_handle in new_ref_handles: replace = True else: new_ref_list.append(child_ref) new_ref_handles.append(child_handle) if replace: family.set_child_ref_list(new_ref_list) self.db.commit_family(family, self.trans) self.progress.step() # Check persons membership in referenced families for person_handle in self.db.get_person_handles(): person = self.db.get_person_from_handle(person_handle) phandle_list = person.get_parent_family_handle_list() new_list = list(set(phandle_list)) if len(phandle_list) != len(new_list): person.set_parent_family_handle_list(new_list) self.db.commit_person(person, self.trans) for par_family_handle in person.get_parent_family_handle_list(): family = self.db.get_family_from_handle(par_family_handle) if not family: person.remove_parent_family_handle(par_family_handle) self.db.commit_person(person, self.trans) continue for child_handle in [child_ref.ref for child_ref in family.get_child_ref_list()]: if child_handle == person_handle: break else: # Person is not a child in the referenced parent family # This is tested by TestcaseGenerator where the father # is "Broken9" LOG(" FAIL: family '%s' person '%s'" " is not a child in the referenced parent family" % (family.gramps_id, person.gramps_id)) person.remove_parent_family_handle(par_family_handle) self.db.commit_person(person, self.trans) self.broken_links.append((person_handle,family_handle)) for family_handle in person.get_family_handle_list(): family = self.db.get_family_from_handle(family_handle) if not family: # The referenced family does not exist in database # This is tested by TestcaseGenerator where the father # is "Broken20" LOG(" FAIL: person '%s' refers to " "family '%s' which is not in the database" % (person.gramps_id, family_handle)) person.remove_family_handle(family_handle) self.db.commit_person(person, self.trans) self.broken_links.append((person_handle, family_handle)) continue if family.get_father_handle() == person_handle: continue if family.get_mother_handle() == person_handle: continue # The person is not a member of the referenced family # This is tested by TestcaseGenerator where the father is # "Broken2" and the family misses the link to the father, and # where the mother is "Broken3" and the family misses the link # to the mother LOG(" FAIL: family '%s' person '%s'" " is not member of the referenced family" % (family.gramps_id, person.gramps_id)) person.remove_family_handle(family_handle) self.db.commit_person(person, self.trans) self.broken_links.append((person_handle, family_handle)) self.progress.step() if previous_errors == len(self.broken_parent_links + self.broken_links): LOG(' OK: no broken family links found') def cleanup_missing_photos(self, cl=0): self.progress.set_pass(_('Looking for unused objects'), len(self.db.get_media_object_handles())) LOG('Looking for missing photos') missmedia_action = 0 #------------------------------------------------------------------------- def remove_clicked(): # File is lost => remove all references and the object itself for handle in self.db.get_person_handles(sort_handles=False): person = self.db.get_person_from_handle(handle) if person.has_media_reference(ObjectId): person.remove_media_references([ObjectId]) self.db.commit_person(person, self.trans) for handle in self.db.get_family_handles(): family = self.db.get_family_from_handle(handle) if family.has_media_reference(ObjectId): family.remove_media_references([ObjectId]) self.db.commit_family(family, self.trans) for handle in self.db.get_event_handles(): event = self.db.get_event_from_handle(handle) if event.has_media_reference(ObjectId): event.remove_media_references([ObjectId]) self.db.commit_event(event,self.trans) for handle in self.db.get_source_handles(): source = self.db.get_source_from_handle(handle) if source.has_media_reference(ObjectId): source.remove_media_references([ObjectId]) self.db.commit_source(source, self.trans) for handle in self.db.get_citation_handles(): citation = self.db.get_citation_from_handle(handle) if citation.has_media_reference(ObjectId): citation.remove_media_references([ObjectId]) self.db.commit_citation(citation, self.trans) for handle in self.db.get_place_handles(): place = self.db.get_place_from_handle(handle) if place.has_media_reference(ObjectId): place.remove_media_references([ObjectId]) self.db.commit_place(place, self.trans) self.removed_photo.append(ObjectId) self.db.remove_object(ObjectId,self.trans) LOG(' FAIL: media object and all references to it removed') def leave_clicked(): self.bad_photo.append(ObjectId) LOG(' FAIL: references to missing file kept') def select_clicked(): # File is lost => select a file to replace the lost one def fs_close_window(obj): self.bad_photo.append(ObjectId) LOG(' FAIL: references to missing file kept') def fs_ok_clicked(obj): name = Utils.get_unicode_path_from_file_chooser(fs_top.get_filename()) if os.path.isfile(name): obj = self.db.get_object_from_handle(ObjectId) obj.set_path(name) self.db.commit_media_object(obj, self.trans) self.replaced_photo.append(ObjectId) self.last_img_dir = os.path.dirname(name) LOG(' FAIL: media object reselected to "%s"' % name) else: self.bad_photo.append(ObjectId) LOG(' FAIL: references to missing file kept') fs_top = gtk.FileChooserDialog("%s - Gramps" % _("Select file"), buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK) ) fs_top.set_current_folder(self.last_img_dir) response = fs_top.run() if response == gtk.RESPONSE_OK: fs_ok_clicked(fs_top) elif response == gtk.RESPONSE_CANCEL: fs_close_window(fs_top) fs_top.destroy() #------------------------------------------------------------------------- for ObjectId in self.db.get_media_object_handles(): obj = self.db.get_object_from_handle(ObjectId) photo_name = Utils.media_path_full(self.db, obj.get_path()) photo_desc = obj.get_description() if photo_name is not None and photo_name != "" and not Utils.find_file(photo_name): if cl: # Convert to file system encoding before prining fn = os.path.basename(photo_name).encode(sys.getfilesystemencoding()) print ("Warning: media file %s was not found." % fn) self.bad_photo.append(ObjectId) else: if missmedia_action == 0: LOG(' FAIL: media object "%s" reference to missing ' 'file "%s" found' % (photo_desc, photo_name)) mmd = MissingMediaDialog(_("Media object could not be found"), _("The file:\n %(file_name)s \nis referenced in the database, but no longer exists. " "The file may have been deleted or moved to a different location. " "You may choose to either remove the reference from the database, " "keep the reference to the missing file, or select a new file." ) % {'file_name' : '%s' % photo_name}, remove_clicked, leave_clicked, select_clicked) missmedia_action = mmd.default_action elif missmedia_action == 1: LOG(' FAIL: media object "%s" reference to missing ' 'file "%s" found' % (photo_desc, photo_name)) remove_clicked() elif missmedia_action == 2: LOG(' FAIL: media object "%s" reference to missing ' 'file "%s" found' % (photo_desc, photo_name)) leave_clicked() elif missmedia_action == 3: LOG(' FAIL: media object "%s" reference to missing ' 'file "%s" found' % (photo_desc, photo_name)) select_clicked() self.progress.step() if len(self.bad_photo + self.removed_photo) == 0: LOG(' OK: no missing photos found') def cleanup_empty_objects(self): #the position of the change column in the primary objects CHANGE_PERSON = 17 CHANGE_FAMILY = 12 CHANGE_EVENT = 10 CHANGE_SOURCE = 8 CHANGE_CITATION = 9 CHANGE_PLACE = 11 CHANGE_MEDIA = 8 CHANGE_REPOS = 7 CHANGE_NOTE = 5 empty_person_data = gen.lib.Person().serialize() empty_family_data = gen.lib.Family().serialize() empty_event_data = gen.lib.Event().serialize() empty_source_data = gen.lib.Source().serialize() empty_citation_data = gen.lib.Citation().serialize() empty_place_data = gen.lib.Place().serialize() empty_media_data = gen.lib.MediaObject().serialize() empty_repos_data = gen.lib.Repository().serialize() empty_note_data = gen.lib.Note().serialize() _db = self.db def _empty(empty, flag): ''' Closure for dispatch table, below ''' def _f(value): return self._check_empty(value, empty, flag) return _f table = ( # Dispatch table for cleaning up empty objects. Each entry is # a tuple containing: # 0. Type of object being cleaned up # 1. function to read the object from the database # 2. function returning cursor over the object type # 3. function returning number of objects of this type # 4. text identifying the object being cleaned up # 5. function to check if the data is empty # 6. function to remove the object, if empty ('persons', _db.get_person_from_handle, _db.get_person_cursor, _db.get_number_of_people, _('Looking for empty people records'), _empty(empty_person_data, CHANGE_PERSON), _db.remove_person, ), ('families', _db.get_family_from_handle, _db.get_family_cursor, _db.get_number_of_families, _('Looking for empty family records'), _empty(empty_family_data, CHANGE_FAMILY), _db.remove_family, ), ('events', _db.get_event_from_handle, _db.get_event_cursor, _db.get_number_of_events, _('Looking for empty event records'), _empty(empty_event_data, CHANGE_EVENT), _db.remove_event, ), ('sources', _db.get_source_from_handle, _db.get_source_cursor, _db.get_number_of_sources, _('Looking for empty source records'), _empty(empty_source_data, CHANGE_SOURCE), _db.remove_source, ), ('citations', _db.get_citation_from_handle, _db.get_citation_cursor, _db.get_number_of_citations, _('Looking for empty citation records'), _empty(empty_citation_data, CHANGE_CITATION), _db.remove_citation, ), ('places', _db.get_place_from_handle, _db.get_place_cursor, _db.get_number_of_places, _('Looking for empty place records'), _empty(empty_place_data, CHANGE_PLACE), _db.remove_place, ), ('media', _db.get_object_from_handle, _db.get_media_cursor, _db.get_number_of_media_objects, _('Looking for empty media records'), _empty(empty_media_data, CHANGE_MEDIA), _db.remove_object, ), ('repos', _db.get_repository_from_handle, _db.get_repository_cursor, _db.get_number_of_repositories, _('Looking for empty repository records'), _empty(empty_repos_data, CHANGE_REPOS), _db.remove_repository, ), ('notes', _db.get_note_from_handle, _db.get_note_cursor, _db.get_number_of_notes, _('Looking for empty note records'), _empty(empty_note_data, CHANGE_NOTE), _db.remove_note, ), ) # Now, iterate over the table, dispatching the functions for (the_type, get_func, cursor_func, total_func, text, check_func, remove_func) in table: with cursor_func() as cursor: total = total_func() self.progress.set_pass(text, total) LOG(text) for handle, data in cursor: self.progress.step() if check_func(data): # we cannot remove here as that would destroy cursor # so save the handles for later removal LOG(' FAIL: empty %s record with handle "%s" was found' % (the_type, handle)) self.empty_objects[the_type].append(handle) #now remove for handle in self.empty_objects[the_type]: remove_func(handle, self.trans) if len(self.empty_objects[the_type]) == 0: LOG(' OK: no empty %s found' % the_type) def _check_empty(self, data, empty_data, changepos): """compare the data with the data of an empty object change, handle and gramps_id are not compared """ if changepos is not None: return (data[2:changepos] == empty_data[2:changepos] and data[changepos+1:] == empty_data[changepos+1:] ) else : return data[2:] == empty_data[2:] def cleanup_empty_families(self, automatic): fhandle_list = self.db.get_family_handles() self.progress.set_pass(_('Looking for empty families'), len(fhandle_list)) LOG('Looking for empty families') previous_errors = len(self.empty_family) for family_handle in fhandle_list: self.progress.step() family = self.db.get_family_from_handle(family_handle) family_id = family.get_gramps_id() father_handle = family.get_father_handle() mother_handle = family.get_mother_handle() if not father_handle and not mother_handle and \ len(family.get_child_ref_list()) == 0: self.empty_family.append(family_id) self.delete_empty_family(family_handle) if previous_errors == len(self.empty_family): LOG(' OK: no empty families found') def delete_empty_family(self, family_handle): for key in self.db.get_person_handles(sort_handles=False): child = self.db.get_person_from_handle(key) changed = False changed |= child.remove_parent_family_handle(family_handle) changed |= child.remove_family_handle(family_handle) if changed: self.db.commit_person(child, self.trans) self.db.remove_family(family_handle, self.trans) def check_parent_relationships(self): """Repair father=female or mother=male in hetero families """ fhandle_list = self.db.get_family_handles() self.progress.set_pass(_('Looking for broken parent relationships'), len(fhandle_list)) LOG('Looking for broken parent relationships') previous_errors = len(self.fam_rel) for family_handle in fhandle_list: self.progress.step() family = self.db.get_family_from_handle(family_handle) father_handle = family.get_father_handle() if father_handle: fgender = self.db.get_person_from_handle(father_handle ).get_gender() else: fgender = None mother_handle = family.get_mother_handle() if mother_handle: mgender = self.db.get_person_from_handle(mother_handle ).get_gender() else: mgender = None if (fgender == gen.lib.Person.FEMALE or mgender == gen.lib.Person.MALE) and fgender != mgender: # swap. note: (at most) one handle may be None LOG(' FAIL: the family "%s" has a father=female or ' ' mother=male in a different sex family' % family.gramps_id) family.set_father_handle(mother_handle) family.set_mother_handle(father_handle) self.db.commit_family(family, self.trans) self.fam_rel.append(family_handle) if previous_errors == len(self.fam_rel): LOG(' OK: no broken parent relationships found') def check_events(self): self.progress.set_pass(_('Looking for event problems'), self.db.get_number_of_people() +self.db.get_number_of_families()) LOG('Looking for event problems') for key in self.db.get_person_handles(sort_handles=False): self.progress.step() person = self.db.get_person_from_handle(key) birth_ref = person.get_birth_ref() if birth_ref: birth_handle = birth_ref.ref birth = self.db.get_event_from_handle(birth_handle) if not birth: # The birth event referenced by the birth handle # does not exist in the database # This is tested by TestcaseGenerator person "Broken11" person.set_birth_ref(None) LOG(' FAIL: the person "%s" refers to a birth event' ' "%s" which does not exist in the database' % (person.gramps_id, birth_handle)) self.db.commit_person(person, self.trans) self.invalid_events.append(key) else: if int(birth.get_type()) != gen.lib.EventType.BIRTH: # Birth event was not of the type "Birth" # This is tested by TestcaseGenerator person "Broken14" LOG(' FAIL: the person "%s" refers to a birth event' ' which is of type "%s" instead of Birth' % (person.gramps_id, int(birth.get_type()))) birth.set_type(gen.lib.EventType(gen.lib.EventType.BIRTH)) self.db.commit_event(birth, self.trans) self.invalid_birth_events.append(key) death_ref = person.get_death_ref() if death_ref: death_handle = death_ref.ref death = self.db.get_event_from_handle(death_handle) if not death: # The death event referenced by the death handle # does not exist in the database # This is tested by TestcaseGenerator person "Broken12" LOG(' FAIL: the person "%s" refers to a death event' ' "%s" which does not exist in the database' % (person.gramps_id, death_handle)) person.set_death_ref(None) self.db.commit_person(person, self.trans) self.invalid_events.append(key) else: if int(death.get_type()) != gen.lib.EventType.DEATH: # Death event was not of the type "Death" # This is tested by TestcaseGenerator person "Broken15" LOG(' FAIL: the person "%s" refers to a death event' ' which is of type "%s" instead of Death' % (person.gramps_id, int(death.get_type()))) death.set_type(gen.lib.EventType(gen.lib.EventType.DEATH)) self.db.commit_event(death, self.trans) self.invalid_death_events.append(key) if person.get_event_ref_list(): for event_ref in person.get_event_ref_list(): event_handle = event_ref.ref event = self.db.get_event_from_handle(event_handle) if not event: # The event referenced by the person # does not exist in the database #TODO: There is no better way? # This is tested by TestcaseGenerator person "Broken11" # This is tested by TestcaseGenerator person "Broken12" # This is tested by TestcaseGenerator person "Broken13" LOG(' FAIL: the person "%s" refers to an event' ' "%s" which does not exist in the database' % (person.gramps_id, event_handle)) person.get_event_ref_list().remove(event_ref) self.db.commit_person(person,self.trans) self.invalid_events.append(key) elif not isinstance(person.get_event_ref_list(), list): # event_list is None or other garbage LOG(' FAIL: the person "%s" has an event ref list' ' which is invalid' % (person.gramps_id)) person.set_event_ref_list([]) self.db.commit_person(person, self.trans) self.invalid_events.append(key) for key in self.db.get_family_handles(): self.progress.step() family = self.db.get_family_from_handle(key) if family.get_event_ref_list(): for event_ref in family.get_event_ref_list(): event_handle = event_ref.ref event = self.db.get_event_from_handle(event_handle) if not event: # The event referenced by the family # does not exist in the database LOG(' FAIL: the family "%s" refers to an event' ' "%s" which does not exist in the database' % (family.gramps_id, event_handle)) nlist = [x for x in family.get_event_ref_list() if x.ref != event_handle] family.set_event_ref_list(nlist) self.db.commit_family(family, self.trans) self.invalid_events.append(key) elif not isinstance(family.get_event_ref_list(), list): # event_list is None or other garbage LOG(' FAIL: the family "%s" has an event ref list' ' which is invalid' % (family.gramps_id)) family.set_event_ref_list([]) self.db.commit_family(family, self.trans) self.invalid_events.append(key) if len (self.invalid_birth_events) + len(self.invalid_death_events) +\ len(self.invalid_events) == 0: LOG(' OK: no event problems found') def check_person_references(self): plist = self.db.get_person_handles() self.progress.set_pass(_('Looking for person reference problems'), len(plist)) LOG('Looking for person reference problems') for key in plist: self.progress.step() person = self.db.get_person_from_handle(key) for pref in person.get_person_ref_list(): p = self.db.get_person_from_handle( pref.ref) if not p: # The referenced person does not exist in the database person.get_person_ref_list().remove(pref) self.db.commit_person(person, self.trans) self.invalid_person_references.append(key) if len (self.invalid_person_references) == 0: LOG(' OK: no event problems found') def check_family_references(self): plist = self.db.get_person_handles() self.progress.set_pass(_('Looking for family reference problems'), len(plist)) LOG('Looking for family reference problems') for key in plist: self.progress.step() person = self.db.get_person_from_handle(key) for ordinance in person.get_lds_ord_list(): family_handle = ordinance.get_family_handle() if family_handle: family = self.db.get_family_from_handle(family_handle) if not family: # The referenced family does not exist in the database ordinance.set_family_handle(None) self.db.commit_person(person, self.trans) self.invalid_family_references.append(key) if len (self.invalid_family_references) == 0: LOG(' OK: no event problems found') def check_repo_references(self): slist = self.db.get_source_handles() self.progress.set_pass(_('Looking for repository reference problems'), len(slist)) LOG('Looking for repository reference problems') for key in slist: self.progress.step() source = self.db.get_source_from_handle(key) for reporef in source.get_reporef_list(): r = self.db.get_repository_from_handle(reporef.ref) if not r: # The referenced repository does not exist in the database source.get_reporef_list().remove(reporef) self.db.commit_source(source, self.trans) self.invalid_repo_references.append(key) if len (self.invalid_repo_references) == 0: LOG(' OK: no repository reference problems found') def check_place_references(self): plist = self.db.get_person_handles() flist = self.db.get_family_handles() elist = self.db.get_event_handles() self.progress.set_pass(_('Looking for place reference problems'), len(elist)+len(plist)+len(flist)) LOG('Looking for place reference problems') # check persons -> the LdsOrd references a place for key in plist: self.progress.step() person = self.db.get_person_from_handle(key) for ordinance in person.lds_ord_list: place_handle = ordinance.get_place_handle() if place_handle: place = self.db.get_place_from_handle(place_handle) if not place: # The referenced place does not exist in the database # This is tested by TestcaseGenerator person "Broken17" # This is tested by TestcaseGenerator person "Broken18" ordinance.set_place_handle("") LOG(' FAIL: the person "%s" refers to an LdsOrd' ' place "%s" which does not exist in the database' % (person.gramps_id, place_handle)) self.db.commit_person(person, self.trans) self.invalid_place_references.append(key) # check families -> the LdsOrd references a place for key in flist: self.progress.step() family = self.db.get_family_from_handle(key) for ordinance in family.lds_ord_list: place_handle = ordinance.get_place_handle() if place_handle: place = self.db.get_place_from_handle(place_handle) if not place: # The referenced place does not exist in the database ordinance.set_place_handle("") LOG(' FAIL: the family "%s" refers to an LdsOrd' ' place "%s" which does not exist in the database' % (family.gramps_id, place_handle)) self.db.commit_family(family, self.trans) self.invalid_place_references.append(key) # check events for key in elist: self.progress.step() event = self.db.get_event_from_handle(key) place_handle = event.get_place_handle() if place_handle: place = self.db.get_place_from_handle(place_handle) if not place: # The referenced place does not exist in the database event.set_place_handle("") LOG(' FAIL: the event "%s" refers to an LdsOrd place' ' "%s" which does not exist in the database' % (event.gramps_id, place_handle)) self.db.commit_event(event, self.trans) self.invalid_place_references.append(key) if len (self.invalid_place_references) == 0: LOG(' OK: no place reference problems found') def check_source_and_citation_references(self): # We check both source and citations in one pass. If there is a problem # with a citation reference from an object to a citation, then we need # to remove the reference from the object. This is the same as any other # reference check. However, if there is a problem with a source # reference from a citation to a source, we can't just remove the source # reference from the citation object (as we would in other cases), # because all citations must have exactly one source. Therefore we must # remove the citation as a whole, and also remove the reference to the # citation from the object. Hence the reason why we do this while we are # processing the object. # bad_citation_handles and invalid_citation_references are citation # handles which occur in objects and we need to remove these citation # references from the object. The citation reference needs to be removed # either because there is no such citation, or because the citation will # be removed as it doesn't point validly to a source object. # invalid_source_references are also citation handles, but these refer # to real citation object which need to be deleted because the citations # don't refer to valid sources. known_source_handles = self.db.get_source_handles() good_citation_handles = set() total = ( self.db.get_number_of_people() + self.db.get_number_of_families() + self.db.get_number_of_events() + self.db.get_number_of_places() + self.db.get_number_of_media_objects() + self.db.get_number_of_sources() + self.db.get_number_of_repositories() ) self.progress.set_pass(_('Looking for source and citation reference' ' problems'), total) LOG('Looking for source and citation reference problems') def check(name, map_func, class_func, commit_func): for handle in map_func.keys(): self.progress.step() info = map_func[handle] obj = class_func() obj.unserialize(info) handle_list = obj.get_referenced_handles_recursively() bad_citation_handles = set() bad_citation_text = set() for classn, handle in handle_list: if classn == 'Citation': if not handle: bad_citation_handles.add(handle) bad_citation_text.add("None") else: citation = self.db.get_citation_from_handle(handle) if not citation: bad_citation_handles.add(handle) bad_citation_text.add(handle) else: # The citation is good, check whether the # source_handle is OK source_handle = citation.source_handle if not source_handle or \ source_handle not in known_source_handles: bad_citation_handles.add(handle) bad_citation_text.add(citation.gramps_id + ": " + citation.page) if handle not in \ self.invalid_source_references: self.invalid_source_references.append( handle) else: good_citation_handles.add(handle) if bad_citation_handles: LOG(' FAIL: the %s "%s" refers to citation(s) "%s"' ' which do not exist in the database' ' or where the referenced source does not exist' % (name, obj.gramps_id, " ".join(h for h in bad_citation_text))) obj.remove_citation_references(list(bad_citation_handles)) commit_func(obj,self.trans) new_bad_handles = [handle for handle in bad_citation_handles if handle not in self.invalid_citation_references] self.invalid_citation_references += new_bad_handles check("person", self.db.person_map, gen.lib.Person, self.db.commit_person) check("family", self.db.family_map, gen.lib.Family, self.db.commit_family) check("event", self.db.event_map, gen.lib.Event, self.db.commit_event) check("media object", self.db.media_map, gen.lib.MediaObject, self.db.commit_media_object) check("place", self.db.place_map, gen.lib.Place, self.db.commit_place) check("repository", self.db.repository_map, gen.lib.Repository, self.db.commit_repository) # There is no point in checking sources, because they don't have # citations. # check("source", self.db.source_map, gen.lib.Source, # self.db.commit_source) # Now we need to check any citations that are not referenced from other # objects, in case they too have invalid source references. for handle in self.db.citation_map: if handle not in good_citation_handles: citation = self.db.get_citation_from_handle(handle) source_handle = citation.source_handle if not source_handle or \ source_handle not in known_source_handles: LOG(' FAIL: the citation "%s" refers to a source' ' "%s" which does not exist in the database' % (citation.gramps_id, citation.source_handle)) if handle not in \ self.invalid_source_references: self.invalid_source_references.append( handle) # bad citation references in objects have already been removed. Now # remove any bad citations that were detected. for citation_handle in self.invalid_source_references: LOG(' FAIL: the citation "%s" which refers to source handle "%s"' ' has been removed' % (self.db.get_citation_from_handle(citation_handle).gramps_id, self.db.get_citation_from_handle(citation_handle).source_handle)) self.db.remove_citation(citation_handle, self.trans) if len(self.invalid_source_references) + \ len(self.invalid_citation_references) == 0: LOG(' OK: no invalid source or citation references found') return def check_media_references(self): known_handles = self.db.get_media_object_handles(False) total = ( self.db.get_number_of_people() + self.db.get_number_of_families() + self.db.get_number_of_events() + self.db.get_number_of_places() + self.db.get_number_of_sources() ) self.progress.set_pass(_('Looking for media object reference problems'), total) LOG('Looking for media object reference problems') for handle in self.db.person_map.keys(): self.progress.step() info = self.db.person_map[handle] person = gen.lib.Person() person.unserialize(info) handle_list = person.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'MediaObject' and item[1] not in known_handles ] if bad_handles: person.remove_media_references(bad_handles) self.db.commit_person(person, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_media_references] self.invalid_media_references += new_bad_handles for handle in self.db.family_map.keys(): self.progress.step() info = self.db.family_map[handle] family = gen.lib.Family() family.unserialize(info) handle_list = family.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'MediaObject' and item[1] not in known_handles ] if bad_handles: family.remove_media_references(bad_handles) self.db.commit_family(family, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_media_references] self.invalid_media_references += new_bad_handles for handle in self.db.place_map.keys(): self.progress.step() info = self.db.place_map[handle] place = gen.lib.Place() place.unserialize(info) handle_list = place.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'MediaObject' and item[1] not in known_handles ] if bad_handles: place.remove_media_references(bad_handles) self.db.commit_place(place, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_media_references] self.invalid_media_references += new_bad_handles for handle in self.db.event_map.keys(): self.progress.step() info = self.db.event_map[handle] event = gen.lib.Event() event.unserialize(info) handle_list = event.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'MediaObject' and item[1] not in known_handles ] if bad_handles: event.remove_media_references(bad_handles) self.db.commit_event(event, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_media_references] self.invalid_media_references += new_bad_handles for handle in self.db.source_map.keys(): self.progress.step() info = self.db.source_map[handle] source = gen.lib.Source() source.unserialize(info) handle_list = source.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'MediaObject' and item[1] not in known_handles ] if bad_handles: source.remove_media_references(bad_handles) self.db.commit_source(source, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_media_references] self.invalid_media_references += new_bad_handles if len (self.invalid_media_references) == 0: LOG(' OK: no media reference problems found') def check_note_references(self): known_handles = self.db.get_note_handles() total = ( self.db.get_number_of_people() + self.db.get_number_of_families() + self.db.get_number_of_events() + self.db.get_number_of_places() + self.db.get_number_of_media_objects() + self.db.get_number_of_sources() + self.db.get_number_of_repositories() ) self.progress.set_pass(_('Looking for note reference problems'), total) LOG('Looking for note reference problems') for handle in self.db.person_map.keys(): self.progress.step() info = self.db.person_map[handle] person = gen.lib.Person() person.unserialize(info) handle_list = person.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'Note' and item[1] not in known_handles ] if bad_handles: map(person.remove_note, bad_handles) self.db.commit_person(person, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_note_references] self.invalid_note_references += new_bad_handles for handle in self.db.family_map.keys(): self.progress.step() info = self.db.family_map[handle] family = gen.lib.Family() family.unserialize(info) handle_list = family.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'Note' and item[1] not in known_handles ] if bad_handles: map(family.remove_note, bad_handles) self.db.commit_family(family, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_note_references] self.invalid_note_references += new_bad_handles for handle in self.db.place_map.keys(): self.progress.step() info = self.db.place_map[handle] place = gen.lib.Place() place.unserialize(info) handle_list = place.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'Note' and item[1] not in known_handles ] if bad_handles: map(place.remove_note, bad_handles) self.db.commit_place(place, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_note_references] self.invalid_note_references += new_bad_handles for handle in self.db.source_map.keys(): self.progress.step() info = self.db.source_map[handle] source = gen.lib.Source() source.unserialize(info) handle_list = source.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'Note' and item[1] not in known_handles ] for bad_handle in bad_handles: source.remove_note(bad_handle) if bad_handles: map(source.remove_note, bad_handles) self.db.commit_source(source, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_note_references] self.invalid_note_references += new_bad_handles for handle in self.db.media_map.keys(): self.progress.step() info = self.db.media_map[handle] obj = gen.lib.MediaObject() obj.unserialize(info) handle_list = obj.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'Note' and item[1] not in known_handles ] if bad_handles: map(obj.remove_note, bad_handles) self.db.commit_media_object(obj, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_note_references] self.invalid_note_references += new_bad_handles for handle in self.db.event_map.keys(): self.progress.step() info = self.db.event_map[handle] event = gen.lib.Event() event.unserialize(info) handle_list = event.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'Note' and item[1] not in known_handles ] if bad_handles: map(event.remove_note, bad_handles) self.db.commit_event(event, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_note_references] self.invalid_note_references += new_bad_handles for handle in self.db.repository_map.keys(): self.progress.step() info = self.db.repository_map[handle] repo = gen.lib.Repository() repo.unserialize(info) handle_list = repo.get_referenced_handles_recursively() bad_handles = [ item[1] for item in handle_list if item[0] == 'Note' and item[1] not in known_handles ] if bad_handles: map(repo.remove_note, bad_handles) self.db.commit_repository(repo, self.trans) new_bad_handles = [handle for handle in bad_handles if handle not in self.invalid_note_references] self.invalid_note_references += new_bad_handles if len (self.invalid_note_references) == 0: LOG(' OK: no note reference problems found') def build_report(self, uistate=None): self.progress.close() bad_photos = len(self.bad_photo) replaced_photos = len(self.replaced_photo) removed_photos = len(self.removed_photo) photos = bad_photos + replaced_photos + removed_photos efam = len(self.empty_family) blink = len(self.broken_links) plink = len(self.broken_parent_links) slink = len(self.duplicate_links) rel = len(self.fam_rel) event_invalid = len(self.invalid_events) birth_invalid = len(self.invalid_birth_events) death_invalid = len(self.invalid_death_events) person = birth_invalid + death_invalid person_references = len(self.invalid_person_references) family_references = len(self.invalid_family_references) invalid_dates = len(self.invalid_dates) place_references = len(self.invalid_place_references) citation_references = len(self.invalid_citation_references) source_references = len(self.invalid_source_references) repo_references = len(self.invalid_repo_references) media_references = len(self.invalid_media_references) note_references = len(self.invalid_note_references) name_format = len(self.removed_name_format) empty_objs = sum(len(obj) for obj in self.empty_objects.itervalues()) errors = (photos + efam + blink + plink + slink + rel + event_invalid + person + person_references + family_references + place_references + citation_references + repo_references + media_references + note_references + name_format + empty_objs + invalid_dates + source_references ) if errors == 0: if uistate: OkDialog(_("No errors were found"), _('The database has passed internal checks'), parent=uistate.window) else: print("No errors were found: the database has passed internal checks.") return 0 self.text = cStringIO.StringIO() if blink > 0: self.text.write( ngettext("%(quantity)d broken child/family link was fixed\n", "%(quantity)d broken child-family links were fixed\n", blink) % {'quantity': blink} ) for (person_handle, family_handle) in self.broken_links: person = self.db.get_person_from_handle(person_handle) if person: cn = person.get_primary_name().get_name() else: cn = _("Non existing child") try: family = self.db.get_family_from_handle(family_handle) pn = Utils.family_name(family, self.db) except: pn = _("Unknown") self.text.write('\t') self.text.write( _("%(person)s was removed from the family of %(family)s\n") % {'person': cn, 'family': pn} ) if plink > 0: self.text.write( ngettext("%(quantity)d broken spouse/family link was fixed\n", "%(quantity)d broken spouse/family links were fixed\n", plink) % {'quantity' : plink} ) for (person_handle, family_handle) in self.broken_parent_links: person = self.db.get_person_from_handle(person_handle) if person: cn = person.get_primary_name().get_name() else: cn = _("Non existing person") family = self.db.get_family_from_handle(family_handle) if family: pn = Utils.family_name(family, self.db) else: pn = family_handle self.text.write('\t') self.text.write( _("%(person)s was restored to the family of %(family)s\n") % {'person': cn, 'family': pn} ) if slink > 0: self.text.write( ngettext("%(quantity)d duplicate spouse/family link was found\n", "%(quantity)d duplicate spouse/family links were found\n", slink) % {'quantity': slink} ) for (person_handle, family_handle) in self.broken_parent_links: person = self.db.get_person_from_handle(person_handle) if person: cn = person.get_primary_name().get_name() else: cn = _("Non existing person") family = self.db.get_family_from_handle(family_handle) if family: pn = Utils.family_name(family, self.db) else: pn = _("None") self.text.write('\t') self.text.write( _("%(person)s was restored to the family of %(family)s\n") % {'person': cn, 'family': pn} ) if efam == 1: self.text.write( _("1 family with no parents or children found, removed.\n") ) self.text.write("\t%s\n" % self.empty_family[0]) elif efam > 1: self.text.write( _("%(quantity)d families with no parents or children, " "removed.\n") % {'quantity': efam} ) if rel: self.text.write( ngettext("%d corrupted family relationship fixed\n", "%d corrupted family relationship fixed\n", rel) % rel ) if person_references: self.text.write( ngettext("%d person was referenced but not found\n", "%d persons were referenced, but not found\n", person_references) % person_references ) if family_references: self.text.write( ngettext("%d family was referenced but not found\n", "%d families were referenced, but not found\n", family_references) % family_references ) if invalid_dates: self.text.write(ngettext("%d date was corrected\n", "%d dates were corrected\n", invalid_dates) % invalid_dates) if repo_references: self.text.write( ngettext("%(quantity)d repository was referenced but not found\n", "%(quantity)d repositories were referenced, but not found\n", repo_references) % {'quantity': repo_references}) if photos: self.text.write( ngettext("%(quantity)d media object was referenced, but not found\n", "%(quantity)d media objects were referenced, but not found\n", photos) % {'quantity' :photos} ) if bad_photos: self.text.write( ngettext("Reference to %(quantity)d missing media object was kept\n", "References to %(quantity)d media objects were kept\n", bad_photos) % {'quantity' :bad_photos} ) if replaced_photos: self.text.write( ngettext("%(quantity)d missing media object was replaced\n", "%(quantity)d missing media objects were replaced\n", replaced_photos) % {'quantity': replaced_photos} ) if removed_photos: self.text.write( ngettext("%(quantity)d missing media object was removed\n", "%(quantity)d missing media objects were removed\n", removed_photos) % {'quantity' : removed_photos} ) if event_invalid: self.text.write( ngettext("%(quantity)d invalid event reference was removed\n", "%(quantity)d invalid event references were removed\n", event_invalid) % {'quantity': event_invalid} ) if birth_invalid: self.text.write( ngettext("%(quantity)d invalid birth event name was fixed\n", "%(quantity)d invalid birth event names were fixed\n", birth_invalid) % {'quantity' : birth_invalid} ) if death_invalid: self.text.write( ngettext("%(quantity)d invalid death event name was fixed\n", "%(quantity)d invalid death event names were fixed\n", death_invalid) % {'quantity': death_invalid} ) if place_references: self.text.write( ngettext("%(quantity)d place was referenced but not found\n", "%(quantity)d places were referenced, but not found\n", place_references) % {'quantity': place_references} ) if citation_references: self.text.write( ngettext("%(quantity)d citation was referenced but not found\n", "%(quantity)d citations were referenced, but not found\n", citation_references) % {'quantity': citation_references} ) if source_references: self.text.write( ngettext("%(quantity)d source was referenced but not found\n", "%(quantity)d sources were referenced, but not found\n", source_references) % {'quantity': source_references} ) if media_references: self.text.write( ngettext("%(quantity)d media object was referenced but not found\n", "%(quantity)d media objects were referenced but not found\n", media_references) % {'quantity': media_references} ) if note_references: self.text.write( ngettext("%(quantity)d note object was referenced but not found\n", "%(quantity)d note objects were referenced but not found\n", note_references) % {'quantity': note_references}) if name_format: self.text.write( ngettext("%(quantity)d invalid name format reference was removed\n", "%(quantity)d invalid name format references were removed\n", name_format) % {'quantity' : name_format} ) if empty_objs > 0 : self.text.write(_("%(empty_obj)d empty objects removed:\n" " %(person)d person objects\n" " %(family)d family objects\n" " %(event)d event objects\n" " %(source)d source objects\n" " %(media)d media objects\n" " %(place)d place objects\n" " %(repo)d repository objects\n" " %(note)d note objects\n") % { 'empty_obj' : empty_objs, 'person' : len(self.empty_objects['persons']), 'family' : len(self.empty_objects['families']), 'event' : len(self.empty_objects['events']), 'source' : len(self.empty_objects['sources']), 'media' : len(self.empty_objects['media']), 'place' : len(self.empty_objects['places']), 'repo' : len(self.empty_objects['repos']), 'note' : len(self.empty_objects['notes']) } ) return errors #------------------------------------------------------------------------- # # Display the results # #------------------------------------------------------------------------- class Report(ManagedWindow.ManagedWindow): def __init__(self, uistate, text, cl=0): if cl: # Convert to file system encoding before printing print (text.encode(sys.getfilesystemencoding())) return ManagedWindow.ManagedWindow.__init__(self, uistate, [], self) topDialog = Glade() topDialog.get_object("close").connect('clicked', self.close) window = topDialog.toplevel textwindow = topDialog.get_object("textwindow") textwindow.get_buffer().set_text(text) self.set_window(window, #topDialog.get_widget("title"), topDialog.get_object("title"), _("Integrity Check Results")) self.show() def build_menu_names(self, obj): return (_('Check and Repair'), None) #------------------------------------------------------------------------ # # # #------------------------------------------------------------------------ class CheckOptions(tool.ToolOptions): """ Defines options and provides handling interface. """ def __init__(self, name, person_id=None): tool.ToolOptions.__init__(self, name, person_id)