348 lines
11 KiB
Python
348 lines
11 KiB
Python
import web.grampsdb.models as models
|
|
from web import libdjango
|
|
from web.djangodb import DjangoDb
|
|
from Simple import SimpleTable, SimpleAccess, make_basic_stylesheet
|
|
import Utils
|
|
import DbState
|
|
import DateHandler
|
|
from gen.lib.date import Date as GDate, Today
|
|
from gen.plug import BasePluginManager
|
|
from cli.grampscli import CLIManager
|
|
from django.template import escape
|
|
from django.contrib.contenttypes.models import ContentType
|
|
|
|
dji = libdjango.DjangoInterface()
|
|
|
|
_dd = DateHandler.displayer.display
|
|
_dp = DateHandler.parser.parse
|
|
|
|
def register_plugins():
|
|
dbstate = DbState.DbState()
|
|
climanager = CLIManager(dbstate, False) # don't load db
|
|
climanager.do_reg_plugins()
|
|
pmgr = BasePluginManager.get_instance()
|
|
return pmgr
|
|
|
|
def probably_alive(handle):
|
|
db = DjangoDb()
|
|
return Utils.probably_alive(db.get_person_from_handle(handle), db)
|
|
|
|
class Table(object):
|
|
"""
|
|
>>> table = Table()
|
|
>>> table.columns("Col1", "Col2", "Col3")
|
|
>>> table.row("1", "2", "3")
|
|
>>> table.row("4", "5", "6")
|
|
>>> table.get_html()
|
|
"""
|
|
def __init__(self):
|
|
self.db = DjangoDb()
|
|
self.access = SimpleAccess(self.db)
|
|
self.table = SimpleTable(self.access)
|
|
class Doc(object):
|
|
def __init__(self, doc):
|
|
self.doc = doc
|
|
# None is paperstyle, which is ignored:
|
|
self.doc = Doc(HtmlDoc.HtmlDoc(make_basic_stylesheet(), None))
|
|
self.doc.doc._backend = HtmlBackend()
|
|
# You can set elements id, class, etc:
|
|
# self.doc.doc.htmllist += [Html('div', id="grampstextdoc")]
|
|
self.doc.doc.htmllist += [Html('div')]
|
|
|
|
def columns(self, *args):
|
|
self.table.columns(*args)
|
|
|
|
def row(self, *args):
|
|
self.table.row(*args)
|
|
|
|
def get_html(self):
|
|
self.table.write(self.doc) # forces to htmllist
|
|
return str(self.doc.doc.htmllist[0])
|
|
|
|
_ = lambda text: text
|
|
|
|
def person_event_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Description"),
|
|
_("Type"),
|
|
_("ID"),
|
|
_("Date"),
|
|
_("Place"),
|
|
_("Role"))
|
|
obj_type = ContentType.objects.get_for_model(djperson)
|
|
event_ref_list = models.EventRef.objects.filter(
|
|
object_id=djperson.id,
|
|
object_type=obj_type).order_by("order")
|
|
event_list = [(obj.ref_object, obj) for obj in event_ref_list]
|
|
for (djevent, event_ref) in event_list:
|
|
table.row(
|
|
djevent.description,
|
|
table.db.get_event_from_handle(djevent.handle),
|
|
djevent.gramps_id,
|
|
display_date(djevent),
|
|
get_title(djevent.place),
|
|
str(event_ref.role_type))
|
|
return table.get_html()
|
|
|
|
def person_name_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Name"),
|
|
_("Type"),
|
|
_("Group As"),
|
|
_("Source"),
|
|
_("Note Preview"))
|
|
for name in djperson.name_set.all():
|
|
obj_type = ContentType.objects.get_for_model(name)
|
|
sourceq = dji.SourceRef.filter(object_type=obj_type,
|
|
object_id=name.id).count() > 0
|
|
note_refs = dji.NoteRef.filter(object_type=obj_type,
|
|
object_id=name.id)
|
|
note = ""
|
|
if note_refs.count() > 0:
|
|
note = dji.Note.get(id=note_refs[0].object_id).text[:50]
|
|
table.row(make_name(name, user),
|
|
str(name.name_type),
|
|
name.group_as,
|
|
["No", "Yes"][sourceq],
|
|
note)
|
|
return table.get_html()
|
|
|
|
def person_source_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("ID"),
|
|
_("Title"),
|
|
_("Author"),
|
|
_("Page"))
|
|
obj_type = ContentType.objects.get_for_model(djperson)
|
|
source_refs = dji.SourceRef.filter(object_type=obj_type,
|
|
object_id=djperson.id)
|
|
for source_ref in source_refs:
|
|
source = table.db.get_source_from_handle(source_ref.ref_object.handle)
|
|
table.row(source,
|
|
source_ref.ref_object.title,
|
|
source_ref.ref_object.author,
|
|
source_ref.page,
|
|
)
|
|
return table.get_html()
|
|
|
|
def person_attribute_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Type"),
|
|
_("Value"),
|
|
)
|
|
obj_type = ContentType.objects.get_for_model(djperson)
|
|
attributes = dji.Attribute.filter(object_type=obj_type,
|
|
object_id=djperson.id)
|
|
for attribute in attributes:
|
|
table.row(attribute.attribute_type.name,
|
|
attribute.value)
|
|
return table.get_html()
|
|
|
|
def person_address_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Date"),
|
|
_("Address"),
|
|
_("City"),
|
|
_("State"),
|
|
_("Country"))
|
|
for address in djperson.address_set.all().order_by("order"):
|
|
locations = address.location_set.all().order_by("order")
|
|
for location in locations:
|
|
table.row(display_date(address),
|
|
location.street,
|
|
location.city,
|
|
location.state,
|
|
location.country)
|
|
return table.get_html()
|
|
|
|
def person_note_table(djperson, user):
|
|
table = Table()
|
|
table.columns(
|
|
_("ID"),
|
|
_("Type"),
|
|
_("Note"))
|
|
obj_type = ContentType.objects.get_for_model(djperson)
|
|
note_refs = dji.NoteRef.filter(object_type=obj_type,
|
|
object_id=djperson.id)
|
|
for note_ref in note_refs:
|
|
note = table.db.get_note_from_handle(
|
|
note_ref.ref_object.handle)
|
|
table.row(table.db.get_note_from_handle(note.handle),
|
|
str(note_ref.ref_object.note_type),
|
|
note_ref.ref_object.text[:50])
|
|
return table.get_html()
|
|
|
|
def person_gallery_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Name"),
|
|
_("Type"),
|
|
)
|
|
return table.get_html()
|
|
|
|
def person_internet_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Type"),
|
|
_("Path"),
|
|
_("Description"))
|
|
urls = dji.Url.filter(person=djperson)
|
|
for url in urls:
|
|
table.row(str(url.url_type),
|
|
url.path,
|
|
url.desc)
|
|
return table.get_html()
|
|
|
|
def person_association_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Name"),
|
|
_("ID"),
|
|
_("Association"))
|
|
gperson = table.db.get_person_from_handle(djperson.handle)
|
|
associations = gperson.get_person_ref_list()
|
|
for association in associations:
|
|
table.row()
|
|
return table.get_html()
|
|
|
|
def person_lds_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Type"),
|
|
_("Date"),
|
|
_("Status"),
|
|
_("Temple"),
|
|
_("Place"))
|
|
obj_type = ContentType.objects.get_for_model(djperson)
|
|
ldss = djperson.lds_set.all().order_by("order")
|
|
for lds in ldss:
|
|
table.row(str(lds.lds_type),
|
|
display_date(lds),
|
|
str(lds.status),
|
|
lds.temple,
|
|
get_title(lds.place))
|
|
return table.get_html()
|
|
|
|
def person_reference_table(djperson, user):
|
|
table = Table()
|
|
table.columns(_("Type"),
|
|
_("ID"),
|
|
_("Name"))
|
|
references = dji.PersonRef.filter(ref_object=djperson)
|
|
for reference in references:
|
|
table.row(str(reference.ref_object),
|
|
reference.ref_object.gramps_id,
|
|
make_name(reference.ref_object.name_set, user))
|
|
return table.get_html()
|
|
|
|
def family_children_table(djfamily, user):
|
|
table = Table()
|
|
table.columns(_("Column"))
|
|
table.row("test")
|
|
return table.get_html()
|
|
|
|
def family_event_table(djfamily, user):
|
|
table = Table()
|
|
table.columns(_("Column"))
|
|
table.row("test")
|
|
return table.get_html()
|
|
|
|
def family_source_table(djfamily, user):
|
|
table = Table()
|
|
table.columns(_("Column"))
|
|
table.row("test")
|
|
return table.get_html()
|
|
|
|
def family_attribute_table(djfamily, user):
|
|
table = Table()
|
|
table.columns(_("Column"))
|
|
table.row("test")
|
|
return table.get_html()
|
|
|
|
def family_note_table(djfamily, user):
|
|
table = Table()
|
|
table.columns(_("Column"))
|
|
table.row("test")
|
|
return table.get_html()
|
|
|
|
def family_gallery_table(djfamily, user):
|
|
table = Table()
|
|
table.columns(_("Column"))
|
|
table.row("test")
|
|
return table.get_html()
|
|
|
|
def family_lds_table(djfamily, user):
|
|
table = Table()
|
|
table.columns(_("Column"))
|
|
table.row("test")
|
|
return table.get_html()
|
|
|
|
## FIXME: these dji function wrappers just use the functions
|
|
## written for the import/export. Can be done much more directly.
|
|
|
|
def get_title(place):
|
|
if place:
|
|
return place.title
|
|
else:
|
|
return ""
|
|
|
|
def person_get_birth_date(person):
|
|
return person_get_event(person, models.EventType.BIRTH)
|
|
|
|
def person_get_death_date(person):
|
|
return person_get_event(person, models.EventType.DEATH)
|
|
|
|
def display_date(obj):
|
|
date_tuple = dji.get_date(obj)
|
|
if date_tuple:
|
|
gdate = GDate()
|
|
gdate.unserialize(date_tuple)
|
|
return escape(_dd(gdate))
|
|
else:
|
|
return ""
|
|
|
|
def person_get_event(person, event_type=None):
|
|
event_ref_list = dji.get_event_ref_list(person)
|
|
if event_type:
|
|
index = libdjango.lookup_role_index(event_type, event_ref_list)
|
|
if index >= 0:
|
|
event_handle = event_ref_list[index][3]
|
|
# (False, [], [], u'b2cfa6cdec87392cf3b', (1, u'Primary'))
|
|
# WARNING: the same object can be referred to more than once
|
|
objs = models.EventRef.objects.filter(ref_object__handle=event_handle)
|
|
if objs.count() > 0:
|
|
return display_date(objs[0].ref_object)
|
|
else:
|
|
return ""
|
|
else:
|
|
return ""
|
|
else:
|
|
retval = [[obj.ref_object for obj in
|
|
models.EventRef.objects.filter(ref_object__handle=event_handle[3])]
|
|
for event_handle in event_ref_list]
|
|
return [j for i in retval for j in i]
|
|
|
|
def make_name(name, user):
|
|
if isinstance(name, models.Name):
|
|
surname = name.surname.strip()
|
|
if not surname:
|
|
surname = "[Missing]"
|
|
if user.is_authenticated():
|
|
return escape("%s, %s" % (surname, name.first_name))
|
|
else:
|
|
if probably_alive(name.person.handle):
|
|
return escape("%s, %s" % (surname, "[Living]"))
|
|
else:
|
|
return escape("%s, %s" % (surname, name.first_name))
|
|
elif name: # name_set
|
|
name = name.get(preferred=True)
|
|
if name:
|
|
return make_name(name, user)
|
|
else:
|
|
return ""
|
|
else:
|
|
return ""
|
|
|
|
register_plugins()
|
|
|
|
# works after registering plugins:
|
|
import HtmlDoc
|
|
from libhtmlbackend import HtmlBackend
|
|
from libhtml import Html
|