def from_struct(struct):
"""
Given a struct with metadata, create a Gramps object.
"""
from gramps.gen.lib import (Person, Family, Event, Source, Place, Citation,
Repository, MediaObject, Note, Tag)
if isinstance(struct, dict):
if "_class" in struct.keys():
if struct["_class"] == "Person":
return Person.create(Person.from_struct(struct))
elif struct["_class"] == "Family":
return Family.create(Family.from_struct(struct))
elif struct["_class"] == "Event":
return Event.create(Event.from_struct(struct))
elif struct["_class"] == "Source":
return Source.create(Source.from_struct(struct))
elif struct["_class"] == "Place":
return Place.create(Place.from_struct(struct))
elif struct["_class"] == "Citation":
return Citation.create(Citation.from_struct(struct))
elif struct["_class"] == "Repository":
return Repository.create(Repository.from_struct(struct))
elif struct["_class"] == "MediaObject":
return MediaObject.create(MediaObject.from_struct(struct))
elif struct["_class"] == "Note":
return Note.create(Note.from_struct(struct))
elif struct["_class"] == "Tag":
return Tag.create(Tag.from_struct(struct))
raise AttributeError("invalid struct: %s" % struct)
def __init__(self, dbstate, uistate, clicked):
self.clicked_func = clicked
self.filter_id = widgets.BasicEntry()
self.filter_name = widgets.BasicEntry()
self.filter_place = Place()
self.filter_place.set_type((PlaceType.CUSTOM, ''))
self.ptype = Gtk.ComboBox(has_entry=True)
if dbstate.is_open():
self.custom_types = dbstate.db.get_place_types()
else:
self.custom_types = []
self.place_menu = widgets.MonitoredDataType(
self.ptype,
self.filter_place.set_type,
self.filter_place.get_type,
False, # read-only
self.custom_types
)
self.filter_code = widgets.BasicEntry()
self.filter_enclosed = widgets.PlaceEntry(dbstate, uistate, [])
self.filter_note = widgets.BasicEntry()
self.filter_regex = Gtk.CheckButton(label=_('Use regular expressions'))
self.tag = Gtk.ComboBox()
self.generic = Gtk.ComboBox()
SidebarFilter.__init__(self, dbstate, uistate, "Place")
def instance_from_struct(cls, struct):
"""
Given a struct with metadata, create a Gramps object.
self is class when called as a classmethod.
"""
from gramps.gen.lib import (Person, Family, Event, Source, Place,
Citation, Repository, Media, Note, Tag,
Date)
if isinstance(struct, dict):
if "_class" in struct.keys():
if struct["_class"] == "Person":
return Person.create(Person.from_struct(struct))
elif struct["_class"] == "Family":
return Family.create(Family.from_struct(struct))
elif struct["_class"] == "Event":
return Event.create(Event.from_struct(struct))
elif struct["_class"] == "Source":
return Source.create(Source.from_struct(struct))
elif struct["_class"] == "Place":
return Place.create(Place.from_struct(struct))
elif struct["_class"] == "Citation":
return Citation.create(Citation.from_struct(struct))
elif struct["_class"] == "Repository":
return Repository.create(Repository.from_struct(struct))
elif struct["_class"] == "Media":
return Media.create(Media.from_struct(struct))
elif struct["_class"] == "Note":
return Note.create(Note.from_struct(struct))
elif struct["_class"] == "Tag":
return Tag.create(Tag.from_struct(struct))
elif struct["_class"] == "Date":
return Date().unserialize(
Date.from_struct(struct, full=True))
raise AttributeError("invalid struct: %s" % struct)
def instance_from_struct(cls, struct):
"""
Given a struct with metadata, create a Gramps object.
self is class when called as a classmethod.
"""
from gramps.gen.lib import (Person, Family, Event, Source, Place, Citation,
Repository, Media, Note, Tag, Date)
if isinstance(struct, dict):
if "_class" in struct.keys():
if struct["_class"] == "Person":
return Person.create(Person.from_struct(struct))
elif struct["_class"] == "Family":
return Family.create(Family.from_struct(struct))
elif struct["_class"] == "Event":
return Event.create(Event.from_struct(struct))
elif struct["_class"] == "Source":
return Source.create(Source.from_struct(struct))
elif struct["_class"] == "Place":
return Place.create(Place.from_struct(struct))
elif struct["_class"] == "Citation":
return Citation.create(Citation.from_struct(struct))
elif struct["_class"] == "Repository":
return Repository.create(Repository.from_struct(struct))
elif struct["_class"] == "Media":
return Media.create(Media.from_struct(struct))
elif struct["_class"] == "Note":
return Note.create(Note.from_struct(struct))
elif struct["_class"] == "Tag":
return Tag.create(Tag.from_struct(struct))
elif struct["_class"] == "Date":
return Date().unserialize(Date.from_struct(struct, full=True))
raise AttributeError("invalid struct: %s" % struct)
def from_struct(struct):
"""
Given a struct with metadata, create a Gramps object.
"""
from gramps.gen.lib import (Person, Family, Event, Source, Place, Citation,
Repository, MediaObject, Note, Tag)
if isinstance(struct, dict):
if "_class" in struct.keys():
if struct["_class"] == "Person":
return Person.create(Person.from_struct(struct))
elif struct["_class"] == "Family":
return Family.create(Family.from_struct(struct))
elif struct["_class"] == "Event":
return Event.create(Event.from_struct(struct))
elif struct["_class"] == "Source":
return Source.create(Source.from_struct(struct))
elif struct["_class"] == "Place":
return Place.create(Place.from_struct(struct))
elif struct["_class"] == "Citation":
return Citation.create(Citation.from_struct(struct))
elif struct["_class"] == "Repository":
return Repository.create(Repository.from_struct(struct))
elif struct["_class"] == "MediaObject":
return MediaObject.create(MediaObject.from_struct(struct))
elif struct["_class"] == "Note":
return Note.create(Note.from_struct(struct))
elif struct["_class"] == "Tag":
return Tag.create(Tag.from_struct(struct))
raise AttributeError("invalid struct: %s" % struct)
def __add_place(self, parent, plat, plon):
"""
Add a new place using longitude and latitude of location centered
on the map
"""
self.select_fct.close()
new_place = Place()
new_place.set_latitude(str(plat))
new_place.set_longitude(str(plon))
if parent:
if isinstance(parent, Place):
placeref = PlaceRef()
placeref.ref = parent
new_place.add_placeref(placeref)
else:
found = None
for place in self.dbstate.db.iter_places():
found = place
if place.name.get_value() == parent:
break
placeref = PlaceRef()
placeref.ref = found.get_handle()
new_place.add_placeref(placeref)
try:
EditPlace(self.dbstate, self.uistate, [], new_place)
self.add_marker(None, None, plat, plon, None, True, 0)
except WindowActiveError:
pass
def create_place(self):
""" Used to create a new person we know doesn't exist """
place = Place()
if self.default_tag:
place.add_tag(self.default_tag.handle)
self.db.add_place(place, self.trans)
self.place_count += 1
return place
def create_place(self):
""" Used to create a new person we know doesn't exist """
place = Place()
if self.default_tag:
place.add_tag(self.default_tag.handle)
self.db.add_place(place, self.trans)
self.place_count += 1
return place
def column_title(self, data):
handle = data[0]
cached, value = self.get_cached_value(handle, "PLACE")
if not cached:
place = Place()
place.unserialize(data)
value = place_displayer.display(self.db, place)
self.set_cached_value(handle, "PLACE", value)
return value
def column_title(self, data):
handle = data[0]
cached, value = self.get_cached_value(handle, "PLACE")
if not cached:
place = Place()
place.unserialize(data)
value = place_displayer.display(self.db, place)
self.set_cached_value(handle, "PLACE", value)
return value
def __add_place(self, parent, plat, plon):
"""
Add a new place using longitude and latitude of location centered
on the map
"""
self.select_fct.close()
new_place = Place()
new_place.set_latitude(str(plat))
new_place.set_longitude(str(plon))
if parent:
if isinstance(parent, Place):
placeref = PlaceRef()
placeref.ref = parent
new_place.add_placeref(placeref)
else:
found = None
for place in self.dbstate.db.iter_places():
found = place
if place.name.get_value() == parent:
break
placeref = PlaceRef()
placeref.ref = found.get_handle()
new_place.add_placeref(placeref)
try:
EditPlace(self.dbstate, self.uistate, [], new_place)
self.add_marker(None, None, plat, plon, None, True, 0)
except WindowActiveError:
pass
def test_editreference(self):
dbstate = DbState()
dbstate.db = self.db
source = Place()
source.gramps_id = "P0001"
self.db.place_map[source.handle] = source
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 get_or_create_place(self,place_name):
place = None
if place_name in self.pkeys:
place = self.db.get_place_from_handle(self.pkeys[place_name])
else:
place = Place()
place.set_title(place_name)
self.db.add_place(place,self.trans)
self.db.commit_place(place,self.trans)
self.pkeys[place_name] = place.get_handle()
return place
def get_or_create_place(self, place_name):
place = None
if place_name in self.pkeys:
place = self.db.get_place_from_handle(self.pkeys[place_name])
else:
place = Place()
place.set_title(place_name)
self.db.add_place(place, self.trans)
self.db.commit_place(place, self.trans)
self.pkeys[place_name] = place.get_handle()
return place
def get_or_create_place(self, place_name):
"Return the requested place object tuple-packed with a new indicator."
LOG.debug("get_or_create_place: looking for: %s", place_name)
for place_handle in self.db.iter_place_handles():
place = self.db.get_place_from_handle(place_handle)
if place.get_title() == place_name:
return (0, place)
place = Place()
place.set_title(place_name)
self.db.add_place(place, self.trans)
return (1, place)
def get_or_create_place(self, place_name):
"Return the requested place object tuple-packed with a new indicator."
LOG.debug("get_or_create_place: looking for: %s", place_name)
for place_handle in self.db.iter_place_handles():
place = self.db.get_place_from_handle(place_handle)
place_title = place_displayer.display(self.db, place)
if place_title == place_name:
return (0, place)
place = Place()
place.set_title(place_name)
self.db.add_place(place, self.trans)
return (1, place)
def object_extend(self,
obj: Place,
args: Dict,
locale: GrampsLocale = glocale) -> Place:
"""Extend place attributes as needed."""
db_handle = self.db_handle
if "profile" in args:
obj.profile = get_place_profile_for_object(db_handle=db_handle,
place=obj,
locale=locale)
if "extend" in args:
obj.extended = get_extended_attributes(db_handle, obj, args)
return obj
def test_editreference(self):
dbstate = DbState()
dbstate.db = self.db
source = Place()
source.gramps_id = "P0001"
self.db.place_map[source.handle] = source
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 __execute(self, obj):
with DbTxn(_("Processing marriages"), 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)
if not event.get_type().is_marriage(): continue
placehandle = event.get_place_handle()
place = self.dbstate.db.get_place_from_handle(placehandle)
pname = place.get_name().value
places = self.__match2(pname)
if not places: continue
print(places)
place1, husb_place, wife_place = places
family_handles = list(
self.dbstate.db.find_backlink_handles(
eventhandle, ['Family']))
print(family_handles)
for objtype, family_handle in family_handles:
family = self.dbstate.db.get_family_from_handle(
family_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
if not father_handle or not mother_handle: continue
father = self.dbstate.db.get_person_from_handle(
father_handle)
father_name = father.get_primary_name().get_name()
mother = self.dbstate.db.get_person_from_handle(
mother_handle)
mother_name = mother.get_primary_name().get_name()
print(father_name, mother_name)
self.__add_resi_event(father, husb_place,
event.get_date_object())
self.__add_resi_event(mother, wife_place,
event.get_date_object())
pn = PlaceName()
pn.set_value(place1)
newplace = Place()
newplace.set_name(pn)
newplacehandle = self.dbstate.db.add_place(
newplace, self.trans)
event.set_place_handle(newplacehandle)
event.set_description("marriage")
self.dbstate.db.commit_event(event, self.trans)
self.dbstate.db.commit_place(place, self.trans)
def add_place_from_kml(self, menu, event, lat, lon):
"""
Add new place(s) from a kml file
1 - ask for a kml file ?
2 - Read the kml file.
3 - create the place(s) with name and title found in the kml marker.
"""
dummy_menu = menu
dummy_event = event
dummy_lat = lat
dummy_lon = lon
# Ask for the kml file
filtering = Gtk.FileFilter()
filtering.add_pattern("*.kml")
kml = Gtk.FileChooserDialog(_("Select a kml file used to add places"),
action=Gtk.FileChooserAction.OPEN,
parent=self.uistate.window,
buttons=(_('_Cancel'),
Gtk.ResponseType.CANCEL,
_('_Apply'), Gtk.ResponseType.OK))
mpath = HOME_DIR
kml.set_current_folder(os.path.dirname(mpath))
kml.set_filter(filtering)
status = kml.run()
if status == Gtk.ResponseType.OK:
val = kml.get_filename()
if val:
kmlfile = Kml(val)
points = kmlfile.add_points()
for place in points:
(name, coords) = place
latlong = coords.pop()
(lat, lon) = latlong
place_name = PlaceName()
place_name.set_value(name)
new_place = Place()
new_place.set_name(place_name)
new_place.set_title(name)
new_place.set_latitude(str(lat))
new_place.set_longitude(str(lon))
try:
EditPlace(self.dbstate, self.uistate, [], new_place)
except WindowActiveError:
pass
kml.destroy()
def get_or_create_place(self, place_name):
"Return the requested place object tuple-packed with a new indicator."
if place_name.startswith("[") and place_name.endswith("]"):
place = self.lookup("place", place_name)
return (0, place)
LOG.debug("get_or_create_place: looking for: %s", place_name)
for place_handle in self.db.iter_place_handles():
place = self.db.get_place_from_handle(place_handle)
place_title = place_displayer.display(self.db, place)
if place_title == place_name:
return (0, place)
place = Place()
place.set_title(place_name)
place.name = PlaceName(value=place_name)
self.db.add_place(place, self.trans)
return (1, place)
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:
data = json.loads(line)
if data["_class"] == "Person":
obj = Person.create(Person.from_struct(data))
db.add_person(obj, trans)
elif data["_class"] == "Family":
obj = Family.create(Family.from_struct(data))
db.add_family(obj, trans)
elif data["_class"] == "Event":
obj = Event.create(Event.from_struct(data))
db.add_event(obj, trans)
elif data["_class"] == "Media":
obj = Media.create(Media.from_struct(data))
db.add_media(obj, trans)
elif data["_class"] == "Repository":
obj = Repository.create(Repository.from_struct(data))
db.add_repository(obj, trans)
elif data["_class"] == "Tag":
obj = Tag.create(Tag.from_struct(data))
db.add_tag(obj, trans)
elif data["_class"] == "Source":
obj = Source.create(Source.from_struct(data))
db.add_source(obj, trans)
elif data["_class"] == "Citation":
obj = Citation.create(Citation.from_struct(data))
db.add_citation(obj, trans)
elif data["_class"] == "Note":
obj = Note.create(Note.from_struct(data))
db.add_note(obj, trans)
elif data["_class"] == "Place":
obj = Place.create(Place.from_struct(data))
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 get_place_profile_for_object(
db_handle: DbReadBase,
place: Place,
locale: GrampsLocale = glocale,
parent_places: bool = True,
) -> Dict[str, Any]:
"""Get place profile given a Place."""
latitude, longitude = conv_lat_lon(place.lat, place.long, format="D.D8")
profile = {
"gramps_id":
place.gramps_id,
"type":
_format_place_type(place.get_type(), locale=locale),
"name":
place.get_name().value,
"alternate_names":
[place_name.value for place_name in place.get_alternative_names()],
"lat":
float(latitude) if (latitude and longitude) else None,
"long":
float(longitude) if (latitude and longitude) else None,
}
if parent_places:
parent_places_handles = []
_place = place
handle = None
while True:
for placeref in _place.get_placeref_list():
handle = placeref.ref
break
if handle is None or handle in parent_places_handles:
break
_place = db_handle.get_place_from_handle(handle)
if _place is None:
break
parent_places_handles.append(handle)
profile["parent_places"] = [
get_place_profile_for_object(
db_handle=db_handle,
place=db_handle.get_place_from_handle(parent_place),
locale=locale,
parent_places=False,
) for parent_place in parent_places_handles
]
return profile
def add(self, obj):
"""
Add a new place. Use the currently selected rows as parent places.
"""
parent_list = []
for handle in self.selected_handles():
placeref = PlaceRef()
placeref.ref = handle
parent_list.append(placeref)
place = Place()
if len(parent_list) > 0:
place.placeref_list = parent_list
try:
EditPlace(self.dbstate, self.uistate, [], place)
except WindowActiveError:
pass
def __get_level0(self):
countries = []
with self.dbstate.db.get_place_cursor() as cursor:
pair = cursor.first()
while pair:
(handle, data) = pair
print(pair)
place = Place()
place.unserialize(data)
placetype = place.get_type().value
print(placetype)
# if getattr(PlaceType, place['type']).upper() == PlaceType.COUNTRY:
if placetype == PlaceType.COUNTRY:
print("Country found")
countries.append(place)
pair = cursor.next()
# print(countries)
return countries
def __add_resi_event(self, person, placename, date_object):
pn = PlaceName()
pn.set_value(placename)
place = Place()
place.set_name(pn)
placehandle = self.dbstate.db.add_place(place, self.trans)
e = Event()
e.set_type(EventType.RESIDENCE)
e.set_date_object(date_object)
e.set_place_handle(placehandle)
e.set_description("marriage")
eventhandle = self.dbstate.db.add_event(e, self.trans)
eref = EventRef()
eref.ref = eventhandle
person.add_event_ref(eref)
self.dbstate.db.commit_person(person, self.trans)
def add(self, obj):
"""
Add a new place. Use the currently selected rows as parent places.
"""
parent_list = []
for handle in self.selected_handles():
placeref = PlaceRef()
placeref.ref = handle
parent_list.append(placeref)
place = Place()
if len(parent_list) > 0:
place.placeref_list = parent_list
try:
EditPlace(self.dbstate, self.uistate, [], place)
except WindowActiveError:
pass
def test_editreference(self):
dbstate = DbState()
db = make_database("bsddb")
path = "/tmp/edit_ref_test"
try:
os.mkdir(path)
except:
pass
db.load(path)
dbstate.change_database(db)
source = Place()
source.gramps_id = "P0001"
dbstate.db.place_map[source.handle] = source.serialize()
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 add_button_clicked(self, obj):
ref = PlaceRef()
place = Place()
try:
from .. import EditPlaceRef
EditPlaceRef(self.dbstate, self.uistate, self.track, place, ref,
self.add_callback)
except WindowActiveError:
pass
def test_editreference(self):
dbstate = DbState()
db = dbstate.make_database("bsddb")
path = "/tmp/edit_ref_test"
try:
os.mkdir(path)
except:
pass
db.write_version(path)
db.load(path)
dbstate.change_database(db)
source = Place()
source.gramps_id = "P0001"
dbstate.db.place_map[source.handle] = source.serialize()
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 call_editor(self, obj=None):
if obj is None:
place = Place()
func = self.obj_added
else:
place = obj
func = self.after_edit
try:
EditPlace(self.dbstate, self.uistate, self.track, place, func)
except WindowActiveError:
pass
def __init__(self, dbstate, uistate, clicked):
self.clicked_func = clicked
self.filter_id = widgets.BasicEntry()
self.filter_title = widgets.BasicEntry()
self.filter_name = widgets.BasicEntry()
self.filter_place = Place()
self.filter_place.set_type((PlaceType.CUSTOM, ''))
self.ptype = Gtk.ComboBox(has_entry=True)
self.place_menu = widgets.MonitoredDataType(self.ptype,
self.filter_place.set_type,
self.filter_place.get_type)
self.filter_code = widgets.BasicEntry()
self.filter_note = widgets.BasicEntry()
self.filter_regex = Gtk.CheckButton(label=_('Use regular expressions'))
self.tag = Gtk.ComboBox()
self.generic = Gtk.ComboBox()
SidebarFilter.__init__(self, dbstate, uistate, "Place")
def run(self):
"""
Generate the hierarchy.
"""
with self.user.progress(_("Generating hierarchy"), '',
self.db.get_number_of_places()) as step:
for handle in self.db.get_place_handles():
step()
place = self.db.get_place_from_handle(handle)
if (int(place.get_type()) != PlaceType.UNKNOWN
or ',' not in place.get_title()):
# Only process places with a type of Unknown.
continue
names = [
name.strip() for name in place.get_title().split(',')
if name.strip()
]
place_name = PlaceName()
place_name.set_value(names[0])
place.set_name(place_name)
place.set_title('')
parent_handle = None
for name, handle in self.find_hierarchy(names)[:-1]:
if handle is None:
new_place = Place()
place_name = PlaceName()
place_name.set_value(name)
new_place.set_name(place_name)
if parent_handle is None:
new_place.set_type(PlaceType.COUNTRY)
if parent_handle is not None:
placeref = PlaceRef()
placeref.ref = parent_handle
new_place.add_placeref(placeref)
with DbTxn(_("Add Place"), self.db) as trans:
parent_handle = self.db.add_place(new_place, trans)
else:
parent_handle = handle
if parent_handle is not None:
placeref = PlaceRef()
placeref.ref = parent_handle
place.add_placeref(placeref)
with DbTxn(_("Edit Place"), self.db) as trans:
self.db.commit_place(place, trans)
def add_place_from_kml(self, menu, event, lat, lon):
"""
Add new place(s) from a kml file
1 - ask for a kml file ?
2 - Read the kml file.
3 - create the place(s) with name and title found in the kml marker.
"""
# Ask for the kml file
filtering = Gtk.FileFilter()
filtering.add_pattern("*.kml")
kml = Gtk.FileChooserDialog(
_("Select a kml file used to add places"),
action=Gtk.FileChooserAction.OPEN,
parent=self.uistate.window,
buttons=(_('_Cancel'), Gtk.ResponseType.CANCEL,
_('_Apply'), Gtk.ResponseType.OK))
mpath = HOME_DIR
kml.set_current_folder(os.path.dirname(mpath))
kml.set_filter(filtering)
status = kml.run()
if status == Gtk.ResponseType.OK:
val = kml.get_filename()
if val:
kmlfile = Kml(val)
points = kmlfile.add_points()
for place in points:
(name, coords) = place
latlong = coords.pop()
(lat, lon) = latlong
place_name = PlaceName()
place_name.set_value(name)
new_place = Place()
new_place.set_name(place_name)
new_place.set_title(name)
new_place.set_latitude(str(lat))
new_place.set_longitude(str(lon))
try:
EditPlace(self.dbstate, self.uistate, [], new_place)
except WindowActiveError:
pass
kml.destroy()
def post(self, path):
if "/" in path:
handle, action = path.split("/")
else:
handle, action = path, "view"
if handle == "add":
place = Place()
place.handle = handle = create_id()
else:
place = self.database.get_place_from_handle(handle)
form = PlaceForm(self.database, _, instance=place)
form.save(handler=self)
self.redirect("/place/%(handle)s" % {"handle": handle})
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 __generate_hierarchy(self, place, original_enclosing_places):
# Generates the hierarchy.
# Returns the place at the top of the hierarchy or None if no hierarchy was generated
original_name = place.get_name().get_value()
if original_name == "":
original_name = place.get_title()
separator = ','
if self.spaces.get_active():
separator = None
if ' ' not in original_name:
return None
else:
if ',' not in original_name:
return None
names = [
name.strip() for name in original_name.split(separator)
if name.strip()
]
if self.reverse.get_active():
names.reverse()
place_name = PlaceName()
place_name.set_value(names[0])
place.set_name(place_name)
place.set_title('')
parent_handle = None
top_place = place
for name, handle, new_place in self.find_hierarchy(
names, original_enclosing_places)[:-1]:
if handle is None:
new_place = Place()
place_name = PlaceName()
place_name.set_value(name)
new_place.set_name(place_name)
if parent_handle is None:
top_place = new_place
if parent_handle is not None:
placeref = PlaceRef()
placeref.ref = parent_handle
placeref.set_date_object(self.date_object)
new_place.add_placeref(placeref)
parent_handle = self.dbstate.db.add_place(
new_place, self.trans)
else:
if parent_handle is None:
top_place = new_place
parent_handle = handle
if parent_handle is not None:
placeref = PlaceRef()
placeref.ref = parent_handle
placeref.set_date_object(self.date_object)
place.set_placeref_list([placeref
]) # this removes any previous parent
return top_place
def __add_place(self, parent, plat, plon):
"""
Add a new place using longitude and latitude of location centered
on the map
"""
self.select_fct.close()
new_place = Place()
new_place.set_latitude(str(plat))
new_place.set_longitude(str(plon))
if parent:
placeref = PlaceRef()
placeref.ref = parent
new_place.add_placeref(placeref)
try:
EditPlace(self.dbstate, self.uistate, [], new_place)
self.add_marker(None, None, plat, plon, None, True, 0)
except WindowActiveError:
pass
def process_note(self,notehandle):
if notehandle in self.notehandles: return # already found thru a place
note = self.db.get_note_from_handle(notehandle)
notetext = note.get()
if notetext.startswith(self.tag):
info = json.loads(notetext.split(maxsplit=1)[1])
id = info["id"]
if id in self.places:
#print("note {id} already found: {info}".format(**locals()))
return # already found thru a place, should not get here!
place = Place()
self.set_info(place,info)
placehandle = self.db.add_place(place,self.trans)
self.db.commit_place(place, self.trans)
self.places[id] = (placehandle,info)
self.notehandles.add(notehandle)
log(2,info,notehandle)
def __add_place(self, name, type_num, parent, title, trans):
"""
Add a missing place to the database.
"""
place = Place()
place.name = name
place.title = title
place.place_type = PlaceType(7 - type_num)
if parent is not None:
placeref = PlaceRef()
placeref.ref = handle2internal(parent)
place.set_placeref_list([placeref])
handle = self.db.add_place(place, trans)
self.db.commit_place(place, trans)
return handle
def get(self, path=""):
"""
HANDLE
HANDLE/edit|delete
/add
b2cfa6ca1e174b1f63d/remove/eventref/1
"""
page = int(self.get_argument("page", 1))
search = self.get_argument("search", "")
if "/" in path:
handle, action = path.split("/", 1)
else:
handle, action = path, "view"
if handle:
if handle == "add":
place = Place()
action = "edit"
else:
place = self.database.get_place_from_handle(handle)
if place:
self.render(
"place.html",
**self.get_template_dict(tview=_("place detail"),
action=action,
page=page,
search=search,
form=PlaceForm(self.database,
_,
instance=place),
logform=None))
return
else:
self.clear()
self.set_status(404)
self.finish("<html><body>No such place</body></html>")
return
self.render(
"page_view.html",
**self.get_template_dict(
tview=_("place view"),
page=page,
search=search,
form=PlaceForm(self.database, _, table="Place"),
))
def __add_place(self, name, type_num, parent, title, trans):
"""
Add a missing place to the database.
"""
place = Place()
place_name = PlaceName()
place_name.set_value(name)
place.name = place_name
place.title = title
place.place_type = PlaceType(7 - type_num)
if parent is not None:
placeref = PlaceRef()
placeref.ref = parent.decode('utf-8')
place.set_placeref_list([placeref])
handle = self.db.add_place(place, trans)
self.db.commit_place(place, trans)
return handle
def __add_place(self, parent, plat, plon):
"""
Add a new place using longitude and latitude of location centered
on the map
"""
self.select_fct.close()
new_place = Place()
new_place.set_latitude(str(plat))
new_place.set_longitude(str(plon))
if parent:
placeref = PlaceRef()
placeref.ref = parent
new_place.add_placeref(placeref)
try:
EditPlace(self.dbstate, self.uistate, [], new_place)
self.add_marker(None, None, plat, plon, None, True, 0)
except WindowActiveError:
pass
def __init__(self, dbstate, uistate, clicked):
self.clicked_func = clicked
self.filter_id = widgets.BasicEntry()
self.filter_title = widgets.BasicEntry()
self.filter_name = widgets.BasicEntry()
self.filter_place = Place()
self.filter_place.set_type((PlaceType.CUSTOM, ''))
self.ptype = Gtk.ComboBox(has_entry=True)
self.place_menu = widgets.MonitoredDataType(
self.ptype,
self.filter_place.set_type,
self.filter_place.get_type)
self.filter_code = widgets.BasicEntry()
self.filter_note = widgets.BasicEntry()
self.filter_regex = Gtk.CheckButton(label=_('Use regular expressions'))
self.tag = Gtk.ComboBox()
self.generic = Gtk.ComboBox()
SidebarFilter.__init__(self, dbstate, uistate, "Place")
def __add_place(self, name, type_num, parent, title, trans):
"""
Add a missing place to the database.
"""
place = Place()
place_name = PlaceName()
place_name.set_value(name)
place.name = place_name
place.title = title
place.place_type = PlaceType(7-type_num)
if parent is not None:
placeref = PlaceRef()
placeref.ref = handle2internal(parent)
place.set_placeref_list([placeref])
handle = self.db.add_place(place, trans)
self.db.commit_place(place, trans)
return handle
class PlaceSidebarFilter(SidebarFilter):
def __init__(self, dbstate, uistate, clicked):
self.clicked_func = clicked
self.filter_id = widgets.BasicEntry()
self.filter_name = widgets.BasicEntry()
self.filter_place = Place()
self.filter_place.set_type((PlaceType.CUSTOM, ''))
self.ptype = Gtk.ComboBox(has_entry=True)
if dbstate.is_open():
self.custom_types = dbstate.db.get_place_types()
else:
self.custom_types = []
self.place_menu = widgets.MonitoredDataType(
self.ptype,
self.filter_place.set_type,
self.filter_place.get_type,
False, # read-only
self.custom_types
)
self.filter_code = widgets.BasicEntry()
self.filter_enclosed = widgets.PlaceEntry(dbstate, uistate, [])
self.filter_note = widgets.BasicEntry()
self.filter_regex = Gtk.CheckButton(label=_('Use regular expressions'))
self.tag = Gtk.ComboBox()
self.generic = Gtk.ComboBox()
SidebarFilter.__init__(self, dbstate, uistate, "Place")
def create_widget(self):
cell = Gtk.CellRendererText()
cell.set_property('width', self._FILTER_WIDTH)
cell.set_property('ellipsize', self._FILTER_ELLIPSIZE)
self.generic.pack_start(cell, True)
self.generic.add_attribute(cell, 'text', 0)
self.on_filters_changed('Place')
cell = Gtk.CellRendererText()
cell.set_property('width', self._FILTER_WIDTH)
cell.set_property('ellipsize', self._FILTER_ELLIPSIZE)
self.tag.pack_start(cell, True)
self.tag.add_attribute(cell, 'text', 0)
self.add_text_entry(_('ID'), self.filter_id)
self.add_text_entry(_('Name'), self.filter_name)
self.add_entry(_('Type'), self.ptype)
self.add_text_entry(_('Code'), self.filter_code)
self.add_text_entry(_('Enclosed By'), self.filter_enclosed)
self.add_text_entry(_('Note'), self.filter_note)
self.add_entry(_('Tag'), self.tag)
self.add_filter_entry(_('Custom filter'), self.generic)
self.add_regex_entry(self.filter_regex)
def clear(self, obj):
self.filter_id.set_text('')
self.filter_name.set_text('')
self.filter_code.set_text('')
self.filter_enclosed.set_text('')
self.filter_note.set_text('')
self.ptype.get_child().set_text('')
self.tag.set_active(0)
self.generic.set_active(0)
def get_filter(self):
gid = str(self.filter_id.get_text()).strip()
name = str(self.filter_name.get_text()).strip()
ptype = self.filter_place.get_type().xml_str()
code = str(self.filter_code.get_text()).strip()
enclosed = str(self.filter_enclosed.get_text()).strip()
note = str(self.filter_note.get_text()).strip()
regex = self.filter_regex.get_active()
tag = self.tag.get_active() > 0
gen = self.generic.get_active() > 0
empty = not (gid or name or ptype or code or enclosed or note or regex
or tag or gen)
if empty:
generic_filter = None
else:
generic_filter = GenericPlaceFilter()
if gid:
rule = RegExpIdOf([gid], use_regex=regex)
generic_filter.add_rule(rule)
if enclosed:
rule = IsEnclosedBy([enclosed, '0'])
generic_filter.add_rule(rule)
rule = HasData([name, ptype, code], use_regex=regex)
generic_filter.add_rule(rule)
if note:
rule = HasNoteRegexp([note], use_regex=regex)
generic_filter.add_rule(rule)
# check the Tag
if tag:
model = self.tag.get_model()
node = self.tag.get_active_iter()
attr = model.get_value(node, 0)
rule = HasTag([attr])
generic_filter.add_rule(rule)
if self.generic.get_active() != 0:
model = self.generic.get_model()
node = self.generic.get_active_iter()
obj = str(model.get_value(node, 0))
rule = MatchesFilter([obj])
generic_filter.add_rule(rule)
return generic_filter
def on_filters_changed(self, name_space):
if name_space == 'Place':
all_filter = GenericPlaceFilter()
all_filter.set_name(_("None"))
all_filter.add_rule(rules.place.AllPlaces([]))
self.generic.set_model(build_filter_model('Place', [all_filter]))
self.generic.set_active(0)
def on_tags_changed(self, tag_list):
"""
Update the list of tags in the tag filter.
"""
model = Gtk.ListStore(str)
model.append(('',))
for tag_name in tag_list:
model.append((tag_name,))
self.tag.set_model(model)
self.tag.set_active(0)
def __add_place(self, parent, plat, plon):
"""
Add a new place using longitude and latitude of location centered
on the map
"""
self.select_fct.close()
new_place = Place()
new_place.set_latitude(str(plat))
new_place.set_longitude(str(plon))
if parent:
if isinstance(parent, Place):
placeref = PlaceRef()
placeref.ref = parent
new_place.add_placeref(placeref)
elif isinstance(parent, gi.overrides.Gtk.TreeModelRow):
# We are here because we selected a place from geocoding
# parent[0] : country
# parent[1] : state
# parent[2] : town
# parent[3] : name
value = PlaceSelection.untag_text(parent[2], 1)
plname = PlaceName()
plname.set_value(value)
handle = self.place_exists(value)
if handle:
# The town already exists. We create a place with name
placeref = PlaceRef()
placeref.ref = handle
new_place.add_placeref(placeref)
value = PlaceSelection.untag_text(parent[3], 1)
plname.set_value(value)
new_place.set_name(plname)
else:
found = None
for place in self.dbstate.db.iter_places():
found = place
if place.name.get_value() == parent:
break
placeref = PlaceRef()
placeref.ref = found.get_handle()
new_place.add_placeref(placeref)
try:
EditPlace(self.dbstate, self.uistate, [], new_place)
self.add_marker(None, None, plat, plon, None, True, 0)
except WindowActiveError:
pass
def __get_place(self, gov_id, type_dic, preferred_lang):
gov_url = 'http://gov.genealogy.net/semanticWeb/about/' + quote(gov_id)
response = urlopen(gov_url)
data = response.read()
dom = parseString(data)
top = dom.getElementsByTagName('gov:GovObject')
place = Place()
place.gramps_id = gov_id
if not len(top) :
return place, []
types = []
for element in top[0].getElementsByTagName('gov:hasName'):
place_name = self.__get_hasname(element)
place.add_name(place_name)
for element in top[0].getElementsByTagName('gov:hasType'):
place_type = self.__get_hastype(element, type_dic,
preferred_lang)
types.append(place_type)
types.sort(key=lambda typ: typ.date.get_sort_value(), reverse=True)
place.set_types(types)
for element in top[0].getElementsByTagName('gov:position'):
latitude, longitude = self.__get_position(element)
place.set_latitude(latitude)
place.set_longitude(longitude)
ref_list = []
for element in top[0].getElementsByTagName('gov:isPartOf'):
ref, date = self.__get_ispartof(element)
ref_list.append((ref, date))
for element in top[0].getElementsByTagName('gov:hasURL'):
url = self.__get_hasurl(element)
place.add_url(url)
return place, ref_list
def on_res_ok_clicked(self, dummy):
""" Accept changes displayed and commit to place.
Also find or create a new enclosing place from parent. """
# do the names
namelist = []
for row in self.alt_store:
if row[0] == 'P':
self.place.name = self.newplace.names[row[4]]
elif row[0] == '\u2714':
namelist.append(self.newplace.names[row[4]])
self.place.alt_names = namelist
# Lat/lon/ID/code/type
self.place.lat = self.top.get_object('latitude').get_text()
self.place.long = self.top.get_object('longitude').get_text()
self.place.gramps_id = self.top.get_object('grampsid').get_text()
self.place.code = self.top.get_object('postal').get_text()
self.place.place_type.set(self.type_combo.get_values())
# Add in URLs if wanted
if self.keepweb:
for url in self.newplace.links:
self.place.add_url(url)
# Enclose in the next level place
next_place = False
parent = None
if not self.keep_enclosure or not self.place.placeref_list:
if self.newplace.parent_ids:
# we might have a parent with geo id 'GEO12345'
parent = self.dbstate.db.get_place_from_gramps_id(
self.newplace.parent_ids[0])
if not parent and self.newplace.parent_names:
# make one, will have to be examined/cleaned later
parent = Place()
parent.title = ', '.join(self.newplace.parent_names)
name = PlaceName()
name.value = parent.title
parent.name = name
parent.gramps_id = self.newplace.parent_ids[0]
with DbTxn(_("Add Place (%s)") % parent.title,
self.dbstate.db) as trans:
self.dbstate.db.add_place(parent, trans)
next_place = True
if parent:
if located_in(self.dbstate.db, parent.handle,
self.place.handle):
# attempting to create a place loop, not good!
ErrorDialog(_('Place cycle detected'),
msg2=_("The place you chose is enclosed in the"
" place you are workin on!\n"
"Please cancel and choose another "
"place."),
parent=self.uistate.window)
return
# check to see if we already have the enclosing place
already_there = False
for pref in self.place.placeref_list:
if parent.handle == pref.ref:
already_there = True
break
if not already_there:
placeref = PlaceRef()
placeref.set_reference_handle(parent.handle)
self.place.set_placeref_list([placeref])
# Add in Citation/Source if wanted
if self.addcitation and self.newplace.geoid:
src_hndl = self.find_or_make_source()
cit = Citation()
cit.set_reference_handle(src_hndl)
cit.set_page("GeoNames ID: %s" %
self.newplace.geoid.replace('GEO', ''))
with DbTxn(_("Add Citation (%s)") % "GeoNames",
self.dbstate.db) as trans:
self.dbstate.db.add_citation(cit, trans)
self.place.add_citation(cit.handle)
# We're finally ready to commit the updated place
with DbTxn(_("Edit Place (%s)") % self.place.title,
self.dbstate.db) as trans:
self.dbstate.db.commit_place(self.place, trans)
# Jump to enclosing place to clean it if necessary
if next_place:
self.set_active('Place', parent.handle)
self.place = parent
# if geoparse fails, leave us at main view
if self.newplace.parent_ids and \
self.geoparse(self.newplace.parent_ids[0],
_(", ").join(self.newplace.parent_names),
self.newplace.parent_ids,
self.newplace.parent_names):
# geoparse worked, lets put up the results view
self.gui.get_child().remove(self.mainwin)
self.gui.get_child().add(self.results_win)
self.res_gui()
return
self.reset_main()
if self.gui.get_child().get_child() == self.results_win:
self.gui.get_child().remove(self.results_win)
self.gui.get_child().add(self.mainwin)
def exportData(database, filename,
error_dialog=None, option_box=None, callback=None):
if not callable(callback):
callback = lambda percent: None # dummy
with OpenFileOrStdout(filename, encoding="utf-8") as fp:
total = (len(database.note_map) +
len(database.person_map) +
len(database.event_map) +
len(database.family_map) +
len(database.repository_map) +
len(database.place_map) +
len(database.media_map) +
len(database.citation_map) +
len(database.source_map) +
len(database.tag_map))
count = 0.0
# ---------------------------------
# Notes
# ---------------------------------
for handle in database.note_map.keys():
serial = database.note_map[handle]
write_line(fp, Note.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Event
# ---------------------------------
for handle in database.event_map.keys():
serial = database.event_map[handle]
write_line(fp, Event.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Person
# ---------------------------------
for handle in database.person_map.keys():
serial = database.person_map[handle]
write_line(fp, Person.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Family
# ---------------------------------
for handle in database.family_map.keys():
serial = database.family_map[handle]
write_line(fp, Family.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Repository
# ---------------------------------
for handle in database.repository_map.keys():
serial = database.repository_map[handle]
write_line(fp, Repository.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Place
# ---------------------------------
for handle in database.place_map.keys():
serial = database.place_map[handle]
write_line(fp, Place.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Source
# ---------------------------------
for handle in database.source_map.keys():
serial = database.source_map[handle]
write_line(fp, Source.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Citation
# ---------------------------------
for handle in database.citation_map.keys():
serial = database.citation_map[handle]
write_line(fp, Citation.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Media
# ---------------------------------
for handle in database.media_map.keys():
serial = database.media_map[handle]
write_line(fp, Media.create(serial))
count += 1
callback(100 * count/total)
# ---------------------------------
# Tag
# ---------------------------------
for handle in database.tag_map.keys():
serial = database.tag_map[handle]
write_line(fp, Tag.create(serial))
count += 1
callback(100 * count/total)
return True
def __get_place(self, gov_id, type_dic, preferred_lang):
gov_url = 'http://gov.genealogy.net/semanticWeb/about/' + quote(gov_id)
response = urlopen(gov_url)
data = response.read()
dom = parseString(data)
top = dom.getElementsByTagName('gov:GovObject')
place = Place()
place.gramps_id = gov_id
if not len(top) :
return place, []
count = 0
for element in top[0].getElementsByTagName('gov:hasName'):
count += 1
place_name = self.__get_hasname(element)
if count == 1:
place.set_name(place_name)
else:
if place_name.lang == preferred_lang:
place.add_alternative_name(place.get_name())
place.set_name(place_name)
else:
place.add_alternative_name(place_name)
for element in top[0].getElementsByTagName('gov:hasType'):
curr_lang = place.get_name().get_language()
place_type = self.__get_hastype(element,curr_lang, type_dic, preferred_lang)
place.set_type(place_type)
for element in top[0].getElementsByTagName('gov:position'):
latitude, longitude = self.__get_position(element)
place.set_latitude(latitude)
place.set_longitude(longitude)
ref_list = []
for element in top[0].getElementsByTagName('gov:isPartOf'):
ref, date = self.__get_ispartof(element)
ref_list.append((ref, date))
for element in top[0].getElementsByTagName('gov:hasURL'):
url = self.__get_hasurl(element)
place.add_url(url)
return place, ref_list
def column_title(self, data):
place = Place()
place.unserialize(data)
return place_displayer.display(self.db, place)