def run(self): """ Perform the actual extraction of information. """ menu = self.options.menu self.filter = menu.get_option_by_name('filter').get_filter() sort_func_num = menu.get_option_by_name('sort_by').get_value() self.sort_desc = menu.get_option_by_name('sort_desc').get_value() self.fam_events = menu.get_option_by_name('family_events').get_value() sort_functions = _get_sort_functions(Sort(self.db)) self.sort_name = sort_functions[sort_func_num][0] self.sort_func = sort_functions[sort_func_num][1] self.sort = Sort(self.db) with DbTxn(_("Sort event changes"), self.db, batch=True) as trans: self.db.disable_signals() family_handles = self.sort_person_events(trans) if len(family_handles) > 0: self.sort_family_events(family_handles, trans) self.db.enable_signals() self.db.request_rebuild()
def gentest(self, button): """ Create some test notes. """ with DbTxn(_("Cleanup Test Notes"), self.db) as trans: gid = 'N99996' text='A note with <a target=new href="'\ 'http://seekingmichigan.org">'\ 'http://seekingmichigan.org</a>.' self.add_note(gid, text, trans) gid = 'N99997' text = 'http://www.google.com' self.add_note(gid, text, trans) gid = 'N99998' text= 'Quick test of <i>italics</i>, <b>bold</b>, <u>underline'\ '</u>, and <a href="http://www.google.com">Google</a>.' self.add_note(gid, text, trans) gid = 'N99999' text = 'An <??>issue</??> with this note' self.add_note(gid, text, trans)
def run(self): """ Run the dialog and return the result. """ self._populate_model() while True: # the self.top.run() makes Gtk make it modal, so any change to that # line would require the ManagedWindow.__init__ to be changed also response = self.top.run() if response == Gtk.ResponseType.HELP: display_help(webpage=WIKI_HELP_PAGE, section=WIKI_HELP_SEC) else: break # Save changed priority values if response == Gtk.ResponseType.CLOSE and self.__priorities_changed(): with DbTxn(_('Change Tag Priority'), self.db) as trans: self.__change_tag_priority(trans) if response != Gtk.ResponseType.DELETE_EVENT: self.close()
def addPlace(pname, ptype, refPlace=None, plang='fi'): place = Place() placeName = PlaceName() placeName.set_value(pname) placeName.set_language(plang) place.set_name(placeName) # place.set_change_time(chgtime) place.set_type(ptype) place.add_tag(tags[ptype]) if refPlace != None: placeRef = PlaceRef() placeRef.set_reference_handle(refPlace.get_handle()) place.add_placeref(placeRef) # tag.set_color("#EF2929") with DbTxn(_("Add Place"), db) as trans: phandle = db.add_place(place, trans) LOG.debug('Place added: ' + place.get_name().get_value() + ' ' + phandle) return place
def query_response(self): with DbTxn( _("Delete Event (%s)") % self.event.get_gramps_id(), self.db) as trans: self.db.disable_signals() ev_handle_list = [self.event.get_handle()] for handle in self.person_list: person = self.db.get_person_from_handle(handle) person.remove_handle_references('Event', ev_handle_list) self.db.commit_person(person, trans) for handle in self.family_list: family = self.db.get_family_from_handle(handle) family.remove_handle_references('Event', ev_handle_list) self.db.commit_family(family, trans) self.db.enable_signals() self.db.remove_event(self.event.get_handle(), trans)
def process(self): sql = self.openSQL() total = (sql.query("select count(*) from note;")[0][0] + sql.query("select count(*) from person;")[0][0] + sql.query("select count(*) from event;")[0][0] + sql.query("select count(*) from family;")[0][0] + sql.query("select count(*) from repository;")[0][0] + sql.query("select count(*) from place;")[0][0] + sql.query("select count(*) from media;")[0][0] + sql.query("select count(*) from tag;")[0][0] + sql.query("select count(*) from citation;")[0][0] + sql.query("select count(*) from source;")[0][0]) with DbTxn(_("CSV import"), self.db, batch=True) as self.trans: self.db.disable_signals() count = 0.0 self.t = time.time() self._process(count, total, sql) sql.db.commit() sql.db.close() return None
def save(self, *obj): """Save the data.""" self.ok_button.set_sensitive(False) self.update_note() if self.object_is_empty(): ErrorDialog( _("Cannot save note"), _("No data exists for this note. Please " "enter data or cancel the edit.")) self.ok_button.set_sensitive(True) return (uses_dupe_id, id) = self._uses_duplicate_id() if uses_dupe_id: msg1 = _("Cannot save note. ID already exists.") msg2 = _("You have attempted to use the existing Gramps ID with " "value %(id)s. This value is already used. Please " "enter a different ID or leave " "blank to get the next available ID value.") % { 'id': id } ErrorDialog(msg1, msg2) self.ok_button.set_sensitive(True) return with DbTxn('', self.db) as trans: if not self.obj.get_handle(): self.db.add_note(self.obj, trans) msg = _("Add Note") else: if not self.obj.get_gramps_id(): self.obj.set_gramps_id(self.db.find_next_note_gramps_id()) self.db.commit_note(self.obj, trans) msg = _("Edit Note") trans.set_description(msg) if self.callback: self.callback(self.obj.get_handle()) self.close()
def drag_data_received(self, widget, context, x, y, sel_data, info, time): """ Handle the standard gtk interface for drag_data_received. If the selection data is define, extract the value from sel_data.data, and decide if this is a move or a reorder. The only data we accept on mediaview is dropping a file, so URI_LIST. We assume this is what we obtain """ if not sel_data: return files = sel_data.get_uris() photo = None for file in files: protocol, site, mfile, j, k, l = urlparse(file) if protocol == "file": name = url2pathname(mfile) mime = get_type(name) if not is_valid_type(mime): return photo = Media() self.uistate.set_busy_cursor(True) photo.set_checksum(create_checksum(name)) self.uistate.set_busy_cursor(False) base_dir = str(media_path(self.dbstate.db)) if os.path.exists(base_dir): name = relative_path(name, base_dir) photo.set_path(name) photo.set_mime_type(mime) basename = os.path.basename(name) (root, ext) = os.path.splitext(basename) photo.set_description(root) with DbTxn(_("Drag Media Object"), self.dbstate.db) as trans: self.dbstate.db.add_media(photo, trans) if photo: self.uistate.set_active(photo.handle, "Media") widget.emit_stop_by_name('drag_data_received')
def save(self, *obj): self.ok_button.set_sensitive(False) if self.object_is_empty(): ErrorDialog( _("Cannot save source"), _("No data exists for this source. Please " "enter data or cancel the edit.")) self.ok_button.set_sensitive(True) return (uses_dupe_id, id) = self._uses_duplicate_id() if uses_dupe_id: prim_object = self.get_from_gramps_id(id) name = prim_object.get_title() msg1 = _("Cannot save source. ID already exists.") msg2 = _("You have attempted to use the existing Gramps ID with " "value %(id)s. This value is already used by '" "%(prim_object)s'. Please enter a different ID or leave " "blank to get the next available ID value.") % { 'id': id, 'prim_object': name } ErrorDialog(msg1, msg2) self.ok_button.set_sensitive(True) return with DbTxn('', self.db) as trans: if not self.obj.get_handle(): self.db.add_source(self.obj, trans) msg = _("Add Source (%s)") % self.obj.get_title() else: if not self.obj.get_gramps_id(): self.obj.set_gramps_id( self.db.find_next_source_gramps_id()) self.db.commit_source(self.obj, trans) msg = _("Edit Source (%s)") % self.obj.get_title() trans.set_description(msg) self.close() if self.callback: self.callback(self.obj)
def __get_places(self, obj): gov_id = self.entry.get_text() to_do = [gov_id] try: preferred_lang = config.get('preferences.place-lang') except AttributeError: fmt = config.get('preferences.place-format') pf = _pd.get_formats()[fmt] preferred_lang = pf.language if len(preferred_lang) != 2: preferred_lang = 'de' visited = {} if not self.type_dic: self.__get_types() with DbTxn(_('Add GOV-id place %s') % gov_id, self.dbstate.db) as trans: while to_do: gov_id = to_do.pop() place = self.dbstate.db.get_place_from_gramps_id(gov_id) if place is not None: visited[gov_id] = (place, []) else: place, ref_list = self.__get_place(gov_id, self.type_dic, preferred_lang) if place.get_name().get_value is not '': self.dbstate.db.add_place(place, trans) visited[gov_id] = (place, ref_list) for ref, date in ref_list: if (ref not in to_do) and (ref not in visited): to_do.append(ref) for place, ref_list in visited.values(): if len(ref_list) > 0: for ref, date in ref_list: handle = visited[ref][0].handle place_ref = PlaceRef() place_ref.ref = handle place_ref.set_date_object(date) place.add_placeref(place_ref) self.dbstate.db.commit_place(place, trans)
def save(self, *obj): self.ok_button.set_sensitive(False) if self.obj.get_name().get_value().strip() == '': msg1 = _("Cannot save place. Name not entered.") msg2 = _("You must enter a name before saving.") ErrorDialog(msg1, msg2) self.ok_button.set_sensitive(True) return (uses_dupe_id, id) = self._uses_duplicate_id() if uses_dupe_id: prim_object = self.get_from_gramps_id(id) name = place_displayer.display(self.db, prim_object) msg1 = _("Cannot save place. ID already exists.") msg2 = _("You have attempted to use the existing Gramps ID with " "value %(id)s. This value is already used by '" "%(prim_object)s'. Please enter a different ID or leave " "blank to get the next available ID value.") % { 'id': id, 'prim_object': name } ErrorDialog(msg1, msg2) self.ok_button.set_sensitive(True) return with DbTxn('', self.db) as trans: place_title = place_displayer.display(self.db, self.obj) if not self.obj.get_handle(): self.db.add_place(self.obj, trans) msg = _("Add Place (%s)") % place_title else: if not self.obj.get_gramps_id(): self.obj.set_gramps_id(self.db.find_next_place_gramps_id()) self.db.commit_place(self.obj, trans) msg = _("Edit Place (%s)") % place_title trans.set_description(msg) self.close() if self.callback: self.callback(self.obj)
def delete_person_response(self): """ Deletes the person from the database. """ # set the busy cursor, so the user knows that we are working self.uistate.set_busy_cursor(True) # create the transaction with DbTxn('', self.dbstate.db) as trans: # create name to save person = self.active_person active_name = _("Delete Person (%s)") % name_displayer.display(person) # delete the person from the database # Above will emit person-delete, which removes the person via # callback to the model, so row delete is signaled self.dbstate.db.delete_person_from_database(person, trans) trans.set_description(active_name) self.uistate.set_busy_cursor(False)
def post(self) -> Response: """Post a new object.""" require_permissions([PERM_ADD_OBJ]) obj = self._parse_object() if not obj: abort(400) db_handle = self.db_handle_writable with DbTxn("Add objects", db_handle) as trans: try: add_object(db_handle, obj, trans, fail_if_exists=True) except ValueError: abort(400) trans_dict = transaction_to_json(trans) # update search index indexer: SearchIndexer = current_app.config["SEARCH_INDEXER"] with indexer.get_writer(overwrite=False, use_async=True) as writer: for _trans_dict in trans_dict: handle = _trans_dict["handle"] class_name = _trans_dict["_class"] indexer.add_or_update_object(writer, handle, db_handle, class_name) return self.response(201, trans_dict, total_items=len(trans_dict))
def run(self): """Tool processing.""" db = self.dbstate.get_database() filter_ = self.__opt("families").get_filter() rel_value = int(self.__opt("relationship").get_value()) rel = FamilyRelType._DATAMAP[rel_value] all_families = db.iter_family_handles() families = filter_.apply(db, all_families) num = len(families) name = _("Family Relationship Tool") with DbTxn(name, db, batch=True) as self.trans: db.disable_signals() self.progress.set_pass(_('Process relationships...'), num) for handle in families: family = db.get_family_from_handle(handle) family.set_relationship(rel) db.commit_family(family, self.trans) self.progress.step() db.enable_signals() db.request_rebuild()
def tag_selected_rows(self, tag_handle): """ Tag the selected rows with the given tag. """ view = self.uistate.viewmanager.active_page selected = view.selected_handles() # Make the dialog modal so that the user can't start another # database transaction while the one setting tags is still running. pmon = progressdlg.ProgressMonitor(progressdlg.GtkProgressDialog, ("", self.uistate.window, Gtk.DialogFlags.MODAL), popup_time=2) status = progressdlg.LongOpStatus(msg=_("Adding Tags"), total_steps=len(selected), interval=len(selected)//20) pmon.add_op(status) tag = self.db.get_tag_from_handle(tag_handle) msg = _('Tag Selection (%s)') % tag.get_name() with DbTxn(msg, self.db) as trans: for object_handle in selected: status.heartbeat() view.add_tag(trans, object_handle, tag_handle) status.end()
def save(self, button): """ Called when the user clicks the OK button. """ with DbTxn(self.get_menu_title(), self.db) as trans: if not self.event.get_handle(): self.db.add_event(self.event, trans) citation_handle = self.citation.get_handle() if not self.citation.get_handle(): self.db.add_citation(self.citation, trans) self.event.add_citation(self.citation.get_handle()) else: self.db.commit_citation(self.citation, trans) self.headings.save() self.details.save(trans) self.db.commit_event(self.event, trans) self.close() self.callback()
def drag_data_received(self, widget, context, x, y, sel_data, info, time): """ Handle the standard gtk interface for drag_data_received. If the selection data is define, extract the value from sel_data.data, and decide if this is a move or a reorder. The only data we accept on mediaview is dropping a file, so URI_LIST. We assume this is what we obtain """ if not sel_data: return #modern file managers provide URI_LIST. For Windows split sel_data.data files = sel_data.get_uris() for file in files: if win(): clean_string = conv_to_unicode( file.replace('\0', ' ').replace("\r", " ").strip(), None) else: clean_string = file protocol, site, mfile, j, k, l = urlparse(clean_string) if protocol == "file": name = url2pathname(mfile) mime = get_type(name) if not is_valid_type(mime): return photo = MediaObject() self.uistate.set_busy_cursor(True) photo.set_checksum(create_checksum(name)) self.uistate.set_busy_cursor(False) base_dir = str(media_path(self.dbstate.db)) if os.path.exists(base_dir): name = relative_path(name, base_dir) photo.set_path(name) photo.set_mime_type(mime) basename = os.path.basename(name) (root, ext) = os.path.splitext(basename) photo.set_description(root) with DbTxn(_("Drag Media Object"), self.dbstate.db) as trans: self.dbstate.db.add_object(photo, trans) widget.emit_stop_by_name('drag_data_received')
def setUpClass(cls): cls.name = "Test Web API" cls.dbman = CLIDbManager(DbState()) _, _name = cls.dbman.create_new_db_cli(cls.name, dbid="sqlite") with patch.dict("os.environ", {ENV_CONFIG_FILE: TEST_AUTH_CONFIG}): cls.app = create_app() cls.app.config["TESTING"] = True cls.client = cls.app.test_client() sqlauth = cls.app.config["AUTH_PROVIDER"] sqlauth.create_table() sqlauth.add_user(name="user", password="******", role=ROLE_GUEST) sqlauth.add_user(name="admin", password="******", role=ROLE_OWNER) dbstate = cls.app.config["DB_MANAGER"].get_db(force_unlock=True) with DbTxn("Add test objects", dbstate.db) as trans: _add_person(Person.MALE, "John", "Allen", trans, dbstate.db) _add_person(Person.FEMALE, "Jane", "Secret", trans, dbstate.db, private=True) dbstate.db.close()
def lock_events(self, date, lock_no_date): with DbTxn(_("Set Privacy Tool"), self.db, batch=True) as self.trans: self.db.disable_signals() event_list = list(self.db.iter_events()) filter_option = self.options.menu.get_option_by_name( 'event_filter') event_filter = filter_option.get_filter() filtered_event_handles = event_filter.apply( self.db, self.db.iter_event_handles()) self.progress.set_pass(_('Set events private..'), len(filtered_event_handles)) cnt = [0, 0] for Event in event_list: if Event.handle not in filtered_event_handles: continue event_date = Event.get_date_object() set_privacy = None if event_date.get_year() == 0 and lock_no_date: set_privacy = True cnt[0] += 1 elif event_date.get_year() == 0 and not lock_no_date: set_privacy = False cnt[1] += 1 elif event_date.get_year() != 0 and event_date >= date: set_privacy = True cnt[0] += 1 else: set_privacy = False cnt[1] += 1 if set_privacy is not None and set_privacy != Event.private: Event.set_privacy(set_privacy) self.db.commit_event(Event, self.trans) self.progress.step() self.db.enable_signals() self.db.request_rebuild() self.cnt.append(("events", cnt[0], cnt[1]))
def fix_media(self, button): """ Fix paths to moved media files. """ progress = ProgressMeter(self.window_name, can_cancel=True, parent=self.window) progress.set_pass(_('Fixing file paths'), len(self.moved_files)) with DbTxn(_("Fix media paths"), self.db, batch=True) as trans: for handle, new_path in self.moved_files: media = self.db.get_media_from_handle(handle) media.set_path(new_path) self.db.commit_media(media, trans) progress.step() if progress.get_cancelled(): break self.models[0].clear() self.show_tabs() progress.close()
def __execute(self, obj): with DbTxn(_("Correcting invalid dates"), self.dbstate.db) as self.trans: selected_handles = self.uistate.viewmanager.active_page.selected_handles( ) num_places = len(selected_handles) for eventhandle in selected_handles: event = self.dbstate.db.get_event_from_handle(eventhandle) print(event) dateobj = event.get_date_object() datestr = dateobj.get_text() if dateobj.is_valid(): print(dateobj, "is valid") continue if datestr == "": print(dateobj, "is blank") continue print(datestr, "is INvalid") newdate = self.fix_date(datestr) print("newdate:", newdate) dateobj.set_text_value(newdate) self.dbstate.db.commit_event(event, self.trans)
def tearDown(self): with DbTxn('Remove test objects', self.db) as trans: for handle in self.handles['Person']: self.db.remove_person(handle, trans) for handle in self.handles['Family']: self.db.remove_family(handle, trans) for handle in self.handles['Event']: self.db.remove_event(handle, trans) for handle in self.handles['Place']: self.db.remove_place(handle, trans) for handle in self.handles['Repository']: self.db.remove_repository(handle, trans) for handle in self.handles['Source']: self.db.remove_source(handle, trans) for handle in self.handles['Citation']: self.db.remove_citation(handle, trans) for handle in self.handles['Media']: self.db.remove_media(handle, trans) for handle in self.handles['Note']: self.db.remove_note(handle, trans) for handle in self.handles['Tag']: self.db.remove_tag(handle, trans)
def lock_media(self, date, lock_no_date): with DbTxn(_("Set Privacy Tool"), self.db, batch=True) as self.trans: self.db.disable_signals() media_list = list(self.db.iter_media()) filter_option = self.options.menu.get_option_by_name( 'media_filter') media_filter = filter_option.get_filter() filtered_media_handles = media_filter.apply( self.db, self.db.iter_media_handles()) self.progress.set_pass(_('Set media private..'), len(filtered_media_handles)) cnt = [0, 0] for Media in media_list: if Media.handle not in filtered_media_handles: continue media_date = Media.get_date_object() set_privacy = None if media_date.get_year() == 0 and lock_no_date: set_privacy = True cnt[0] += 1 elif media_date.get_year() == 0 and not lock_no_date: set_privacy = False cnt[1] += 1 elif media_date.get_year() != 0 and media_date >= date: set_privacy = True cnt[0] += 1 else: set_privacy = False cnt[1] += 1 if set_privacy is not None and set_privacy != Media.private: Media.set_privacy(set_privacy) self.db.commit_media(Media, self.trans) self.progress.step() self.db.enable_signals() self.db.request_rebuild() self.cnt.append(("media", cnt[0], cnt[1]))
def addRepository(repositoryName, repositoryUrl, reftag): ridno = db.find_next_repository_gramps_id() repository = Repository() repositoryType = RepositoryType() repositoryType.set(RepositoryType.ARCHIVE) repository.set_type(repositoryType) repository.set_gramps_id(ridno) repository.set_name(repositoryName) urlList = [] # for urlPath in repositoryUrls: url = Url() url.set_path(repositoryUrl) url.set_description('Sshy') url.set_type(UrlType.WEB_HOME) urlList.append(url) repository.set_url_list(urlList) repository.set_change_time(chgtime) if reftag != None: repository.add_tag(reftag.get_handle()) with DbTxn(_("Add Repository"), db) as trans: rhandle = db.add_repository(repository, trans) return repository
def importData(dbase, filename, user): """Function called by Gramps to import data on persons in CSV format.""" dbase.disable_signals() try: with DbTxn(_("JSON import"), dbase, batch=True) as trans: with OpenFileOrStdin(filename, encoding="utf-8") as fp: line = fp.readline() while line: json = ast.literal_eval(line) obj = from_struct(json) if json["_class"] == "Person": dbase.add_person(obj, trans) elif json["_class"] == "Family": dbase.add_family(obj, trans) elif json["_class"] == "Event": dbase.add_event(obj, trans) elif json["_class"] == "MediaObject": dbase.add_object(obj, trans) elif json["_class"] == "Repository": dbase.add_repository(obj, trans) elif json["_class"] == "Tag": dbase.add_tag(obj, trans) elif json["_class"] == "Source": dbase.add_source(obj, trans) elif json["_class"] == "Citation": dbase.add_citation(obj, trans) elif json["_class"] == "Note": dbase.add_note(obj, trans) elif json["_class"] == "Place": dbase.add_place(obj, trans) else: LOG.warn("ignored: " + json) line = fp.readline() except EnvironmentError as err: user.notify_error(_("%s could not be opened\n") % filename, str(err)) dbase.enable_signals() dbase.request_rebuild()
def importData(db, filename, user): """Function called by Gramps to import data on persons in CSV format.""" db.disable_signals() try: with DbTxn(_("JSON import"), db, batch=True) as trans: with OpenFileOrStdin(filename, encoding="utf-8") as fp: line = fp.readline() while line: obj = from_json(line) if isinstance(obj, Person): db.add_person(obj, trans) elif isinstance(obj, Family): db.add_family(obj, trans) elif isinstance(obj, Event): db.add_event(obj, trans) elif isinstance(obj, Media): db.add_media(obj, trans) elif isinstance(obj, Repository): db.add_repository(obj, trans) elif isinstance(obj, Tag): db.add_tag(obj, trans) elif isinstance(obj, Source): db.add_source(obj, trans) elif isinstance(obj, Citation): db.add_citation(obj, trans) elif isinstance(obj, Note): db.add_note(obj, trans) elif isinstance(obj, Place): db.add_place(obj, trans) else: LOG.warn("ignored: " + data) line = fp.readline() except EnvironmentError as err: user.notify_error(_("%s could not be opened\n") % filename, str(err)) db.enable_signals() db.request_rebuild()
def post(self) -> Response: """Post a new object.""" require_permissions([PERM_ADD_OBJ]) mime = request.content_type if not mime: abort(HTTPStatus.NOT_ACCEPTABLE) checksum, f = process_file(request.stream) base_dir = current_app.config.get("MEDIA_BASE_DIR", "") media_handler = MediaHandler(base_dir) media_handler.upload_file(f, checksum, mime) path = media_handler.get_default_filename(checksum, mime) db_handle = self.db_handle_writable obj = Media() obj.set_checksum(checksum) obj.set_path(path) obj.set_mime_type(mime) with DbTxn("Add object", db_handle) as trans: try: add_object(db_handle, obj, trans) except ValueError: abort(400) trans_dict = transaction_to_json(trans) return self.response(201, trans_dict, total_items=len(trans_dict))
def test_editreference(self): dbstate = DbState() db = make_database("sqlite") path = "/tmp/edit_ref_test" try: os.mkdir(path) except: pass db.load(path) dbstate.change_database(db) source = Place() source.gramps_id = "P0001" with DbTxn("test place", dbstate.db) as trans: dbstate.db.add_place(source, trans) editor = MockEditReference(dbstate, uistate=None, track=[], source=source, source_ref=None, update=None) with patch('gramps.gui.editors.editreference.ErrorDialog') as MockED: editor.check_for_duplicate_id("Place") self.assertTrue(MockED.called)
def __removeTag(self, tag_handle): counter = 0 iter_people = self.dbstate.db.iter_person_handles() self.filter_option = self.options.menu.get_option_by_name('filter') self.filter = self.filter_option.get_filter() people = self.filter.apply(self.dbstate.db, iter_people) with DbTxn(_("Remove Tag Tool"), self.db, batch=True) as self.trans: self.db.disable_signals() num_people = len(people) self.progress.set_pass(_('Removing tags...'), num_people) for person_handle in people: person = self.dbstate.db.get_person_from_handle(person_handle) if tag_handle in person.get_tag_list(): person.remove_tag(tag_handle) self.db.commit_person(person, self.trans) counter += 1 self.db.enable_signals() self.db.request_rebuild() text = _("Tag removed from {} people.\n") text_f = text.format(str(counter)) OkDialog("INFO", text_f, parent=self.window)
def on_ok_clicked(self, obj): with DbTxn(_("Extract Place data"), self.db, batch=True) as self.trans: self.db.disable_signals() changelist = [node for node in self.iter_list if self.model.get_value(node, 0)] for change in changelist: row = self.model[change] place = self.db.get_place_from_handle(row[6]) location = ('', '', '', row[2], '', row[3], row[5]) self.place_import.store_location(location, place.handle) if row[2]: place.set_name(PlaceName(value=row[2])) place.set_type(PlaceType.CITY) if row[4]: place.set_code(row[4]) self.db.commit_place(place, self.trans) self.place_import.generate_hierarchy(self.trans) self.db.enable_signals() self.db.request_rebuild() self.close()