def run(database, document, person):
    """
    Display a person's timeline.
    """
    sa = SimpleAccess(database)
    sd = SimpleDoc(document)
    sd.title(_("Timeline for %s") % sa.name(person))
    sd.paragraph("")
    stab = QuickTable(sa)
    stab.columns(_("Date"), _("Event"), _("Age"), _("Place"),
                 _("People involved"))
    stab.set_link_col(4)

    handled = {}
    birth_ref = gramps.gen.lib.Person.get_birth_ref(person)
    birth_date = get_event_date_from_ref(database, birth_ref)
    event_list = []

    process(database, sa, event_list, handled, person, False, person)

    for (event, obj, desc) in sorted(event_list, key=by_date):
        edate = sa.event_date_obj(event)
        span_str, span_int = format_date(birth_date, edate, obj == person)
        if desc == None:
            desc = event
        stab.row(edate, desc, span_str, sa.event_place(event), obj)
        stab.row_sort_val(2, span_int)
    today = Today()
    span_str, span_int = format_date(birth_date, today, False)
    stab.row(today, _("Today"), span_str, "", person)
    stab.row_sort_val(2, span_int)
    stab.write(sd)
    sd.paragraph("")
Ejemplo n.º 2
0
def get_sources(database, person):
    """
    Create list of sources for person's events
    """
    sources = list()
    sa = SimpleAccess(database)
    events = sa.events(person)
    # Get family events also
    for family in sa.parent_in(person):
        for event in sa.events(family):
            events.append(event)

    for event in events:
        for handle in event.citation_list:
            citation = database.get_citation_from_handle(handle)
            page = citation.page
            source = database.get_source_from_handle(citation.source_handle)
            title = source.title
            author = source.author
            if author:
                source_desc = '* {}, {} - {}'.format(author, title, page)
            else:
                source_desc = '* {} - {}'.format(title, page)

            if source_desc not in sources:
                sources.append(source_desc)
    return sources
Ejemplo n.º 3
0
def get_parents_desc(database, person):
    """
    Return text describing person's parents
    """
    sa = SimpleAccess(database)
    narrator = Narrator(database,
                        verbose=True,
                        use_call_name=True,
                        use_fulldate=True)
    narrator.set_subject(person)
    family_handle = person.get_main_parents_family_handle()
    if family_handle:
        family = database.get_family_from_handle(family_handle)
        mother_handle = family.get_mother_handle()
        father_handle = family.get_father_handle()
        if mother_handle:
            mother = database.get_person_from_handle(mother_handle)
            mother_name = sa.name(mother)
        else:
            mother_name = ""
        if father_handle:
            father = database.get_person_from_handle(father_handle)
            father_name = sa.name(father)
        else:
            father_name = ""
        return narrator.get_child_string(father_name, mother_name)
Ejemplo n.º 4
0
def run(database, document, object, item, trans):
    """
    Display back-references for this object.
    """

    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)

    # display the title
    sdoc.title(_("References for this %s") % trans)
    sdoc.paragraph("\n")
    stab.columns(_("Type"), _("Reference"))
    for (objclass, handle) in database.find_backlink_handles(object.handle):
        ref = get_ref(database, objclass, handle)
        stab.row(_(objclass), ref)  # translation are explicit (above)

    if stab.get_row_count() > 0:
        document.has_data = True
        stab.write(sdoc)
    else:
        document.has_data = False
        sdoc.paragraph(_("No references for this %s") % trans)
        sdoc.paragraph("")
    sdoc.paragraph("")
Ejemplo n.º 5
0
def run(database, document, person):
    """
    Loops through the families that the person is a child in, and display
    the information about the other children.
    """
    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)
    rel_class = get_relationship_calculator(glocale)

    # display the title
    # feature request 2356: avoid genitive form
    sdoc.title(_("Siblings of %s") % sdb.name(person))
    sdoc.paragraph("")
    stab.columns(_("Sibling"), _("Gender"), _("Birth Date"), _("Type"))
    # grab our current id (self):
    gid = sdb.gid(person)
    # loop through each family in which the person is a child
    document.has_data = False
    for family in sdb.child_in(person):
        # loop through each child in the family
        for child in sdb.children(family):
            # only display if this child is not the active person
            if sdb.gid(child) != gid:
                rel_str = rel_class.get_sibling_relationship_string(
                    rel_class.get_sibling_type(database, person, child),
                    person.get_gender(), child.get_gender())
            else:
                rel_str = _('self')
            # pass row the child object to make link:
            stab.row(child, sdb.gender(child), sdb.birth_or_fallback(child),
                     rel_str)
            document.has_data = True
    stab.write(sdoc)
Ejemplo n.º 6
0
def run_mother(database, document, person):
    """ Function writing the mother lineage quick report
    """
    sa = SimpleAccess(database)
    sd = SimpleDoc(document)

    # display the results

    # feature request 2356: avoid genitive form
    sd.title(_("Mother lineage for %s") % sa.name(person))
    sd.paragraph("")
    sd.paragraph(
        _(""
          "This report shows the mother lineage, also called matronymic lineage "
          "mtDNA lineage."
          " People in this lineage all share the same Mitochondrial DNA (mtDNA)."
          ))
    sd.paragraph("")

    stab = QuickTable(sa)
    stab.columns(_("Name Mother"), _("Birth"), _("Death Date"), _("Remark"))
    make_details(Person.FEMALE, person, sa, sd, database, stab)
    stab.write(sd)
    sd.paragraph("")

    if person.gender == Person.MALE:
        return

    sd.header2((_("Direct line female descendants")))
    sd.paragraph("")

    make_details_child(Person.FEMALE, person, sa, sd, database)
Ejemplo n.º 7
0
def run(database, document, person):
    """
    Loops through the families that the person is a child in, and display
    the information about the other children.
    """
    global cache
    cache = {}
    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)
    # display the title
    sdoc.title(_("Descendant Count"))
    sdoc.paragraph("")
    stab.columns(_("Person"), _("Number of Descendants"))
    people = database.get_person_handles(sort_handles=True)
    for person_handle in people:
        result = countem(database, handle2internal(person_handle))
        cache[person_handle] = len(result)
    matches = 0
    for person_handle in cache:
        person = database.get_person_from_handle(person_handle)
        stab.row(person, cache[person_handle])
        matches += 1
    sdoc.paragraph(_("There are %d people.\n") % matches)
    stab.write(sdoc)
Ejemplo n.º 8
0
def run(database, document, *args, **kwargs):
    """
    Loops through the families that the person is a child in, and display
    the information about the other children.
    """
    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)
    # display the title
    sdoc.title(_("All Names of All People"))
    sdoc.paragraph("")
    matches = 0
    stab.columns(_("Name"), _("Primary Name"), _("Name Type"))
    names = []  # name, person
    for person in database.iter_people():
        primary_name = person.get_primary_name()
        if primary_name:
            names += [(nd.display_name(primary_name), person,
                       str(primary_name.get_type()))]
        names += [(nd.display_name(name), person, str(name.get_type()))
                  for name in person.get_alternate_names()]

    matches = 0
    for (name, person, name_type) in sorted(names, key=lambda x: x[0]):
        stab.row(name, person, name_type)
        matches += 1
    sdoc.paragraph(_("Total names %d") % matches)
    sdoc.paragraph("")
    stab.write(sdoc)
Ejemplo n.º 9
0
def run(database, document, person):
    """
    Loops through the person events and the family events of any family
    in which the person is a parent (to catch Marriage events), displaying
    the basic details of the event
    """

    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)

    # get the personal events
    event_list = sdb.events(person)

    # get the events of each family in which the person is
    # a parent
    for family in sdb.parent_in(person):
        event_list += sdb.events(family)

    # Sort the events by their date
    event_list.sort(key=lambda x: x.get_date_object())

    # display the results

    # feature request 2356: avoid genitive form
    sdoc.title(_("Sorted events of %s") % sdb.name(person))
    sdoc.paragraph("")

    stab.columns(_("Event Type"), _("Event Date"), _("Event Place"))
    document.has_data = False
    for event in event_list:
        stab.row(event, sdb.event_date_obj(event), sdb.event_place(event))
        document.has_data = True
    stab.write(sdoc)
Ejemplo n.º 10
0
def run_fam(database, document, family):
    """
    Loops through the family events and the events of all parents, displaying
    the basic details of the event
    """

    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)

    # get the family events
    event_list = [(_('Family'), x) for x in sdb.events(family)]

    # get the events of father and mother
    #fathername = sdb.first_name(sdb.father(family))
    event_list += [(sdb.father(family), x)
                   for x in sdb.events(sdb.father(family))]
    #mothername = sdb.first_name(sdb.mother(family))
    event_list += [(sdb.mother(family), x)
                   for x in sdb.events(sdb.mother(family))]

    # children events
    event_list_children = []
    for child in sdb.children(family):
        #name = sdb.first_name(child)
        event_list_children += [(child, x) for x in sdb.events(child)]

    # Sort the events by their date
    event_list.sort(key=lambda x: x[1].get_date_object())
    event_list_children.sort(key=lambda x: x[1].get_date_object())

    # display the results

    sdoc.title(
        _("Sorted events of family\n %(father)s - %(mother)s") % {
            'father': sdb.name(sdb.father(family)),
            'mother': sdb.name(sdb.mother(family))
        })
    sdoc.paragraph("")

    document.has_data = False
    stab.columns(_("Family Member"), _("Event Type"), _("Event Date"),
                 _("Event Place"))

    for (person, event) in event_list:
        stab.row(person, sdb.event_type(event), sdb.event_date_obj(event),
                 sdb.event_place(event))
        document.has_data = True
    stab.write(sdoc)

    stab = QuickTable(sdb)
    sdoc.header1(_("Personal events of the children"))
    stab.columns(_("Family Member"), _("Event Type"), _("Event Date"),
                 _("Event Place"))
    for (person, event) in event_list_children:
        stab.row(person, sdb.event_type(event), sdb.event_date_obj(event),
                 sdb.event_place(event))
        document.has_data = True
    stab.write(sdoc)
Ejemplo n.º 11
0
    def __init__(self, database, document, person):
        self.database = database
        self.person = person
        self.sdb = SimpleAccess(database)
        self.sdoc = SimpleDoc(document)
        self.rel_class = get_relationship_calculator(glocale)

        self.msg_list = []
Ejemplo n.º 12
0
def run(database, document, person):
    """
    Output a text biography of active person
    """
    sa = SimpleAccess(database)
    sd = SimpleDoc(document)
    sd.title(_("Biography for %s") % sa.name(person))
    sd.paragraph('')

    narrator = Narrator(database,
                        verbose=True,
                        use_call_name=True,
                        use_fulldate=True)
    narrator.set_subject(person)

    # Birth Details
    text = narrator.get_born_string()
    if text:
        sd.paragraph(text)

    text = narrator.get_baptised_string()
    if text:
        sd.paragraph(text)

    text = narrator.get_christened_string()
    if text:
        sd.paragraph(text)

    text = get_parents_desc(database, person)
    if text:
        sd.paragraph(text)
    sd.paragraph('')

    # Family Details
    for family in sa.parent_in(person):
        text = narrator.get_married_string(family)
        if text:
            sd.paragraph(text)
    sd.paragraph('')

    # Death Details
    text = narrator.get_died_string(True)
    if text:
        sd.paragraph(text)

    text = narrator.get_buried_string()
    if text:
        sd.paragraph(text)
    sd.paragraph('')

    # Sources
    sd.header1(_('Sources'))
    for source in get_sources(database, person):
        sd.paragraph(source)
Ejemplo n.º 13
0
    def __init__(self, dbstate, uistate, track, url, callback):
        self.url = url
        self.dbstate = dbstate
        self.simple_access = SimpleAccess(self.dbstate.db)
        self.callback = callback

        ManagedWindow.__init__(self, uistate, track, url)

        self._local_init()
        self._connect_signals()
        self.show()
Ejemplo n.º 14
0
def run(database, document, date):
    """
    Display people probably alive and their ages on a particular date.
    """
    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)
    if not date.get_valid():
        sdoc.paragraph("Date is not a valid date.")
        return
    # display the title
    if date.get_day_valid():
        sdoc.title(_("People and their ages the %s") % displayer.display(date))
    else:
        sdoc.title(_("People and their ages on %s") % displayer.display(date))
    stab.columns(_("Person"), _("Age"),
                 _("Status"))  # Actual Date makes column unicode
    alive_matches = 0
    dead_matches = 0
    for person in sdb.all_people():
        alive, birth, death, explain, relative = \
            probably_alive(person, database, date, return_range=True)
        # Doesn't show people probably alive but no way of figuring an age:
        if alive:
            if birth:
                diff_span = (date - birth)
                stab.row(person, str(diff_span), _("Alive: %s") % explain)
                stab.row_sort_val(1, int(diff_span))
            else:
                stab.row(person, "", _("Alive: %s") % explain)
                stab.row_sort_val(1, 0)
            alive_matches += 1
        else:  # not alive
            if birth:
                diff_span = (date - birth)
                stab.row(person, str(diff_span), _("Deceased: %s") % explain)
                stab.row_sort_val(1, int(diff_span))
            else:
                stab.row(person, "", _("Deceased: %s") % explain)
                stab.row_sort_val(1, 1)
            dead_matches += 1

    document.has_data = (alive_matches + dead_matches) > 0
    sdoc.paragraph(
        _("\nLiving matches: %(alive)d, "
          "Deceased matches: %(dead)d\n") % {
              'alive': alive_matches,
              'dead': dead_matches
          })
    if document.has_data:
        stab.write(sdoc)
    sdoc.paragraph("")
Ejemplo n.º 15
0
 def __init__(self, *args, **kwargs):
     self.dbi = DBI(SelectTest.DB, None)  # no document here
     self.dbi.flat = True
     self.dbi.sdb = SimpleAccess(SelectTest.DB)
     self.pcount = len(SelectTest.DB._tables["Person"]["handles_func"]())
     self.john_count = 0
     with SelectTest.DB._tables["Person"]["cursor_func"]() as cursor:
         for handle, person in cursor:
             name = SelectTest.DB._tables["Person"]["class_func"](
                 person).get_primary_name()
             if name and "John" in name.first_name:
                 self.john_count += 1
     unittest.TestCase.__init__(self, *args, **kwargs)
Ejemplo n.º 16
0
 def make_tooltip_from_link(self, link_tag):
     """
     Return a string useful for a tooltip given a LinkTag object.
     """
     from gramps.gen.simple import SimpleAccess
     win_obj = find_parent_with_attr(self, attr="dbstate")
     display = link_tag.data
     if win_obj:
         simple_access = SimpleAccess(win_obj.dbstate.db)
         url = link_tag.data
         if url.startswith("gramps://"):
             obj_class, prop, value = url[9:].split("/")
             display = simple_access.display(obj_class, prop, value) or url
     return display
Ejemplo n.º 17
0
 def make_tooltip_from_link(self, link_tag):
     """
     Return a string useful for a tooltip given a LinkTag object.
     """
     from gramps.gen.simple import SimpleAccess
     win_obj = find_parent_with_attr(self, attr="dbstate")
     display = link_tag.data
     if win_obj:
         simple_access = SimpleAccess(win_obj.dbstate.db)
         url = link_tag.data
         if url.startswith("gramps://"):
             obj_class, prop, value = url[9:].split("/")
             display = simple_access.display(obj_class, prop, value) or url
     return display + ((_("\nCommand-Click to follow link") if mac() else _(
         "\nCtrl-Click to follow link")) if self.get_editable() else '')
Ejemplo n.º 18
0
 def query(self, query):
     self.parse(query)
     self.select = 0
     start_time = time.time()
     class Table():
         results = []
         def row(self, *args, **kwargs):
             self.results.append([args, kwargs])
         def get_rows(self):
             return [list(item[0]) for item in self.results]
     table = Table()
     self.sdb = SimpleAccess(self.database)
     self.process_table(table) # a class that has .row(1, 2, 3, ...)
     print(_("%d rows processed in %s seconds.\n") % (self.select, time.time() - start_time))
     return table
 def main(self):
     database = self.dbstate.db
     simple_a = SimpleAccess(database)
     # stime = time.perf_counter()
     counts_list = {}
     count = 0
     self.model.clear()
     for person in database.iter_people():
         if count == 200:
             count = 0
             yield True
         count += 1
         result = len(countem(database, person, counts_list))
         self.model.append(
             (simple_a.describe(person), result, person.handle))
     self.set_has_data(len(self.model) > 0)
Ejemplo n.º 20
0
 def eval(self):
     """
     Execute the query.
     """
     self.sdb = SimpleAccess(self.database)
     self.stab = QuickTable(self.sdb)
     self.select = 0
     start_time = time.time()
     self.process_table(self.stab) # a class that has .row(1, 2, 3, ...)
     if self.select > 0:
         self.stab.columns(*self.clean_titles(self.columns))
         self.sdoc = SimpleDoc(self.document)
         self.sdoc.title(self.query_text)
         self.sdoc.paragraph("\n")
         self.sdoc.paragraph("%d rows processed in %s seconds.\n" % (self.select, time.time() - start_time))
         self.stab.write(self.sdoc)
         self.sdoc.paragraph("")
     return _("%d rows processed in %s seconds.\n") % (self.select, time.time() - start_time)
Ejemplo n.º 21
0
def run(database, document, repo):
    """
    Display back-references (sources) for this repository.
    """

    # setup the simple access functions

    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)

    # First we find repository and add its text

    sdoc.title('%s\n' % repo.get_name())

    # Go over all the sources that refer to this repository

    repo_handle = repo.handle
    source_list = [item[1] for item in
                   database.find_backlink_handles(repo_handle, ['Source'
                   ])]

    stab.columns(_("Source"), _("Type of media"), _("Call number"))
    document.has_data = False
    for source_handle in source_list:
        src = database.get_source_from_handle(source_handle)

        # Get the list of references from this source to our repo
        # (can be more than one, technically)

        for reporef in src.get_reporef_list():
            if reporef.ref == repo_handle:

                # Determine the text for this source

                media = str(reporef.get_media_type())
                call = reporef.get_call_number()

                stab.row(src.get_title(), media, call)
                document.has_data = True
    if document.has_data:
        stab.write(sdoc)
    else:
        sdoc.header1(_("Not found"))
Ejemplo n.º 22
0
def run_given(database, document, person):
    """
    Loops through the families that the person is a child in, and displays
    the information about the other children.
    """
    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)
    if isinstance(person, Person):
        rgivenname = person.get_primary_name().get_first_name()
    else:
        rgivenname = person
    if " " in rgivenname.strip():
        rgivenname, second = rgivenname.strip().split(" ", 1)
    # display the title
    sdoc.title(_("People with the given name '%s'") % rgivenname)
    sdoc.paragraph("")
    stab.columns(_("Person"), _("Birth Date"), _("Name type"))
    filter = GenericFilterFactory('Person')()
    if rgivenname != '':
        rule = SameGiven([rgivenname])
    else:
        rule = IncompleteGiven([])
    filter.add_rule(rule)
    people = filter.apply(database, database.iter_person_handles())

    matches = 0
    for person_handle in people:
        person = database.get_person_from_handle(person_handle)
        stab.row(person, sdb.birth_or_fallback(person),
                 str(person.get_primary_name().get_type()))
        matches += 1

    document.has_data = matches > 0
    sdoc.paragraph(
        # Translators: leave all/any {...} untranslated
        ngettext(
            "There is {number_of} person "
            "with a matching name, or alternate name.\n",
            "There are {number_of} people "
            "with a matching name, or alternate name.\n",
            matches).format(number_of=matches))
    stab.write(sdoc)
Ejemplo n.º 23
0
def run(database, document, attribute, value=None):
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)
    sdoc.title(_("People who have the '%s' Attribute") % attribute)
    sdoc.paragraph("")
    stab.columns(_("Person"), str(attribute))
    matches = 0
    for person_handle in database.iter_person_handles():
        person = database.get_person_from_handle(person_handle)
        matched = False
        for attr in person.attribute_list:
            if str(attr.type) == attribute:
                stab.row(person, str(attr.get_value()))
                matched = True
        if matched:
            matches += 1
    document.has_data = matches > 0
    sdoc.paragraph(
        _("There are %d people with a matching attribute name.\n") % matches)
    stab.write(sdoc)
Ejemplo n.º 24
0
def run(database, document, obj):
    """
    Display link references for this note.
    """

    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)

    # display the title
    sdoc.title(_("Link References for this note"))
    sdoc.paragraph("\n")
    stab.columns(_("Type"), _("Reference"), _("Link check"))

    for (ldomain, ltype, lprop, lvalue) in obj.get_links():
        if ldomain == "gramps":
            tagtype = _(ltype)
            ref_obj = sdb.get_link(ltype, lprop, lvalue)
            if ref_obj:
                tagvalue = ref_obj
                tagcheck = _("Ok")
            else:
                tagvalue = styledtext_tag.value
                tagcheck = _("Failed: missing object")
        else:
            tagtype = _("Internet")
            tagvalue = lvalue
            tagcheck = ""
        stab.row(tagtype, tagvalue, tagcheck)

    if stab.get_row_count() > 0:
        stab.write(sdoc)
        document.has_data = True
    else:
        sdoc.paragraph(_("No link references for this note"))
        sdoc.paragraph("")
        document.has_data = False
    sdoc.paragraph("")
Ejemplo n.º 25
0
    def write_report(self):
        """
        The routine that actually creates the report.
        At this point, the document is opened and ready for writing.
        """
        sdb = SimpleAccess(self.database)

        self.doc.start_paragraph("NoteLink-Title")
        title = _("Note Link Check Report")
        mark = IndexMark(title, INDEX_TYPE_TOC, 1)
        self.doc.write_text(title, mark)
        self.doc.end_paragraph()
        self.doc.start_table('NoteLinkTable', 'NoteLink-Table')

        self.doc.start_row()

        self.doc.start_cell('NoteLink-TableCell')
        self.doc.start_paragraph('NoteLink-Normal-Bold')
        self.doc.write_text(_("Note ID"))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.start_cell('NoteLink-TableCell')
        self.doc.start_paragraph('NoteLink-Normal-Bold')
        self.doc.write_text(_("Link Type"))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.start_cell('NoteLink-TableCell')
        self.doc.start_paragraph('NoteLink-Normal-Bold')
        self.doc.write_text(_("Links To"))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.start_cell('NoteLink-TableCell')
        self.doc.start_paragraph('NoteLink-Normal-Bold')
        self.doc.write_text(_("Status"))
        self.doc.end_paragraph()
        self.doc.end_cell()

        self.doc.end_row()

        for note in self.database.iter_notes():
            for (ldomain, ltype, lprop, lvalue) in note.get_links():
                if ldomain == "gramps":
                    tagtype = _(ltype)
                    ref_obj = sdb.get_link(ltype, lprop, lvalue)
                    if ref_obj:
                        tagvalue = sdb.describe(ref_obj)
                        tagcheck = _("Ok")
                    else:
                        tagvalue = "%s://%s/%s/%s" % (ldomain, ltype, lprop,
                                                      lvalue)
                        tagcheck = _("Failed")
                else:
                    tagtype = _("Internet")
                    tagvalue = lvalue
                    tagcheck = ""

                self.doc.start_row()

                self.doc.start_cell('NoteLink-TableCell')
                self.doc.start_paragraph('NoteLink-Normal')
                self.doc.write_text(note.gramps_id)
                self.doc.end_paragraph()
                self.doc.end_cell()

                self.doc.start_cell('NoteLink-TableCell')
                self.doc.start_paragraph('NoteLink-Normal')
                self.doc.write_text(tagtype)
                self.doc.end_paragraph()
                self.doc.end_cell()

                self.doc.start_cell('NoteLink-TableCell')
                self.doc.start_paragraph('NoteLink-Normal')
                self.doc.write_text(tagvalue)
                self.doc.end_paragraph()
                self.doc.end_cell()

                self.doc.start_cell('NoteLink-TableCell')
                self.doc.start_paragraph('NoteLink-Normal')
                self.doc.write_text(tagcheck)
                self.doc.end_paragraph()
                self.doc.end_cell()

                self.doc.end_row()

        self.doc.end_table()
Ejemplo n.º 26
0
    def write_report(self):
        """ The short method that runs through each month and creates a page. """
        self.doc.start_paragraph('DIFF-Title')
        self.doc.write_text(_("Database Differences Report"))
        self.doc.end_paragraph()

        self.doc.start_table('DiffTable', 'DIFF-Table2')
        self.doc.start_row()
        self.doc.start_cell('DIFF-TableCellNoBorder')
        self.doc.start_paragraph('DIFF-TableHeading')
        self.doc.write_text("Database:")
        self.doc.end_paragraph()
        self.doc.end_cell()
        self.doc.start_cell('DIFF-TableCellNoBorder')
        self.doc.start_paragraph('DIFF-Text')
        self.doc.write_text(str(self.database.get_dbname()))
        self.doc.end_paragraph()
        self.doc.end_cell()
        self.doc.end_row()
        self.doc.start_row()
        self.doc.start_cell('DIFF-TableCellNoBorder')
        self.doc.start_paragraph('DIFF-TableHeading')
        self.doc.write_text(_("File:"))
        self.doc.end_paragraph()
        self.doc.end_cell()
        self.doc.start_cell('DIFF-TableCellNoBorder')
        self.doc.start_paragraph('DIFF-Text')
        self.doc.write_text(self.filename)
        self.doc.end_paragraph()
        self.doc.end_cell()
        self.doc.end_row()
        self.doc.end_table()
        self.doc.start_paragraph('DIFF-Heading')
        self.doc.write_text("")
        self.doc.end_paragraph()
        self.database2 = import_as_dict(self.filename, self._user)
        if self.database2 is None:
            return
        self.sa = [SimpleAccess(self.database), SimpleAccess(self.database2)]
        diffs, added, missing = diff_dbs(self.database, self.database2,
                                         self._user)
        if self.show_diff:
            self.doc.start_paragraph('DIFF-Heading')
            self.doc.write_text(_("Differences between Database and File"))
            self.doc.end_paragraph()
            last_object = None
            if diffs:
                self._user.begin_progress(_('Family Tree Differences'),
                                          _('Processing...'), len(diffs))
                for diff in diffs:
                    self._user.step_progress()
                    obj_type, item1, item2 = diff
                    if last_object != item1:
                        if last_object != None:
                            self.doc.end_table()
                            self.doc.start_paragraph('DIFF-Heading')
                            self.doc.write_text("")
                            self.doc.end_paragraph()
                        self.doc.start_table('DiffTable', 'DIFF-Table3')
                    last_object = item1
                    if hasattr(item1, "gramps_id"):
                        self.start_list(self.doc,
                                        "%s: %s" % (obj_type, item1.gramps_id),
                                        "Database", "File")
                    else:
                        self.start_list(
                            self.doc, "%s: %s" % (obj_type, item1.get_name()),
                            "Database", "File")
                    self.report_diff(obj_type, to_struct(item1),
                                     to_struct(item2), self.doc)
                self.doc.end_table()
            else:
                self.doc.start_table('DiffTable', 'DIFF-Table3')
                self.start_list(self.doc, _("No differences"), "", "")
                self.doc.end_table()
            self.doc.start_paragraph('DIFF-Heading')
            self.doc.write_text("")
            self.doc.end_paragraph()
        if self.show_missing:
            self.doc.start_paragraph('DIFF-Heading')
            self.doc.write_text(
                _("Missing items in File that are added in Database"))
            self.doc.end_paragraph()
            if missing:
                for pair in missing:
                    obj_type, item = pair
                    self.doc.start_paragraph('DIFF-Text')
                    self.doc.write_text(
                        _("Missing %s: %s") %
                        (obj_type, self.sa[0].describe(item)))
                    self.doc.end_paragraph()
            else:
                self.doc.start_paragraph('DIFF-Text')
                self.doc.write_text(_("Nothing missing"))
                self.doc.end_paragraph()
            self.doc.start_paragraph('DIFF-Heading')
            self.doc.write_text("")
            self.doc.end_paragraph()
        if self.show_added:
            self.doc.start_paragraph('DIFF-Heading')
            self.doc.write_text(
                _("Added items in File that are missing in Database"))
            self.doc.end_paragraph()
            if added:
                for pair in added:
                    obj_type, item = pair
                    self.doc.start_paragraph('DIFF-Text')
                    self.doc.write_text(
                        _("Added %s: %s ") %
                        (obj_type, self.sa[1].describe(item)))
                    self.doc.end_paragraph()
            else:
                self.doc.start_paragraph('DIFF-Text')
                self.doc.write_text(_("Nothing added"))
                self.doc.end_paragraph()
            self.doc.start_paragraph('DIFF-Heading')
            self.doc.write_text("")
            self.doc.end_paragraph()
        self._user.end_progress()
Ejemplo n.º 27
0
def run(database, document, filter_name, *args, **kwargs):
    """
    Loops through the families that the person is a child in, and display
    the information about the other children.
    """
    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)
    if (filter_name == 'all'):
        sdoc.title(_("Summary counts of current selection"))
        sdoc.paragraph("")
        sdoc.paragraph(_("Right-click row (or press ENTER) to see selected items."))
        sdoc.paragraph("")
        stab.columns(_("Object"), _("Count/Total"))
        if hasattr(database, "db"):
            stab.row([_("People"), "Filter", "Person"], 
                     "%d/%d" % (len(database.get_person_handles()),
                                len(database.db.get_person_handles())))
            stab.row([_("Families"), "Filter", "Family"], 
                     "%d/%d" % (len(database.get_family_handles()),
                                len(database.db.get_family_handles())))
            stab.row([_("Events"), "Filter", "Event"], 
                     "%d/%d" % (len(database.get_event_handles()),
                                len(database.db.get_event_handles())))
            stab.row([_("Places"), "Filter", "Place"], 
                     "%d/%d" % (len(database.get_place_handles()),
                                len(database.db.get_place_handles())))
            stab.row([_("Sources"), "Filter", "Source"], 
                     "%d/%d" % (len(database.get_source_handles()),
                                len(database.db.get_source_handles())))
            stab.row([_("Repositories"), "Filter", "Repository"], 
                     "%d/%d" % (len(database.get_repository_handles()),
                     len(database.db.get_repository_handles())))
            stab.row([_("Media"), "Filter", "MediaObject"], 
                     "%d/%d" % (len(database.get_media_object_handles()),
                                len(database.db.get_media_object_handles())))
            stab.row([_("Notes"), "Filter", "Note"], 
                     "%d/%d" % (len(database.get_note_handles()),
                                len(database.db.get_note_handles())))
        else:
            stab.row([_("People"), "Filter", "Person"], 
                     "%d/%d" % (len(database.get_person_handles()),
                                len(database.basedb.get_person_handles())))
            stab.row([_("Families"), "Filter", "Family"], 
                     "%d/%d" % (len(database.get_family_handles()),
                                len(database.basedb.get_family_handles())))
            stab.row([_("Events"), "Filter", "Event"], 
                     "%d/%d" % (len(database.get_event_handles()),
                                len(database.basedb.get_event_handles())))
            stab.row([_("Places"), "Filter", "Place"], 
                     "%d/%d" % (len(database.get_place_handles()),
                                len(database.basedb.get_place_handles())))
            stab.row([_("Sources"), "Filter", "Source"], 
                     "%d/%d" % (len(database.get_source_handles()),
                                len(database.basedb.get_source_handles())))
            stab.row([_("Repositories"), "Filter", "Repository"], 
                     "%d/%d" % (len(database.get_repository_handles()),
                     len(database.basedb.get_repository_handles())))
            stab.row([_("Media"), "Filter", "MediaObject"], 
                     "%d/%d" % (len(database.get_media_object_handles()),
                                len(database.basedb.get_media_object_handles())))
            stab.row([_("Notes"), "Filter", "Note"], 
                     "%d/%d" % (len(database.get_note_handles()),
                                len(database.basedb.get_note_handles())))
        sdoc.paragraph("")
        stab.write(sdoc)
        return

    # display the title
    if filter_name in fname_map:
        sdoc.title(_("Filtering on %s") % fname_map[filter_name]) # listed above
    else:
        sdoc.title(_("Filtering on %s") % _(filter_name))
    sdoc.paragraph("")
    matches = 0

    if (filter_name == 'Inverse Person'):
        sdb.dbase = database.db
        stab.columns(_("Person"), _("Gramps ID"), _("Birth Date"))
        proxy_handles = set(database.iter_person_handles())

        for person in database.db.iter_people():
            if person.handle not in proxy_handles:
                stab.row(person, person.gramps_id, 
                         sdb.birth_or_fallback(person))
                matches += 1

    elif (filter_name == 'Inverse Family'):
        sdb.dbase = database.db
        stab.columns(_("Family"), _("Gramps ID"))
        proxy_handles = set(database.iter_family_handles())

        for family in database.db.iter_families():
            if family.handle not in proxy_handles:
                stab.row(family, family.gramps_id)
                matches += 1

    elif (filter_name == 'Inverse Event'):
        sdb.dbase = database.db
        stab.columns(_("Event"), _("Gramps ID"))
        proxy_handles = set(database.iter_event_handles())

        for event in database.db.iter_events():
            if event.handle not in proxy_handles:
                stab.row(event, event.gramps_id)
                matches += 1

    elif (filter_name == 'Inverse Place'):
        sdb.dbase = database.db
        stab.columns(_("Place"), _("Gramps ID"))
        proxy_handles = set(database.iter_place_handles())                              

        for place in database.db.iter_places():
            if place.handle not in proxy_handles:
                stab.row(place, place.gramps_id)
                matches += 1

    elif (filter_name == 'Inverse Source'):
        sdb.dbase = database.db
        stab.columns(_("Source"), _("Gramps ID"))
        proxy_handles = set(database.iter_source_handles())                              

        for source in database.db.iter_sources():
            if source.handle not in proxy_handles:
                stab.row(source, source.gramps_id)
                matches += 1

    elif (filter_name == 'Inverse Repository'):
        sdb.dbase = database.db
        stab.columns(_("Repository"), _("Gramps ID"))
        proxy_handles = set(database.iter_repository_handles())

        for repository in database.db.iter_repositories():
            if repository.handle not in proxy_handles:
                stab.row(repository, repository.gramps_id)
                matches += 1

    elif (filter_name == 'Inverse MediaObject'):
        sdb.dbase = database.db
        stab.columns(_("Media"), _("Gramps ID"))
        proxy_handles = set(database.iter_media_object_handles())                              

        for media in database.db.iter_media_objects():
            if media.handle not in proxy_handles:
                stab.row(media, media.gramps_id)
                matches += 1

    elif (filter_name == 'Inverse Note'):
        sdb.dbase = database.db
        stab.columns(_("Note"), _("Gramps ID"))
        proxy_handles = set(database.iter_note_handles())                              

        for note in database.db.iter_notes():
            if note.handle not in proxy_handles:
                stab.row(note, note.gramps_id)
                matches += 1

    elif (filter_name in ['all people', 'Person']):
        stab.columns(_("Person"), _("Gramps ID"), _("Birth Date"))
        for person in database.iter_people():
            stab.row(person, person.gramps_id, sdb.birth_or_fallback(person))
            matches += 1

    elif (filter_name in ['all families', 'Family']):
        stab.columns(_("Family"), _("Gramps ID"))
        for family in database.iter_families():
            stab.row(family, family.gramps_id)
            matches += 1

    elif (filter_name in ['all events', 'Event']):
        stab.columns(_("Event"), _("Gramps ID"))
        for obj in database.iter_events():
            stab.row(obj, obj.gramps_id)
            matches += 1

    elif (filter_name in ['all places', 'Place']):
        stab.columns(_("Place"), _("Gramps ID"))
        for obj in database.iter_places():
            stab.row(obj, obj.gramps_id)
            matches += 1

    elif (filter_name in ['all sources', 'Source']):
        stab.columns(_("Source"), _("Gramps ID"))
        for obj in database.iter_sources():
            stab.row(obj, obj.gramps_id)
            matches += 1

    elif (filter_name in ['all repositories', 'Repository']):
        stab.columns(_("Repository"), _("Gramps ID"))
        for obj in database.iter_repositories():
            stab.row(obj, obj.gramps_id)
            matches += 1

    elif (filter_name in ['all media', 'MediaObject']):
        stab.columns(_("Media"), _("Gramps ID"))
        for obj in database.iter_media_objects():
            stab.row(obj, obj.gramps_id)
            matches += 1

    elif (filter_name in ['all notes', 'Note']):
        stab.columns(_("Note"), _("Gramps ID"))
        for obj in database.iter_notes():
            stab.row(obj, obj.gramps_id)
            matches += 1

    elif (filter_name == 'males'):
        stab.columns(_("Person"), _("Birth Date"), _("Name type"))
        for person in database.iter_people():
            if person.gender == Person.MALE:
                stab.row(person, sdb.birth_or_fallback(person),
                         str(person.get_primary_name().get_type()))
                matches += 1

    elif (filter_name == 'females'):
        stab.columns(_("Person"), _("Birth Date"), _("Name type"))
        for person in database.iter_people():
            if person.gender == Person.FEMALE:
                stab.row(person, sdb.birth_or_fallback(person),
                         str(person.get_primary_name().get_type()))
                matches += 1

    elif (filter_name == 'people with unknown gender'):
        stab.columns(_("Person"), _("Birth Date"), _("Name type"))
        for person in database.iter_people():
            if person.gender not in [Person.FEMALE, Person.MALE]:
                stab.row(person, sdb.birth_or_fallback(person),
                         str(person.get_primary_name().get_type()))
                matches += 1

    elif (filter_name == 'incomplete names'):
        stab.columns(_("Name"), _("Birth Date"), _("Name type"))
        for person in database.iter_people():
            for name in [person.get_primary_name()] + person.get_alternate_names():
                if name.get_first_name().strip() == "":
                    stab.row([name.get_name(), "Person", person.handle], sdb.birth_or_fallback(person),
                             str(name.get_type()))
                    matches += 1
                else:
                    if name.get_surname_list():
                        for surname in name.get_surname_list():
                            if surname.get_surname().strip() == "":
                                stab.row([name.get_first_name(), "Person", person.handle], sdb.birth_or_fallback(person),
                                         str(name.get_type()))
                                matches += 1
                    else:
                        stab.row([name.get_first_name(), "Person", person.handle], sdb.birth_or_fallback(person),
                                 str(name.get_type()))
                        matches += 1

    elif (filter_name == 'people with missing birth dates'):
        stab.columns(_("Person"), _("Type"))
        for person in database.iter_people():
            birth_ref = person.get_birth_ref()
            if birth_ref:
                birth = database.get_event_from_handle(birth_ref.ref)
                if not get_date(birth):
                    stab.row(person, _("birth event but no date"))
                    matches += 1
            else:
                stab.row(person, _("missing birth event"))
                matches += 1

    elif (filter_name == 'disconnected people'):
        stab.columns(_("Person"), _("Birth Date"), _("Name type"))
        for person in database.iter_people():
            if ((not person.get_main_parents_family_handle()) and 
                (not len(person.get_family_handle_list()))):
                stab.row(person, sdb.birth_or_fallback(person),
                         str(person.get_primary_name().get_type()))
                matches += 1

    elif (filter_name == 'unique surnames'):
        namelist = defaultdict(int)
        for person in database.iter_people():
            names = [person.get_primary_name()] + person.get_alternate_names()
            surnames = list(set([name.get_group_name() for name in names]))
            for surname in surnames:
                namelist[surname] += 1
        stab.columns(_("Surname"), _("Count"))
        for name in sorted(namelist):
            stab.row(name, namelist[name])
            matches += 1
        stab.set_callback("leftdouble", 
            lambda name: run_quick_report_by_name_direct("samesurnames",
                                                         database,
                                                         document,
                                                         name))

    elif (filter_name == 'people with media'):
        stab.columns(_("Person"), _("Media count"))
        for person in database.iter_people():
            length = len(person.get_media_list())
            if length > 0:
                stab.row(person, str(length))
                matches += 1

    elif (filter_name == 'media references'):
        stab.columns(_("Person"), _("Reference"))
        for person in database.iter_people():
            medialist = person.get_media_list()
            for item in medialist:
                stab.row(person, _("media"))
                matches += 1

    elif (filter_name == 'unique media'):
        stab.columns(_("Unique Media"))
        for photo in database.iter_media_objects():
            fullname = media_path_full(database, photo.get_path())
            stab.row(fullname)
            matches += 1

    elif (filter_name == 'missing media'):
        stab.columns(_("Missing Media"))
        for photo in database.iter_media_objects():
            fullname = media_path_full(database, photo.get_path())
            try:
                posixpath.getsize(fullname)
            except:
                stab.row(fullname)
                matches += 1

    elif (filter_name == 'media by size'):
        stab.columns(_("Media"), _("Size in bytes"))
        for photo in database.iter_media_objects():
            fullname = media_path_full(database, photo.get_path())
            try:
                bytes = posixpath.getsize(fullname)
                stab.row(fullname, str(bytes))
                matches += 1
            except:
                pass

    elif (filter_name == 'list of people'):
        stab.columns(_("Person"), _("Birth Date"), _("Name type"))
        handles = kwargs["handles"]
        for person_handle in handles:
            person = database.get_person_from_handle(person_handle)
            stab.row(person, sdb.birth_or_fallback(person),
                     str(person.get_primary_name().get_type()))
            matches += 1

    else:
        raise AttributeError("invalid filter name: '%s'" % filter_name)
    # translators: leave all/any {...} untranslated
    sdoc.paragraph(ngettext("Filter matched {number_of} record.",
                            "Filter matched {number_of} records.", matches
                           ).format(number_of=matches) )
    sdoc.paragraph("")
    document.has_data = matches > 0
    if matches > 0:
        stab.write(sdoc)
Ejemplo n.º 28
0
def run(database, document, object, item='place', trans=_("Place")):
    """
    Display back-references for this object.
    """

    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)

    # hold a person-event dictionary
    pedic = defaultdict(list)
    for pe in database.get_person_handles():
        for eventref in database.get_person_from_handle(pe).event_ref_list:
            pedic[eventref.ref].append((eventref.get_role(), pe))
    #for ev in pedic.keys():
    #    print(ev,pedic[ev])

    # display the title
    sdoc.title(_("References for this %s") % trans)
    sdoc.paragraph("\n")
    stab.columns(_("Type"), _("Reference"), _("Date"), _("Persons"))
    


    # get the events
    event_handle_list = [handle for (objclass, handle) in database.find_backlink_handles(object.handle)]
    
    #    ref = get_ref(database, objclass, handle)
    #    #print(ref,pedic[handle])
    #    line=''
    #    for i, (role, personhandle) in enumerate(pedic[handle]):
    #        line = line + ' ' + (
    #                f'{i} {role} {_nd.display(database.get_person_from_handle(personhandle))} '
    #                f'[{database.get_person_from_handle(personhandle).get_gramps_id()}]'
    #                )
    #    e_date = ref.get_date_object()
    #    s_date = ref.get_date_object().get_sort_value()
    #    event_list += [s_date, _(objclass), ref, e_date, line]


    # Sort the events by their date
    event_handle_list.sort(key=lambda x: database.get_event_from_handle(x).get_date_object().get_sort_value())
    print(len(event_handle_list))
    for handle in event_handle_list:
        print(database.get_event_from_handle(handle), pedic[handle], database.get_event_from_handle(handle).get_date_object())

        line=''
        for i, (role, personhandle) in enumerate(pedic[handle]):
            line = line + ' ' + (
                    f'{i} {role} {_nd.display(database.get_person_from_handle(personhandle))} '
                    f'[{database.get_person_from_handle(personhandle).get_gramps_id()}]'
                    )
        stab.row(database.get_event_from_handle(handle).get_description(), database.get_event_from_handle(handle), database.get_event_from_handle(handle).get_date_object(), line)  # translation are explicit (above)

    if stab.get_row_count() > 0:
        document.has_data = True
#        stab.sort(_("Date"))
        stab.write(sdoc)
    else:
        document.has_data = False
        sdoc.paragraph(_("No references for this %s") % trans)
        sdoc.paragraph("")
    sdoc.paragraph("")
Ejemplo n.º 29
0
def run(database, document, main_event):
    """
    Displays events on a specific date of an event (or date)

    Takes an Event or Date object
    """
    if isinstance(main_event, Date):
        main_date = main_event
    else:
        main_date = main_event.get_date_object()

    cal = main_date.get_calendar()

    # setup the simple access functions
    sdb = SimpleAccess(database)
    sdoc = SimpleDoc(document)
    stab = QuickTable(sdb)
    stab.set_link_col(3)
    yeartab = QuickTable(sdb)
    yeartab.set_link_col(3)
    histab = QuickTable(sdb)
    histab.set_link_col(3)

    # display the title
    sdoc.title(_("Events of %(date)s") % {"date": sdb.date_string(main_date)})
    sdoc.paragraph("")
    stab.columns(_("Date"), _("Type"), _("Place"), _("Reference"))
    yeartab.columns(_("Date"), _("Type"), _("Place"), _("Reference"))
    histab.columns(_("Date"), _("Type"), _("Place"), _("Reference"))

    for event in database.iter_events():
        date = event.get_date_object()
        date.convert_calendar(cal)
        if date.get_year() == 0:
            continue
        if (date.get_year() == main_date.get_year()
                and date.get_month() == main_date.get_month()
                and date.get_day() == main_date.get_day()):
            for (objclass,
                 handle) in database.find_backlink_handles(event.handle):
                ref = get_ref(database, objclass, handle)
                stab.row(date, sdb.event_type(event), sdb.event_place(event),
                         ref)
        elif (date.get_month() == main_date.get_month()
              and date.get_day() == main_date.get_day()
              and date.get_month() != 0):
            for (objclass,
                 handle) in database.find_backlink_handles(event.handle):
                ref = get_ref(database, objclass, handle)
                histab.row(date, sdb.event_type(event), sdb.event_place(event),
                           ref)
        elif (date.get_year() == main_date.get_year()):
            for (objclass,
                 handle) in database.find_backlink_handles(event.handle):
                ref = get_ref(database, objclass, handle)
                yeartab.row(date, sdb.event_type(event),
                            sdb.event_place(event), ref)

    document.has_data = False
    if stab.get_row_count() > 0:
        document.has_data = True
        sdoc.paragraph(_("Events on this exact date"))
        stab.write(sdoc)
    else:
        sdoc.paragraph(_("No events on this exact date"))
        sdoc.paragraph("")
    sdoc.paragraph("")

    if histab.get_row_count() > 0:
        document.has_data = True
        sdoc.paragraph(_("Other events on this month/day in history"))
        histab.write(sdoc)
    else:
        sdoc.paragraph(_("No other events on this month/day in history"))
        sdoc.paragraph("")
    sdoc.paragraph("")

    if yeartab.get_row_count() > 0:
        document.has_data = True
        sdoc.paragraph(
            _("Other events in %(year)d") % {"year": main_date.get_year()})
        yeartab.write(sdoc)
    else:
        sdoc.paragraph(
            _("No other events in %(year)d") % {"year": main_date.get_year()})
        sdoc.paragraph("")
    sdoc.paragraph("")
Ejemplo n.º 30
0
 def __init__(self, *args, **kwargs):
     self.dbi = DBI(StructTest.DB, None)  # no document here
     self.dbi.flat = True
     self.dbi.sdb = SimpleAccess(StructTest.DB)
     self.pcount = len(StructTest.DB._tables["Person"]["handles_func"]())
     unittest.TestCase.__init__(self, *args, **kwargs)