class RemoveTagOptions(MenuToolOptions):
"""Class for creating menu options."""
def __init__(self, name, person_id=None, dbstate=None):
self.db = dbstate.get_database()
MenuToolOptions.__init__(self, name, person_id, dbstate)
def add_menu_options(self, menu):
"""Add the menu options for the tool."""
if self.__is_db_empty():
txt = [_("The Tool requires at least one tag to execute.")]
self.empty = TextOption(_("ERROR"), txt)
self.empty.set_available(False)
menu.add_option(_("ERROR"), "empty", self.empty)
return # stop other menu option creation
else:
self.__general_options(menu)
self.__filter_options(menu)
def __enum_tag_list(self):
"""Return an enumerated tag name list."""
tag_list = list(self.db.iter_tags())
if tag_list:
L = list(map(lambda x: x.get_name(), tag_list))
return list(enumerate(L))
def __is_db_empty(self):
"""Check if database has at least one tag."""
try:
next(self.db.iter_tag_handles())
except StopIteration:
# StopIteration is raised when the category has no objects
return True # Empty
return False # Not empty
def __general_options(self, menu):
"""Menu Options for general option tab."""
# Add or remove tags menu option
self.add_remove = FilterOption(_("Add/Remove"), 0)
self.add_remove.set_help(_("Add or remove tags from objects."))
self.add_remove.set_items([(0, _("Add Tags")), (1, _("Remove Tags"))])
menu.add_option(_("General options"), "add_remove", self.add_remove)
# category menu option
lst = [
_("People"),
_("Families"),
_("Events"),
_("Places"),
_("Sources"),
_("Citations"),
_("Repositories"),
_("Media"),
_("Notes")
]
category_list = list(enumerate(lst))
self.tag_category = FilterOption(_("Category"), 0)
self.tag_category.set_help(_("Choose a category."))
menu.add_option(_("General options"), "category", self.tag_category)
self.tag_category.set_items(category_list)
self.tag_category.connect('value-changed', self.__update_options)
# tag name list menu option
tag_list = self.__enum_tag_list()
self.tag_name = FilterOption(_("Choose Tag"), 0)
self.tag_name.set_help(_("Choose a tag to remove."))
menu.add_option(_("General options"), "tag_name", self.tag_name)
self.tag_name.set_items(tag_list)
def __filter_options(self, menu):
"""Menu Options for filter option tab."""
self.filter_dict = {}
# get all filter rules, used for generic filters
all_persons = rules.person.Everyone([])
all_families = rules.family.AllFamilies([])
all_events = rules.event.AllEvents([])
all_places = rules.place.AllPlaces([])
all_sources = rules.source.AllSources([])
all_cits = rules.citation.AllCitations([])
all_repos = rules.repository.AllRepos([])
all_media = rules.media.AllMedia([])
all_notes = rules.note.AllNotes([])
# create a list used for menu filter option creation later
lst = [(_("Person Filter"), 'Person', _("Persons"), all_persons),
(_("Family Filter"), 'Family', _("Families"), all_families),
(_("Event Filter"), 'Event', _("Events"), all_events),
(_("Place Filter"), 'Place', _("Places"), all_places),
(_("Source Filter"), 'Source', _("Sources"), all_sources),
(_("Citation Filter"), 'Citation', _("Citations"), all_cits),
(_("Repository Filter"), 'Repository',
_("Repositories"), all_repos),
(_("Media Filter"), 'Media', _("Media"), all_media),
(_("Note Filter"), 'Note', _("Notes"), all_notes)]
for entry in lst:
# create a filter option for each category e.g. person, events
# filter option is a combination of custom filters and
# a generic filter for all objects of one category
filter_name = FilterOption(entry[0], 0)
menu.add_option(_("Filter options"), entry[1].lower(), filter_name)
self.filter_dict[entry[1]] = filter_name
# custom filter:
filter_list = CustomFilters.get_filters(entry[1])
# generic filter:
GenericFilter = GenericFilterFactory(entry[1])
all_filter = GenericFilter()
all_filter.set_name(_("All %s") % (entry[2]))
all_filter.add_rule(entry[3])
# only add the generic filter if it isn't already in the menu
all_filter_in_list = False
for fltr in filter_list:
if fltr.get_name() == all_filter.get_name():
all_filter_in_list = True
if not all_filter_in_list:
filter_list.insert(0, all_filter)
# add the list of custom and generic filters
# to the filter option
self.filter_dict[entry[1]].set_filters(filter_list)
def __update_options(self):
"""Turn availability on and off depending on user selection."""
lst = [
'Person', 'Family', 'Event', 'Place', 'Source', 'Citation',
'Repository', 'Media', 'Note'
]
for entry in lst:
self.filter_dict[entry].set_available(False)
value = self.tag_category.get_value()
self.filter_dict[lst[value]].set_available(True)
