"""

Find the handle in a unserialized event_ref_list and return code.

"""

if role0 is None:

return -1

else:

count = 0

for event_ref in event_ref_list:

(private, note_list, attribute_list, ref, erole) = event_ref

try:

event = models.Event.objects.get(handle=ref)

except:

return -1

if event.event_type[0] == role0:

return count

count += 1

if dtime:

return int(time.mktime(dtime.timetuple()))

else:

"""

Get the unserialized event_ref in an list of them and return it.

"""

if index < 0:

return None

else:

count = 0

for event_ref in event_ref_list:

(private, note_list, attribute_list, ref, role) = event_ref

if index == count:

return ref

count += 1

"""

DjangoInterface for interoperating between Gramps and Simple Django.

"""

def __init__(self):

self.debug = 0

def __getattr__(self, name):

"""

Django Objects database interface.

>>> self.Person.all()

>>> self.Person.get(id=1)

>>> self.Person.get(handle='gh71234dhf3746347734')

"""

if hasattr(models, name):

return getattr(models, name).objects

else:

raise AttributeError("no such model: '%s'" % name)

# -----------------------------------------------

# Get methods to retrieve list data from the tables

# -----------------------------------------------

"""

def get_attribute_list(self, obj):

obj_type = ContentType.objects.get_for_model(obj)

attribute_list = models.Attribute.objects.filter(object_id=obj.id,

object_type=obj_type)

return list(map(self.pack_attribute, attribute_list))

def get_primary_name(self, person):

names = person.name_set.filter(preferred=True).order_by("order")

if len(names) > 0:

return Name.create(self.pack_name(names[0]))

else:

return Name()

def get_alternate_names(self, person):

names = person.name_set.filter(preferred=False).order_by("order")

return [Name.create(self.pack_name(n)) for n in names]

def get_names(self, person, preferred):

names = person.name_set.filter(preferred=preferred).order_by("order")

if preferred:

if len(names) > 0:

return self.pack_name(names[0])

else:

return Name().serialize()

else:

return list(map(self.pack_name, names))

def get_source_datamap(self, source):

return dict([map.key, map.value] for map in source.sourcedatamap_set.all().order_by("order"))

def get_citation_datamap(self, citation):

return dict([map.key, map.value] for map in citation.citationdatamap_set.all().order_by("order"))

def get_media_list(self, obj):

obj_type = ContentType.objects.get_for_model(obj)

mediarefs = models.MediaRef.objects.filter(object_id=obj.id,

object_type=obj_type)

return list(map(self.pack_media_ref, mediarefs))

def get_note_list(self, obj):

obj_type = ContentType.objects.get_for_model(obj)

noterefs = models.NoteRef.objects.filter(object_id=obj.id,

object_type=obj_type)

return [noteref.ref_object.handle for noteref in noterefs]

def get_repository_ref_list(self, obj):

obj_type = ContentType.objects.get_for_model(obj)

reporefs = models.RepositoryRef.objects.filter(object_id=obj.id,

object_type=obj_type)

return list(map(self.pack_repository_ref, reporefs))

def get_url_list(self, obj):

return list(map(self.pack_url, obj.url_set.all().order_by("order")))

def get_address_list(self, obj, with_parish): # person or repository

addresses = obj.address_set.all().order_by("order")

return [self.pack_address(address, with_parish)

for address in addresses]

def get_child_ref_list(self, family):

obj_type = ContentType.objects.get_for_model(family)

childrefs = models.ChildRef.objects.filter(object_id=family.id,

object_type=obj_type).order_by("order")

return list(map(self.pack_child_ref, childrefs))

def get_citation_list(self, obj):

obj_type = ContentType.objects.get_for_model(obj)

citationrefs = models.CitationRef.objects.filter(object_id=obj.id,

object_type=obj_type).order_by("order")

return [citationref.citation.handle for citationref in citationrefs]

def get_event_refs(self, obj, order="order"):

obj_type = ContentType.objects.get_for_model(obj)

eventrefs = models.EventRef.objects.filter(object_id=obj.id,

object_type=obj_type).order_by(order)

return eventrefs

def get_event_ref_list(self, obj):

obj_type = ContentType.objects.get_for_model(obj)

eventrefs = models.EventRef.objects.filter(object_id=obj.id,

object_type=obj_type).order_by("order")

return list(map(self.pack_event_ref, eventrefs))

def get_family_list(self, person): # person has families

return [fam.family.handle for fam in

models.MyFamilies.objects.filter(person=person).order_by("order")]

def get_parent_family_list(self, person): # person's parents has families

return [fam.family.handle for fam in

models.MyParentFamilies.objects.filter(person=person).order_by("order")]

def get_person_ref_list(self, person):

obj_type = ContentType.objects.get_for_model(person)

return list(map(self.pack_person_ref,

models.PersonRef.objects.filter(object_id=person.id,

object_type=obj_type)))

def get_lds_list(self, obj): # person or family

return list(map(self.pack_lds, obj.lds_set.all().order_by("order")))

def get_place_handle(self, obj): # obj is event

if obj.place:

return obj.place.handle

return ''

"""

## Export lists:

def add_citation_list(self, obj, citation_list):

for citation_handle in citation_list:

self.add_citation_ref(obj, citation_handle)

def add_event_ref_list(self, obj, event_ref_list):

for event_ref in event_ref_list:

self.add_event_ref(obj, event_ref)

def add_surname_list(self, name, surname_list):

order = 1

for data in surname_list:

(surname_text, prefix, primary, origin_type,

connector) = data

surname = models.Surname()

surname.surname = surname_text

surname.prefix = prefix

surname.primary = primary

surname.name_origin_type = models.get_type(models.NameOriginType,

origin_type)

surname.connector = connector

surname.name = name

surname.order = order

surname.save()

order += 1

def add_note_list(self, obj, note_list):

for handle in note_list:

# Just the handle

try:

note = models.Note.objects.get(handle=handle)

self.add_note_ref(obj, note)

except:

print(("ERROR: Note does not exist: '%s'" %

handle), file=sys.stderr)

def add_alternate_name_list(self, person, alternate_names):

for name in alternate_names:

if name:

self.add_name(person, name, False)

def add_parent_family_list(self, person, parent_family_list):

for parent_family_data in parent_family_list:

self.add_parent_family(person, parent_family_data)

def add_media_ref_list(self, person, media_list):

for media_data in media_list:

self.add_media_ref(person, media_data)

def add_attribute_list(self, obj, attribute_list):

for attribute_data in attribute_list:

self.add_attribute(obj, attribute_data)

def add_tag_list(self, obj, tag_list):

for tag_handle in tag_list:

try:

tag = models.Tag.objects.get(handle=tag_handle)

except:

print(("ERROR: Tag does not exist: '%s'" %

tag_handle), file=sys.stderr)

obj.tags.add(tag)

def add_url_list(self, field, obj, url_list):

if not url_list: return None

count = 1

for url_data in url_list:

self.add_url(field, obj, url_data, count)

count += 1

def add_person_ref_list(self, obj, person_ref_list):

for person_ref_data in person_ref_list:

self.add_person_ref(obj, person_ref_data)

def add_address_list(self, field, obj, address_list):

count = 1

for address_data in address_list:

self.add_address(field, obj, address_data, count)

count += 1

def add_lds_list(self, field, obj, lds_ord_list):

count = 1

for ldsord in lds_ord_list:

lds = self.add_lds(field, obj, ldsord, count)

#obj.lds_list.add(lds)

#obj.save()

count += 1

def add_repository_ref_list(self, obj, reporef_list):

for data in reporef_list:

self.add_repository_ref(obj, data)

def add_family_ref_list(self, person, family_list):

for family_handle in family_list:

self.add_family_ref(person, family_handle)

## Export reference objects:

def add_person_ref_default(self, obj, person, private=False, desc=None):

count = person.references.count()

person_ref = models.PersonRef(referenced_by=obj,

ref_object=person,

private=private,

order=count + 1,

description=desc)

person_ref.save()

def add_person_ref(self, obj, person_ref_data):

(private,

citation_list,

note_list,

handle,

desc) = person_ref_data

try:

person = models.Person.objects.get(handle=handle)

except:

print(("ERROR: Person does not exist: '%s'" %

handle), file=sys.stderr)

return

count = person.references.count()

person_ref = models.PersonRef(referenced_by=obj,

ref_object=person,

private=private,

order=count + 1,

description=desc)

person_ref.save()

self.add_note_list(person_ref, note_list)

self.add_citation_list(person_ref, citation_list)

def add_note_ref(self, obj, note):

count = note.references.count()

note_ref = models.NoteRef(referenced_by=obj,

ref_object=note,

private=False,

order=count + 1)

note_ref.save()

def add_media_ref_default(self, obj, media, private=False, role=None):

count = media.references.count()

if not role:

role = (0,0,0,0)

media_ref = models.MediaRef(referenced_by=obj,

ref_object=media,

x1=role[0],

y1=role[1],

x2=role[2],

y2=role[3],

private=private,

order=count + 1)

media_ref.save()

def add_media_ref(self, obj, media_ref_data):

(private, citation_list, note_list, attribute_list,

ref, role) = media_ref_data

try:

media = models.Media.objects.get(handle=ref)

except:

print(("ERROR: Media does not exist: '%s'" %

ref), file=sys.stderr)

return

count = media.references.count()

if not role:

role = (0,0,0,0)

media_ref = models.MediaRef(referenced_by=obj,

ref_object=media,

x1=role[0],

y1=role[1],

x2=role[2],

y2=role[3],

private=private,

order=count + 1)

media_ref.save()

self.add_note_list(media_ref, note_list)

self.add_attribute_list(media_ref, attribute_list)

self.add_citation_list(media_ref, citation_list)

def add_citation_ref_default(self, obj, citation, private=False):

object_type = ContentType.objects.get_for_model(obj)

count = models.CitationRef.objects.filter(object_id=obj.id,object_type=object_type).count()

citation_ref = models.CitationRef(private=private,

referenced_by=obj,

citation=citation,

order=count + 1)

citation_ref.save()

def add_citation_ref(self, obj, handle):

try:

citation = models.Citation.objects.get(handle=handle)

except:

print(("ERROR: Citation does not exist: '%s'" %

handle), file=sys.stderr)

return

object_type = ContentType.objects.get_for_model(obj)

count = models.CitationRef.objects.filter(object_id=obj.id,object_type=object_type).count()

citation_ref = models.CitationRef(private=False,

referenced_by=obj,

citation=citation,

order=count + 1)

citation_ref.save()

def add_citation(self, citation_data):

(handle, gid, date, page, confidence, source_handle, note_list,

media_list, datamap, changed, private) = citation_data

citation = models.Citation(

handle=handle,

gramps_id=gid,

private=private,

last_changed=todate(changed),

confidence=confidence,

page=page)

citation.save()

def add_citation_detail(self, citation_data):

(handle, gid, date, page, confidence, source_handle, note_list,

media_list, datamap, change, private) = citation_data

try:

citation = models.Citation.objects.get(handle=handle)

except:

print(("ERROR: Citation does not exist: '%s'" %

handle), file=sys.stderr)

return

try:

source = models.Source.objects.get(handle=source_handle)

except:

print(("ERROR: Source does not exist: '%s'" %

source_handle), file=sys.stderr)

return

citation.source = source

self.add_date(citation, date)

citation.cache = self.encode_raw(citation_data)

citation.save()

self.add_note_list(citation, note_list)

self.add_media_ref_list(citation, media_list)

self.add_citation_datamap_dict(citation, datamap)

def add_child_ref_default(self, obj, child, frel=1, mrel=1, private=False):

object_type = ContentType.objects.get_for_model(obj) # obj is family

count = models.ChildRef.objects.filter(object_id=obj.id,object_type=object_type).count()

child_ref = models.ChildRef(private=private,

referenced_by=obj,

ref_object=child,

order=count + 1,

father_rel_type=models.get_type(models.ChildRefType, frel), # birth

mother_rel_type=models.get_type(models.ChildRefType, mrel))

child_ref.save()

def add_child_ref(self, obj, data):

(private, citation_list, note_list, ref, frel, mrel) = data

try:

child = models.Person.objects.get(handle=ref)

except:

print(("ERROR: Person does not exist: '%s'" %

ref), file=sys.stderr)

return

object_type = ContentType.objects.get_for_model(obj)

count = models.ChildRef.objects.filter(object_id=obj.id,object_type=object_type).count()

child_ref = models.ChildRef(private=private,

referenced_by=obj,

ref_object=child,

order=count + 1,

father_rel_type=models.get_type(models.ChildRefType, frel),

mother_rel_type=models.get_type(models.ChildRefType, mrel))

child_ref.save()

self.add_citation_list(child_ref, citation_list)

self.add_note_list(child_ref, note_list)

"""

def add_event_ref_default(self, obj, event, private=False, role=models.EventRoleType._DEFAULT):

object_type = ContentType.objects.get_for_model(obj)

count = models.EventRef.objects.filter(object_id=obj.id,object_type=object_type).count()

event_ref = models.EventRef(private=private,

referenced_by=obj,

ref_object=event,

order=count + 1,

role_type = models.get_type(models.EventRoleType, role))

event_ref.save()

"""

def add_event_ref(self, obj, event_data):

(private, note_list, attribute_list, ref, role) = event_data

try:

event = models.Event.objects.get(handle=ref)

except:

print(("ERROR: Event does not exist: '%s'" %

ref), file=sys.stderr)

return

object_type = ContentType.objects.get_for_model(obj)

count = models.EventRef.objects.filter(object_id=obj.id,object_type=object_type).count()

event_ref = models.EventRef(private=private,

referenced_by=obj,

ref_object=event,

order=count + 1,

role_type = models.get_type(models.EventRoleType, role))

event_ref.save()

self.add_note_list(event_ref, note_list)

self.add_attribute_list(event_ref, attribute_list)

"""

def add_repository_ref_default(self, obj, repository, private=False, call_number="",

source_media_type=models.SourceMediaType._DEFAULT):

object_type = ContentType.objects.get_for_model(obj)

count = models.RepositoryRef.objects.filter(object_id=obj.id,object_type=object_type).count()

repos_ref = models.RepositoryRef(private=private,

referenced_by=obj,

call_number=call_number,

source_media_type=models.get_type(models.SourceMediaType,

source_media_type),

ref_object=repository,

order=count + 1)

repos_ref.save()

"""

def add_repository_ref(self, obj, reporef_data):

(note_list,

ref,

call_number,

source_media_type,

private) = reporef_data

try:

repository = models.Repository.objects.get(handle=ref)

except:

print(("ERROR: Repository does not exist: '%s'" %

ref), file=sys.stderr)

return

object_type = ContentType.objects.get_for_model(obj)

count = models.RepositoryRef.objects.filter(object_id=obj.id,object_type=object_type).count()

repos_ref = models.RepositoryRef(private=private,

referenced_by=obj,

call_number=call_number,

source_media_type=models.get_type(models.SourceMediaType,

source_media_type),

ref_object=repository,

order=count + 1)

repos_ref.save()

self.add_note_list(repos_ref, note_list)

def add_family_ref(self, obj, handle):

try:

family = models.Family.objects.get(handle=handle)

except:

print(("ERROR: Family does not exist: '%s'" %

handle), file=sys.stderr)

return

#obj.families.add(family)

pfo = models.MyFamilies(person=obj, family=family,

order=len(models.MyFamilies.objects.filter(person=obj)) + 1)

pfo.save()

obj.save()

## Export individual objects:

def add_source_datamap_dict(self, source, datamap_dict):

count = 1

for key in datamap_dict:

value = datamap_dict[key]

datamap = models.SourceDatamap(key=key, value=value, order=count)

datamap.source = source

datamap.save()

count += 1

def add_citation_datamap_dict(self, citation, datamap_dict):

count = 1

for key in datamap_dict:

value = datamap_dict[key]

datamap = models.CitationDatamap(key=key, value=value, order=count)

datamap.citation = citation

datamap.save()

count += 1

def add_lds(self, field, obj, data, order):

(lcitation_list, lnote_list, date, type, place_handle,

famc_handle, temple, status, private) = data

if place_handle:

try:

place = models.Place.objects.get(handle=place_handle)

except:

print(("ERROR: Place does not exist: '%s'" %

place_handle), file=sys.stderr)

place = None

else:

place = None

if famc_handle:

try:

famc = models.Family.objects.get(handle=famc_handle)

except:

print(("ERROR: Family does not exist: '%s'" %

famc_handle), file=sys.stderr)

famc = None

else:

famc = None

lds = models.Lds(lds_type = models.get_type(models.LdsType, type),

temple=temple,

place=place,

famc=famc,

order=order,

status = models.get_type(models.LdsStatus, status),

private=private)

self.add_date(lds, date)

lds.save()

self.add_note_list(lds, lnote_list)

self.add_citation_list(lds, lcitation_list)

if field == "person":

lds.person = obj

elif field == "family":

lds.family = obj

else:

raise AttributeError("invalid field '%s' to attach lds" %

field)

lds.save()

return lds

def add_address(self, field, obj, address_data, order):

(private, acitation_list, anote_list, date, location) = address_data

address = models.Address(private=private, order=order)

self.add_date(address, date)

address.save()

self.add_location("address", address, location, 1)

self.add_note_list(address, anote_list)

self.add_citation_list(address, acitation_list)

if field == "person":

address.person = obj

elif field == "repository":

address.repository = obj

else:

raise AttributeError("invalid field '%s' to attach address" %

field)

address.save()

#obj.save()

#obj.addresses.add(address)

#obj.save()

def add_attribute(self, obj, attribute_data):

(private, citation_list, note_list, the_type, value) = attribute_data

attribute_type = models.get_type(models.AttributeType, the_type)

attribute = models.Attribute(private=private,

attribute_of=obj,

attribute_type=attribute_type,

value=value)

attribute.save()

self.add_citation_list(attribute, citation_list)

self.add_note_list(attribute, note_list)

#obj.attributes.add(attribute)

#obj.save()

def add_url(self, field, obj, url_data, order):

(private, path, desc, type) = url_data

url = models.Url(private=private,

path=path,

desc=desc,

order=order,

url_type=models.get_type(models.UrlType, type))

if field == "person":

url.person = obj

elif field == "repository":

url.repository = obj

elif field == "place":

url.place = obj

else:

raise AttributeError("invalid field '%s' to attach to url" %

field)

url.save()

#obj.url_list.add(url)

#obj.save()

def add_place_ref(self, event, place_handle):

if place_handle:

try:

place = models.Place.objects.get(handle=place_handle)

except:

print(("ERROR: Place does not exist: '%s'" %

place_handle), file=sys.stderr)

return

event.place = place

event.save()

def add_parent_family(self, person, parent_family_handle):

try:

family = models.Family.objects.get(handle=parent_family_handle)

except:

print(("ERROR: Family does not exist: '%s'" %

parent_family_handle), file=sys.stderr)

return

#person.parent_families.add(family)

pfo = models.MyParentFamilies(person=person, family=family,

order=len(models.MyParentFamilies.objects.filter(person=person)) + 1)

pfo.save()

person.save()

def add_date(self, obj, date):

"""

Uzywane obecnie

"""

if date is None:

(calendar, modifier, quality, text, sortval, newyear) = \

(0, 0, 0, "", 0, 0)

day1, month1, year1, slash1 = 0, 0, 0, 0

day2, month2, year2, slash2 = 0, 0, 0, 0

else:

(calendar, modifier, quality, dateval, text, sortval, newyear) = date

if len(dateval) == 4:

day1, month1, year1, slash1 = dateval

day2, month2, year2, slash2 = 0, 0, 0, 0

elif len(dateval) == 8:

day1, month1, year1, slash1, day2, month2, year2, slash2 = dateval

else:

raise AttributeError("ERROR: dateval format '%s'" % dateval)

obj.calendar = calendar

obj.modifier = modifier

obj.quality = quality

obj.text = text

obj.sortval = sortval

obj.newyear = newyear

obj.day1 = day1

obj.month1 = month1

obj.year1 = year1

obj.slash1 = slash1

obj.day2 = day2

obj.month2 = month2

obj.year2 = year2

obj.slash2 = slash2

def add_name(self, person, data, preferred):

if data:

(private, citation_list, note_list, date,

first_name, surname_list, suffix, title,

name_type, group_as, sort_as,

display_as, call, nick, famnick) = data

person.first_name = first_name

person.save()

"""

count = person.name_set.count()

name = models.Name()

name.order = count + 1

name.preferred = preferred

name.private = private

name.first_name = first_name

name.suffix = suffix

name.title = title

name.name_type = models.get_type(models.NameType, name_type)

name.group_as = group_as

name.sort_as = models.get_type(models.NameFormatType, sort_as)

name.display_as = models.get_type(models.NameFormatType, display_as)

name.call = call

name.nick = nick

name.famnick = famnick

# we know person exists

# needs to have an ID for key

name.person = person

self.add_date(name, date)

name.save()

self.add_surname_list(name, surname_list)

self.add_note_list(name, note_list)

self.add_citation_list(name, citation_list)

#person.save()

"""

## Export primary objects:

def add_location(self, field, obj, location_data, order):

# location now has 8 items

# street, locality, city, county, state,

# country, postal, phone, parish

if location_data == None: return

if len(location_data) == 8:

(street, locality, city, county, state, country, postal, phone) = location_data

parish = None

elif len(location_data) == 2:

((street, locality, city, county, state, country, postal, phone), parish) = location_data

else:

print(("ERROR: unknown location: '%s'" %

location_data), file=sys.stderr)

(street, locality, city, county, state, country, postal, phone, parish) = \

("", "", "", "", "", "", "", "", "")

location = models.Location(street = street,

locality = locality,

city = city,

county = county,

state = state,

country = country,

postal = postal,

phone = phone,

parish = parish,

order = order)

if field == "address":

location.address = obj

elif field == "place":

location.place = obj

else:

raise AttributeError("invalid field '%s' to attach to location" %

field)

location.save()

#obj.locations.add(location)

#obj.save()

def add_tag_detail(self, data):

(handle,

name,

color,

priority,

change) = data

tag = models.Tag.objects.get(handle=handle)

tag.cache = self.encode_raw(data)

tag.save()

def add_tag(self, data):

(handle,

name,

color,

priority,

change) = data

tag = models.Tag(handle=handle,

gramps_id=create_id(),

name=name,

color=color,

priority=priority,

last_changed=todate(change))

tag.save()

def encode_raw(self, raw):

return base64.encodestring(pickle.dumps(raw))