Very close to having the SQL import/export done
svn: r12930
This commit is contained in:
Doug Blank
parent
6c07dfc9dd
commit
78530fae2e
@ -40,6 +40,9 @@ import ExportOptions
|
||||
from Utils import create_id
|
||||
|
||||
def lookup(index, event_ref_list):
|
||||
"""
|
||||
Get the unserialized event_ref in an list of them and return it.
|
||||
"""
|
||||
if index < 0:
|
||||
return None
|
||||
else:
|
||||
@ -71,9 +74,10 @@ def makeDB(db):
|
||||
db.query("""drop table lds;""")
|
||||
db.query("""drop table media_ref;""")
|
||||
db.query("""drop table address;""")
|
||||
db.query("""drop table location;""")
|
||||
db.query("""drop table attribute;""")
|
||||
db.query("""drop table url;""")
|
||||
# Completed
|
||||
|
||||
db.query("""CREATE TABLE note (
|
||||
handle CHARACTER(25),
|
||||
gid CHARACTER(25),
|
||||
@ -85,9 +89,8 @@ def makeDB(db):
|
||||
marker0 INTEGER,
|
||||
marker1 TEXT,
|
||||
private BOOLEAN);""")
|
||||
|
||||
|
||||
db.query("""CREATE TABLE name (
|
||||
from_handle CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
primary_name BOOLEAN,
|
||||
private BOOLEAN,
|
||||
@ -105,8 +108,7 @@ def makeDB(db):
|
||||
call TEXT);""")
|
||||
|
||||
db.query("""CREATE TABLE date (
|
||||
from_type CHARACTER(25),
|
||||
from_handle CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
calendar INTEGER,
|
||||
modifier INTEGER,
|
||||
quality INTEGER,
|
||||
@ -149,6 +151,7 @@ def makeDB(db):
|
||||
handle CHARACTER(25),
|
||||
gid CHARACTER(25),
|
||||
title TEXT,
|
||||
main_location CHARACTER(25),
|
||||
long FLOAT,
|
||||
lat FLOAT,
|
||||
change INTEGER,
|
||||
@ -168,7 +171,6 @@ def makeDB(db):
|
||||
private BOOLEAN);""")
|
||||
|
||||
db.query("""CREATE TABLE source (
|
||||
from_type CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
gid CHARACTER(25),
|
||||
title TEXT,
|
||||
@ -202,6 +204,7 @@ def makeDB(db):
|
||||
marker1 TEXT,
|
||||
private BOOLEAN);""")
|
||||
|
||||
# One link to link them all
|
||||
db.query("""CREATE TABLE link (
|
||||
from_type CHARACTER(25),
|
||||
from_handle CHARACTER(25),
|
||||
@ -216,22 +219,18 @@ def makeDB(db):
|
||||
start_stop_list TEXT);""")
|
||||
|
||||
db.query("""CREATE TABLE event_ref (
|
||||
from_type CHARACTER(25),
|
||||
from_handle CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
ref CHARACTER(25),
|
||||
role0 INTEGER,
|
||||
role1 TEXT,
|
||||
private BOOLEAN);""")
|
||||
|
||||
db.query("""CREATE TABLE person_ref (
|
||||
from_type CHARACTER(25),
|
||||
from_handle CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
description TEXT,
|
||||
private BOOLEAN);""")
|
||||
|
||||
db.query("""CREATE TABLE source_ref (
|
||||
type CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
ref CHARACTER(25),
|
||||
confidence INTEGER,
|
||||
@ -239,8 +238,7 @@ def makeDB(db):
|
||||
private BOOLEAN);""")
|
||||
|
||||
db.query("""CREATE TABLE child_ref (
|
||||
from_type CHARACTER(25),
|
||||
from_handle CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
ref CHARACTER(25),
|
||||
frel0 INTEGER,
|
||||
frel1 CHARACTER(25),
|
||||
@ -249,11 +247,9 @@ def makeDB(db):
|
||||
private BOOLEAN);""")
|
||||
|
||||
db.query("""CREATE TABLE lds (
|
||||
from_type CHARACTER(25),
|
||||
from_handle CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
type CHARACTER(25),
|
||||
place TEXT,
|
||||
place CHARACTER(25),
|
||||
famc CHARACTER(25),
|
||||
temple TEXT,
|
||||
status TEXT,
|
||||
@ -262,12 +258,15 @@ def makeDB(db):
|
||||
db.query("""CREATE TABLE media_ref (
|
||||
handle CHARACTER(25),
|
||||
ref CHARACTER(25),
|
||||
role TEXT,
|
||||
role0 INTEGER,
|
||||
role1 TEXT,
|
||||
private BOOLEAN);""")
|
||||
|
||||
db.query("""CREATE TABLE address (
|
||||
from_type CHARACTER(25),
|
||||
from_handle CHARACTER(25),
|
||||
handle CHARACTER(25),
|
||||
private BOOLEAN);""")
|
||||
|
||||
db.query("""CREATE TABLE location (
|
||||
handle CHARACTER(25),
|
||||
street TEXT,
|
||||
city TEXT,
|
||||
@ -276,22 +275,21 @@ def makeDB(db):
|
||||
country TEXT,
|
||||
postal TEXT,
|
||||
phone TEXT,
|
||||
parish TEXT,
|
||||
private BOOLEAN);""")
|
||||
parish TEXT);""")
|
||||
|
||||
db.query("""CREATE TABLE attribute (
|
||||
handle CHARACTER(25),
|
||||
from_type CHARACTER(25),
|
||||
from_handle CHARACTER(25),
|
||||
the_type0 INTEGER,
|
||||
the_type1 TEXT,
|
||||
value TEXT,
|
||||
private BOOLEAN);""")
|
||||
|
||||
db.query("""CREATE TABLE url (
|
||||
handle CHARACTER(25),
|
||||
path TEXT,
|
||||
desc TXT,
|
||||
type CHARACTER(1),
|
||||
type0 INTEGER,
|
||||
type1 TEXT,
|
||||
private BOOLEAN);
|
||||
""")
|
||||
|
||||
@ -326,23 +324,31 @@ class Database(object):
|
||||
self.cursor.close()
|
||||
self.db.close()
|
||||
|
||||
def export_place(db, from_type, from_handle, place_handle):
|
||||
export_link(db, from_type, from_handle, "place", place_handle)
|
||||
def export_location_list(db, from_type, from_handle, locations):
|
||||
for location in locations:
|
||||
export_location(db, from_type, from_handle, location)
|
||||
|
||||
def export_url_list(db, from_type, handle, urls):
|
||||
def export_url_list(db, from_type, from_handle, urls):
|
||||
for url in urls:
|
||||
# (False, u'http://www.gramps-project.org/', u'loleach', (0, u'kaabgo'))
|
||||
private, path, desc, type = url
|
||||
(private, path, desc, type) = url
|
||||
handle = create_id()
|
||||
db.query("""insert INTO url (
|
||||
handle,
|
||||
path,
|
||||
desc,
|
||||
type,
|
||||
private) VALUES (?, ?, ?, ?);
|
||||
type0,
|
||||
type1,
|
||||
private) VALUES (?, ?, ?, ?, ?, ?);
|
||||
""",
|
||||
handle,
|
||||
path,
|
||||
desc,
|
||||
type[0],
|
||||
type[1],
|
||||
private)
|
||||
# finally, link this to parent
|
||||
export_link(db, from_type, from_handle, "url", handle)
|
||||
|
||||
def export_person_ref_list(db, from_type, from_handle, person_ref_list):
|
||||
for person_ref in person_ref_list:
|
||||
@ -352,76 +358,53 @@ def export_person_ref_list(db, from_type, from_handle, person_ref_list):
|
||||
handle,
|
||||
desc) = person_ref
|
||||
db.query("""INSERT INTO person_ref (
|
||||
from_type,
|
||||
from_handle,
|
||||
handle,
|
||||
description,
|
||||
private) VALUES (?, ?, ?, ?, ?);""",
|
||||
from_type,
|
||||
from_handle,
|
||||
private) VALUES (?, ?, ?);""",
|
||||
handle,
|
||||
desc,
|
||||
private
|
||||
)
|
||||
export_list(db, "person_ref", handle, "note", note_list)
|
||||
export_source_list(db, "person_ref", handle, source_list)
|
||||
export_source_ref_list(db, "person_ref", handle, source_list)
|
||||
# And finally, make a link from parent to new object
|
||||
export_link(db, from_type, from_handle, "person_ref", handle)
|
||||
|
||||
|
||||
def export_event_ref(db, from_type, from_handle, ref, role, private):
|
||||
db.query("""insert INTO event_ref (
|
||||
from_type,
|
||||
from_handle,
|
||||
ref,
|
||||
role0,
|
||||
role1,
|
||||
private) VALUES (?, ?, ?,?,?,?);""",
|
||||
from_type,
|
||||
from_handle,
|
||||
ref,
|
||||
role[0],
|
||||
role[1],
|
||||
private)
|
||||
|
||||
def export_markup(db, handle, markup_code0, markup_code1, value,
|
||||
start_stop_list):
|
||||
db.query("""INSERT INTO markup (
|
||||
handle,
|
||||
markup0,
|
||||
markup1,
|
||||
value,
|
||||
start_stop_list) VALUES (?,?,?,?,?);""",
|
||||
handle, markup_code0, markup_code1, value,
|
||||
start_stop_list)
|
||||
|
||||
def export_lds(db, from_type, from_handle, handle, type, place, famc, temple, status, private):
|
||||
db.query("""INSERT into lds (from_type, from_handle, handle, type, place, famc, temple, status, private)
|
||||
VALUES (?,?,?,?,?,?,?,?,?);""",
|
||||
from_type, from_handle, handle, type, place, famc, temple, status, private)
|
||||
# FIXME: remove place from here?
|
||||
def export_lds(db, from_type, from_handle, data):
|
||||
(lsource_list, lnote_list, date, type, place,
|
||||
famc, temple, status, private) = data
|
||||
lds_handle = create_id()
|
||||
db.query("""INSERT into lds (handle, type, place, famc, temple, status, private)
|
||||
VALUES (?,?,?,?,?,?,?);""",
|
||||
lds_handle, type, place, famc, temple, status, private)
|
||||
export_link(db, "lds", lds_handle, "place", place)
|
||||
export_list(db, "lds", lds_handle, "note", lnote_list)
|
||||
export_date(db, "lds", lds_handle, date)
|
||||
export_source_ref_list(db, "lds", lds_handle, lsource_list)
|
||||
# And finally, make a link from parent to new object
|
||||
export_link(db, from_type, from_handle, "lds", lds_handle)
|
||||
|
||||
def export_media_ref(db, handle, ref, role, private):
|
||||
db.query("""INSERT into media_ref (
|
||||
handle,
|
||||
ref,
|
||||
role,
|
||||
private) VALUES (?,?,?,?);""",
|
||||
handle, ref, str(role), private) # FIXME: role with two parts
|
||||
|
||||
def export_source_ref(db, from_type, handle, ref, private, confidence, page):
|
||||
def export_source_ref(db, from_type, from_handle, source):
|
||||
(date, private, note_list, confidence, ref, page) = source
|
||||
handle = create_id()
|
||||
# handle is source_ref handle
|
||||
# ref is source handle
|
||||
db.query("""INSERT into source_ref (
|
||||
type,
|
||||
handle,
|
||||
ref,
|
||||
confidence,
|
||||
page,
|
||||
private
|
||||
) VALUES (?, ?,?,?,?,?);""",
|
||||
from_type,
|
||||
) VALUES (?,?,?,?,?);""",
|
||||
handle,
|
||||
ref,
|
||||
confidence,
|
||||
page,
|
||||
private)
|
||||
export_date(db, "source_ref", handle, date)
|
||||
export_list(db, "source_ref", handle, "note", note_list)
|
||||
# And finally, make a link from parent to new object
|
||||
export_link(db, from_type, from_handle, "source_ref", handle)
|
||||
|
||||
def export_source(db, handle, gid, title, author, pubinfo, abbrev, change,
|
||||
marker0, marker1, private):
|
||||
@ -448,9 +431,12 @@ def export_source(db, handle, gid, title, author, pubinfo, abbrev, change,
|
||||
marker1,
|
||||
private)
|
||||
|
||||
def export_note(db, handle, gid, text, format, note_type0,
|
||||
note_type1, change, marker0, marker1, private):
|
||||
db.query("""INSERT into note (handle,
|
||||
def export_note(db, data):
|
||||
(handle, gid, styled_text, format, note_type,
|
||||
change, marker, private) = data
|
||||
text, markup_list = styled_text
|
||||
db.query("""INSERT into note (
|
||||
handle,
|
||||
gid,
|
||||
text,
|
||||
format,
|
||||
@ -461,18 +447,193 @@ def export_note(db, handle, gid, text, format, note_type0,
|
||||
marker1,
|
||||
private) values (?, ?, ?, ?, ?,
|
||||
?, ?, ?, ?, ?);""",
|
||||
handle, gid, text, format, note_type0,
|
||||
note_type1, change, marker0, marker1, private)
|
||||
handle, gid, text, format, note_type[0],
|
||||
note_type[1], change, marker[0], marker[1], private)
|
||||
for markup in markup_list:
|
||||
markup_code, value, start_stop_list = markup
|
||||
export_markup(db, "note", handle, markup_code[0], markup_code[1], value,
|
||||
str(start_stop_list)) # Not normal form; use eval
|
||||
|
||||
def export_name(db, from_handle, handle, primary, data):
|
||||
def export_markup(db, from_type, from_handle, markup_code0, markup_code1, value,
|
||||
start_stop_list):
|
||||
markup_handle = create_id()
|
||||
db.query("""INSERT INTO markup (
|
||||
handle,
|
||||
markup0,
|
||||
markup1,
|
||||
value,
|
||||
start_stop_list) VALUES (?,?,?,?,?);""",
|
||||
markup_handle, markup_code0, markup_code1, value,
|
||||
start_stop_list)
|
||||
# And finally, make a link from parent to new object
|
||||
export_link(db, from_type, from_handle, "markup", markup_handle)
|
||||
|
||||
def export_event(db, data):
|
||||
(handle, gid, the_type, date, description, place_handle,
|
||||
source_list, note_list, media_list, attribute_list,
|
||||
change, marker, private) = data
|
||||
db.query("""INSERT INTO event (
|
||||
handle,
|
||||
gid,
|
||||
the_type0,
|
||||
the_type1,
|
||||
description,
|
||||
change,
|
||||
marker0,
|
||||
marker1,
|
||||
private) VALUES (?,?,?,?,?,?,?,?,?);""",
|
||||
handle,
|
||||
gid,
|
||||
the_type[0],
|
||||
the_type[1],
|
||||
description,
|
||||
change,
|
||||
marker[0],
|
||||
marker[1],
|
||||
private)
|
||||
export_date(db, "event", handle, date)
|
||||
export_link(db, "event", handle, "place", place_handle)
|
||||
export_list(db, "event", handle, "note", note_list)
|
||||
export_attribute_list(db, "event", handle, attribute_list)
|
||||
export_media_ref_list(db, "event", handle, media_list)
|
||||
export_source_ref_list(db, "event", handle, source_list)
|
||||
|
||||
def export_event_ref(db, from_type, from_handle, event_ref):
|
||||
(private, note_list, attribute_list, ref, role) = event_ref
|
||||
handle = create_id()
|
||||
db.query("""insert INTO event_ref (
|
||||
handle,
|
||||
ref,
|
||||
role0,
|
||||
role1,
|
||||
private) VALUES (?,?,?,?,?);""",
|
||||
handle,
|
||||
ref,
|
||||
role[0],
|
||||
role[1],
|
||||
private)
|
||||
export_list(db, "event_ref", handle, "note", note_list)
|
||||
export_attribute_list(db, "event_ref", handle, attribute_list)
|
||||
# finally, link this to parent
|
||||
export_link(db, from_type, from_handle, "event_ref", handle)
|
||||
|
||||
def export_person(db, person):
|
||||
(handle, # 0
|
||||
gid, # 1
|
||||
gender, # 2
|
||||
primary_name, # 3
|
||||
alternate_names, # 4
|
||||
death_ref_index, # 5
|
||||
birth_ref_index, # 6
|
||||
event_ref_list, # 7
|
||||
family_list, # 8
|
||||
parent_family_list, # 9
|
||||
media_list, # 10
|
||||
address_list, # 11
|
||||
attribute_list, # 12
|
||||
urls, # 13
|
||||
lds_ord_list, # 14
|
||||
psource_list, # 15
|
||||
pnote_list, # 16
|
||||
change, # 17
|
||||
marker, # 18
|
||||
private, # 19
|
||||
person_ref_list, # 20
|
||||
) = person
|
||||
db.query("""INSERT INTO person (
|
||||
handle,
|
||||
gid,
|
||||
gender,
|
||||
death_ref_handle,
|
||||
birth_ref_handle,
|
||||
change,
|
||||
marker0,
|
||||
marker1,
|
||||
private) values (?, ?, ?, ?, ?, ?, ?, ?, ?);""",
|
||||
handle,
|
||||
gid,
|
||||
gender,
|
||||
lookup(death_ref_index, event_ref_list),
|
||||
lookup(birth_ref_index, event_ref_list),
|
||||
change,
|
||||
marker[0],
|
||||
marker[1],
|
||||
private)
|
||||
|
||||
# Event Reference information
|
||||
for event_ref in event_ref_list:
|
||||
export_event_ref(db, "person", handle, event_ref)
|
||||
export_list(db, "person", handle, "family", family_list)
|
||||
export_list(db, "person", handle, "parent_family", parent_family_list)
|
||||
export_media_ref_list(db, "person", handle, media_list)
|
||||
export_list(db, "person", handle, "note", pnote_list)
|
||||
export_attribute_list(db, "person", handle, attribute_list)
|
||||
export_url_list(db, "person", handle, urls)
|
||||
export_person_ref_list(db, "person", handle, person_ref_list)
|
||||
export_source_ref_list(db, "person", handle, psource_list)
|
||||
|
||||
# -------------------------------------
|
||||
# Address
|
||||
# -------------------------------------
|
||||
for address in address_list:
|
||||
export_address(db, "person", handle, address)
|
||||
|
||||
# -------------------------------------
|
||||
# LDS ord
|
||||
# -------------------------------------
|
||||
for ldsord in lds_ord_list:
|
||||
export_lds(db, "person", handle, ldsord)
|
||||
|
||||
# -------------------------------------
|
||||
# Names
|
||||
# -------------------------------------
|
||||
export_name(db, "person", handle, True, primary_name)
|
||||
map(lambda name: export_name(db, "person", handle, False, name),
|
||||
alternate_names)
|
||||
|
||||
def export_date(db, from_type, from_handle, data):
|
||||
if data is None: return
|
||||
(calendar, modifier, quality, dateval, text, sortval, newyear) = data
|
||||
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 ("ERROR: date dateval format", dateval)
|
||||
date_handle = create_id()
|
||||
db.query("""INSERT INTO date (
|
||||
handle,
|
||||
calendar,
|
||||
modifier,
|
||||
quality,
|
||||
day1,
|
||||
month1,
|
||||
year1,
|
||||
slash1,
|
||||
day2,
|
||||
month2,
|
||||
year2,
|
||||
slash2,
|
||||
text,
|
||||
sortval,
|
||||
newyear) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,
|
||||
?, ?, ?, ?, ?, ?);""",
|
||||
date_handle, calendar, modifier, quality,
|
||||
day1, month1, year1, slash1,
|
||||
day2, month2, year2, slash2,
|
||||
text, sortval, newyear)
|
||||
# And finally, make a link from parent to new object
|
||||
export_link(db, from_type, from_handle, "date", date_handle)
|
||||
|
||||
def export_name(db, from_type, from_handle, primary, data):
|
||||
if data:
|
||||
(private, source_list, note_list, date,
|
||||
first_name, surname, suffix, title,
|
||||
name_type, prefix, patronymic,
|
||||
group_as, sort_as, display_as, call) = data
|
||||
|
||||
handle = create_id()
|
||||
db.query("""INSERT into name (
|
||||
from_handle,
|
||||
handle,
|
||||
primary_name,
|
||||
private,
|
||||
@ -488,98 +649,78 @@ def export_name(db, from_handle, handle, primary, data):
|
||||
sort_as,
|
||||
display_as,
|
||||
call
|
||||
) values (?, ?, ?, ?, ?, ?, ?, ?, ?,
|
||||
) values (?, ?, ?, ?, ?, ?, ?, ?,
|
||||
?, ?, ?, ?, ?, ?, ?);""",
|
||||
from_handle, handle, primary, private, first_name, surname, suffix, title,
|
||||
handle, primary, private, first_name, surname, suffix, title,
|
||||
name_type[0], name_type[1], prefix, patronymic, group_as,
|
||||
sort_as, display_as, call)
|
||||
|
||||
if date:
|
||||
export_date(db, "name", handle, date)
|
||||
export_date(db, "name", handle, date)
|
||||
export_list(db, "name", handle, "note", note_list)
|
||||
export_source_list(db, "name", handle, source_list)
|
||||
export_source_ref_list(db, "name", handle, source_list)
|
||||
# And finally, make a link from parent to new object
|
||||
export_link(db, from_type, from_handle, "name", handle)
|
||||
|
||||
def export_date(db, date_type, handle, date):
|
||||
if True:
|
||||
(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 ("ERROR:", dateval)
|
||||
db.query("""INSERT INTO date (
|
||||
from_type,
|
||||
from_handle,
|
||||
calendar,
|
||||
modifier,
|
||||
quality,
|
||||
day1,
|
||||
month1,
|
||||
year1,
|
||||
slash1,
|
||||
day2,
|
||||
month2,
|
||||
year2,
|
||||
slash2,
|
||||
text,
|
||||
sortval,
|
||||
newyear) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,
|
||||
?, ?, ?, ?, ?, ?, ?);""",
|
||||
date_type, handle, calendar, modifier, quality,
|
||||
day1, month1, year1, slash1,
|
||||
day2, month2, year2, slash2,
|
||||
text, sortval, newyear)
|
||||
|
||||
def export_attribute(db, from_type, from_handle, attr_handle, the_type, value, private):
|
||||
def export_attribute(db, from_type, from_handle, attribute):
|
||||
(private, source_list, note_list, the_type, value) = attribute
|
||||
handle = create_id()
|
||||
db.query("""INSERT INTO attribute (
|
||||
handle,
|
||||
from_type,
|
||||
from_handle,
|
||||
the_type0,
|
||||
the_type1,
|
||||
value,
|
||||
private) VALUES (?,?,?,?,?,?,?);""",
|
||||
attr_handle, from_type, from_handle, the_type[0], the_type[1], value, private)
|
||||
private) VALUES (?,?,?,?,?);""",
|
||||
handle, the_type[0], the_type[1], value, private)
|
||||
export_source_ref_list(db, "attribute", handle, source_list)
|
||||
export_list(db, "attribute", handle, "note", note_list)
|
||||
# finally, link the parent to the address
|
||||
export_link(db, from_type, from_handle, "attribute", handle)
|
||||
|
||||
def export_source_list(db, from_type, handle, source_list):
|
||||
# Event Sources
|
||||
def export_source_ref_list(db, from_type, from_handle, source_list):
|
||||
for source in source_list:
|
||||
(date, private, note_list, confidence, ref, page) = source
|
||||
export_source_ref(db, from_type, handle, ref, private, confidence, page)
|
||||
if date:
|
||||
export_date(db, "source", ref, date)
|
||||
export_list(db, "source", ref, "note", note_list)
|
||||
export_source_ref(db, from_type, from_handle, source)
|
||||
|
||||
def export_media_list(db, from_type, from_handle, media_list):
|
||||
# Media list
|
||||
def export_media_ref_list(db, from_type, from_handle, media_list):
|
||||
for media in media_list:
|
||||
(private, source_list, note_list,attribute_list,ref,role) = media
|
||||
export_media_ref(db, from_handle, ref, role, private)
|
||||
export_list(db, "media", ref, "note", note_list)
|
||||
export_attribute_list(db, "media", ref, attribute_list)
|
||||
export_media_ref(db, from_type, from_handle, media)
|
||||
|
||||
def export_attribute_list(db, from_type, from_handle, attribute_list):
|
||||
for attribute in attribute_list:
|
||||
(private, source_list, note_list, the_type, value) = attribute
|
||||
attr_handle = create_id()
|
||||
export_attribute(db, from_type, from_handle, attr_handle, the_type, value, private)
|
||||
export_list(db, "attribute", attr_handle, "note", note_list)
|
||||
export_source_list(db, "atribute", attr_handle, source_list)
|
||||
def export_media_ref(db, from_type, from_handle, media):
|
||||
(private, source_list, note_list, attribute_list, ref, role) = media
|
||||
# handle is the media_ref handle
|
||||
# ref is the media handle
|
||||
handle = create_id()
|
||||
if role is None:
|
||||
role = (-1, '')
|
||||
db.query("""INSERT into media_ref (
|
||||
handle,
|
||||
ref,
|
||||
role0,
|
||||
role1,
|
||||
private) VALUES (?,?,?,?,?);""",
|
||||
handle, ref, role[0], role[1] ,private)
|
||||
export_list(db, "media_ref", handle, "note", note_list)
|
||||
export_attribute_list(db, "media_ref", handle, attribute_list)
|
||||
# And finally, make a link from parent to new object
|
||||
export_link(db, from_type, from_handle, "media_ref", handle)
|
||||
|
||||
def export_attribute_list(db, from_type, from_handle, attr_list):
|
||||
for attribute in attr_list:
|
||||
export_attribute(db, from_type, from_handle, attribute)
|
||||
|
||||
def export_child_ref_list(db, from_type, from_handle, to_type, ref_list):
|
||||
for child_ref in ref_list:
|
||||
# family -> child_ref
|
||||
# (False, [], [], u'b305e96e39652d8f08c', (1, u''), (1, u''))
|
||||
(private, source_list, note_list, ref, frel, mrel) = child_ref
|
||||
db.query("""INSERT INTO child_ref (from_type, from_handle,
|
||||
handle = create_id()
|
||||
db.query("""INSERT INTO child_ref (handle,
|
||||
ref, frel0, frel1, mrel0, mrel1, private)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?);""",
|
||||
from_type, from_handle, ref, frel[0], frel[1],
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?);""",
|
||||
handle, ref, frel[0], frel[1],
|
||||
mrel[0], mrel[1], private)
|
||||
export_source_list(db, from_type, ref, source_list)
|
||||
export_list(db, from_type, ref, "note", note_list)
|
||||
export_source_ref_list(db, from_type, handle, source_list)
|
||||
export_list(db, from_type, handle, "note", note_list)
|
||||
# And finally, make a link from parent to new object
|
||||
export_link(db, from_type, from_handle, "child_ref", handle)
|
||||
|
||||
def export_list(db, from_type, from_handle, to_type, handle_list):
|
||||
for to_handle in handle_list:
|
||||
@ -593,11 +734,30 @@ def export_link(db, from_type, from_handle, to_type, to_handle):
|
||||
to_handle) values (?, ?, ?, ?)""",
|
||||
from_type, from_handle, to_type, to_handle)
|
||||
|
||||
def export_address(db, from_type, from_handle, handle, street, city, county,
|
||||
state, country, postal, phone, private, parish=None):
|
||||
|
||||
def export_address(db, from_type, from_handle, address):
|
||||
(private, asource_list, anote_list, date, location) = address
|
||||
addr_handle = create_id()
|
||||
db.query("""INSERT INTO address (
|
||||
from_type,
|
||||
from_handle,
|
||||
handle,
|
||||
private) VALUES (?, ?);""", addr_handle, private)
|
||||
export_location(db, "address", addr_handle, location)
|
||||
export_date(db, "address", addr_handle, date)
|
||||
export_list(db, "address", addr_handle, "note", anote_list)
|
||||
export_source_ref_list(db, "address", addr_handle, asource_list)
|
||||
# finally, link the parent to the address
|
||||
export_link(db, from_type, from_handle, "address", addr_handle)
|
||||
|
||||
def export_location(db, from_type, from_handle, location):
|
||||
if len(location) == 7:
|
||||
(street, city, county, state, country, postal, phone) = location
|
||||
parish = None
|
||||
elif len(location) == 2:
|
||||
((street, city, county, state, country, postal, phone), parish) = location
|
||||
else:
|
||||
print "ERROR: what kind of location is this?", location
|
||||
handle = create_id()
|
||||
db.query("""INSERT INTO location (
|
||||
handle,
|
||||
street,
|
||||
city,
|
||||
@ -606,10 +766,10 @@ def export_address(db, from_type, from_handle, handle, street, city, county,
|
||||
country,
|
||||
postal,
|
||||
phone,
|
||||
parish,
|
||||
private) VALUES (?, ?, ?,?,?,?,?,?,?,?,?,?);""",
|
||||
from_type, from_handle, handle, street, city, county, state, country, postal, phone, parish, private)
|
||||
|
||||
parish) VALUES (?,?,?,?,?,?,?,?,?);""",
|
||||
handle, street, city, county, state, country, postal, phone, parish)
|
||||
# finally, link the parent to the address
|
||||
export_link(db, from_type, from_handle, "location", handle)
|
||||
|
||||
def exportData(database, filename, option_box=None, callback=None):
|
||||
if not callable(callback):
|
||||
@ -632,16 +792,8 @@ def exportData(database, filename, option_box=None, callback=None):
|
||||
# Notes
|
||||
# ---------------------------------
|
||||
for note_handle in database.note_map.keys():
|
||||
note = database.note_map[note_handle]
|
||||
(handle, gid, styled_text, format, note_type,
|
||||
change, marker, private) = note
|
||||
text, markup_list = styled_text
|
||||
export_note(db, handle, gid, text, format, note_type[0],
|
||||
note_type[1], change, marker[0], marker[1], private)
|
||||
for markup in markup_list:
|
||||
markup_code, value, start_stop_list = markup
|
||||
export_markup(db, handle, markup_code[0], markup_code[1], value,
|
||||
str(start_stop_list)) # Not normal form; use eval
|
||||
data = database.note_map[note_handle]
|
||||
export_note(db, data)
|
||||
count += 1
|
||||
callback(100 * count/total)
|
||||
|
||||
@ -649,39 +801,8 @@ def exportData(database, filename, option_box=None, callback=None):
|
||||
# Event
|
||||
# ---------------------------------
|
||||
for event_handle in database.event_map.keys():
|
||||
event = database.event_map[event_handle]
|
||||
(handle, gid, the_type, date, description, place,
|
||||
source_list, note_list, media_list, attribute_list,
|
||||
change, marker, private) = event
|
||||
if date:
|
||||
export_date(db, "event", event_handle, date)
|
||||
db.query("""INSERT INTO event (
|
||||
handle,
|
||||
gid,
|
||||
the_type0,
|
||||
the_type1,
|
||||
description,
|
||||
change,
|
||||
marker0,
|
||||
marker1,
|
||||
private) VALUES (?,?,?,?,?,?,?,?,?);""",
|
||||
handle,
|
||||
gid,
|
||||
the_type[0],
|
||||
the_type[1],
|
||||
description,
|
||||
change,
|
||||
marker[0],
|
||||
marker[1],
|
||||
private)
|
||||
|
||||
if place:
|
||||
export_place(db, "event", handle, place)
|
||||
export_list(db, "event", handle, "note", note_list)
|
||||
export_attribute_list(db, "event", handle, attribute_list)
|
||||
export_media_list(db, "event", handle, media_list)
|
||||
export_source_list(db, "event", handle, source_list)
|
||||
|
||||
data = database.event_map[event_handle]
|
||||
export_event(db, data)
|
||||
count += 1
|
||||
callback(100 * count/total)
|
||||
|
||||
@ -690,96 +811,7 @@ def exportData(database, filename, option_box=None, callback=None):
|
||||
# ---------------------------------
|
||||
for person_handle in database.person_map.keys():
|
||||
person = database.person_map[person_handle]
|
||||
(handle, # 0
|
||||
gid, # 1
|
||||
gender, # 2
|
||||
primary_name, # 3
|
||||
alternate_names, # 4
|
||||
death_ref_index, # 5
|
||||
birth_ref_index, # 6
|
||||
event_ref_list, # 7
|
||||
family_list, # 8
|
||||
parent_family_list, # 9
|
||||
media_list, # 10
|
||||
address_list, # 11
|
||||
attribute_list, # 12
|
||||
urls, # 13
|
||||
lds_ord_list, # 14
|
||||
psource_list, # 15
|
||||
pnote_list, # 16
|
||||
change, # 17
|
||||
marker, # 18
|
||||
private, # 19
|
||||
person_ref_list, # 20
|
||||
) = person
|
||||
db.query("""INSERT INTO person (
|
||||
handle,
|
||||
gid,
|
||||
gender,
|
||||
death_ref_handle,
|
||||
birth_ref_handle,
|
||||
change,
|
||||
marker0,
|
||||
marker1,
|
||||
private) values (?, ?, ?, ?, ?, ?, ?, ?, ?);""",
|
||||
handle,
|
||||
gid,
|
||||
gender,
|
||||
lookup(death_ref_index, event_ref_list),
|
||||
lookup(birth_ref_index, event_ref_list),
|
||||
change,
|
||||
marker[0],
|
||||
marker[1],
|
||||
private)
|
||||
|
||||
# Event Reference information
|
||||
for event_ref in event_ref_list:
|
||||
(private, note_list, attribute_list, ref, role) = event_ref
|
||||
export_event_ref(db, "person", handle, ref, role, private)
|
||||
export_list(db, "event_ref", ref, "note", note_list)
|
||||
export_attribute_list(db, "event_ref", ref, attribute_list)
|
||||
export_list(db, "person", handle, "family", family_list)
|
||||
export_list(db, "person", handle, "parent_family", parent_family_list)
|
||||
export_media_list(db, "person", handle, media_list)
|
||||
export_list(db, "person", handle, "note", pnote_list)
|
||||
export_attribute_list(db, "person", handle, attribute_list)
|
||||
export_url_list(db, "person", handle, urls)
|
||||
export_person_ref_list(db, "person", handle, person_ref_list)
|
||||
export_source_list(db, "person", handle, psource_list)
|
||||
|
||||
# -------------------------------------
|
||||
# Address
|
||||
# -------------------------------------
|
||||
for address in address_list:
|
||||
(private, asource_list, anote_list, date, location) = address
|
||||
(street, city, county, state, country, postal, phone) = location
|
||||
addr_handle = create_id()
|
||||
export_address(db, "person", handle, addr_handle, street, city, county, state, country, postal, phone, private)
|
||||
if date:
|
||||
export_date(db, "address", addr_handle, date)
|
||||
export_list(db, "address", addr_handle, "note", anote_list)
|
||||
export_source_list(db, "address", addr_handle, source_list)
|
||||
|
||||
# -------------------------------------
|
||||
# LDS ord
|
||||
# -------------------------------------
|
||||
for ldsord in lds_ord_list:
|
||||
(lsource_list, lnote_list, date, type, place,
|
||||
famc, temple, status, lprivate) = ldsord
|
||||
lds_handle = create_id()
|
||||
# FIXME: place?
|
||||
export_lds(db, "person", handle, lds_handle, type, place, famc, temple, status, lprivate)
|
||||
if date:
|
||||
export_date(db, "lds", lds_handle, date)
|
||||
export_list(db, "lds", lds_handle, "note", lnote_list)
|
||||
export_source_list(db, "lds", lds_handle, lsource_list)
|
||||
|
||||
# -------------------------------------
|
||||
# Names
|
||||
# -------------------------------------
|
||||
export_name(db, handle, create_id(), True, primary_name)
|
||||
map(lambda name: export_name(db, handle, create_id(), False, name),
|
||||
alternate_names)
|
||||
export_person(db, person)
|
||||
count += 1
|
||||
callback(100 * count/total)
|
||||
|
||||
@ -809,31 +841,20 @@ def exportData(database, filename, option_box=None, callback=None):
|
||||
private)
|
||||
|
||||
export_child_ref_list(db, "family", handle, "child_ref", child_ref_list)
|
||||
export_list(db, "family", handle, "note", pnote_list)
|
||||
export_list(db, "family", handle, "note", note_list)
|
||||
export_attribute_list(db, "family", handle, attribute_list)
|
||||
export_source_list(db, "family", handle, source_list)
|
||||
export_media_list(db, "family", handle, media_list)
|
||||
export_source_ref_list(db, "family", handle, source_list)
|
||||
export_media_ref_list(db, "family", handle, media_list)
|
||||
|
||||
# Event Reference information
|
||||
for event_ref in event_ref_list:
|
||||
(private, note_list, attribute_list, ref, role) = event_ref
|
||||
export_event_ref(db, "family", handle, ref, role, private)
|
||||
export_list(db, "event_ref", ref, "note", note_list)
|
||||
export_attribute_list(db, "event_ref", ref, attribute_list)
|
||||
export_event_ref(db, "family", handle, event_ref)
|
||||
|
||||
# -------------------------------------
|
||||
# LDS
|
||||
# -------------------------------------
|
||||
for ldsord in lds_seal_list:
|
||||
(lsource_list, lnote_list, date, type, place,
|
||||
famc, temple, status, lprivate) = ldsord
|
||||
lds_handle = create_id()
|
||||
# FIXME: place?
|
||||
export_lds(db, "family", handle, lds_handle, type, place, famc, temple, status, lprivate)
|
||||
if date:
|
||||
export_date(db, "lds", lds_handle, date)
|
||||
export_list(db, "lds", lds_handle, "note", lnote_list)
|
||||
export_source_list(db, "lds", lds_handle, lsource_list)
|
||||
export_lds(db, "family", handle, ldsord)
|
||||
|
||||
count += 1
|
||||
callback(100 * count/total)
|
||||
@ -859,24 +880,17 @@ def exportData(database, filename, option_box=None, callback=None):
|
||||
handle, gid, the_type[0], the_type[1],
|
||||
name, change, marker[0], marker[1], private)
|
||||
|
||||
export_list(db, "lds", lds_handle, "note", lnote_list)
|
||||
export_list(db, "repository", handle, "note", note_list)
|
||||
export_url_list(db, "repository", handle, urls)
|
||||
|
||||
for address in address_list:
|
||||
(private, asource_list, anote_list, date, location) = address
|
||||
(street, city, county, state, country, postal, phone) = location
|
||||
addr_handle = create_id()
|
||||
export_address(db, "repository", handle, addr_handle, street, city, county, state,
|
||||
country, postal, phone, private)
|
||||
if date:
|
||||
export_date(db, "address", addr_handle, date)
|
||||
export_list(db, "address", addr_handle, "note", anote_list)
|
||||
export_source_list(db, "address", addr_handle, asource_list)
|
||||
export_address(db, "repository", handle, address)
|
||||
|
||||
count += 1
|
||||
callback(100 * count/total)
|
||||
|
||||
# ---------------------------------
|
||||
# Place
|
||||
# Place
|
||||
# ---------------------------------
|
||||
for place_handle in database.place_map.keys():
|
||||
place = database.place_map[place_handle]
|
||||
@ -902,22 +916,16 @@ def exportData(database, filename, option_box=None, callback=None):
|
||||
change, marker[0], marker[1], private)
|
||||
|
||||
export_url_list(db, "place", handle, urls)
|
||||
export_media_list(db, "place", handle, media_list)
|
||||
export_source_list(db, "place", handle, source_list)
|
||||
export_media_ref_list(db, "place", handle, media_list)
|
||||
export_source_ref_list(db, "place", handle, source_list)
|
||||
export_list(db, "place", handle, "note", note_list)
|
||||
|
||||
# FIX: losing link to places?
|
||||
for location in alt_location_list:
|
||||
((street, city, county, state, country, postal, phone), parish) = location
|
||||
addr_handle = create_id()
|
||||
export_address(db, "place", handle, addr_handle, street, city, county, state,
|
||||
country, postal, phone, private, parish)
|
||||
# Main Location with parish:
|
||||
# No need; we have the handle, but ok:
|
||||
export_location(db, "place_main", handle, main_loc)
|
||||
# But we need to link these:
|
||||
export_location_list(db, "place_alt", handle, alt_location_list)
|
||||
|
||||
(street, city, county, state, country, postal, phone,
|
||||
private, parish) = main_loc
|
||||
export_address(db, "place", handle, create_id(), street, city,
|
||||
county, state, country, postal, phone, private,
|
||||
parish)
|
||||
count += 1
|
||||
callback(100 * count/total)
|
||||
|
||||
@ -938,7 +946,7 @@ def exportData(database, filename, option_box=None, callback=None):
|
||||
export_source(db, handle, gid, title, author, pubinfo, abbrev, change,
|
||||
marker[0], marker[1], private)
|
||||
export_list(db, "source", handle, "note", note_list)
|
||||
export_media_list(db, "source", handle, media_list)
|
||||
export_media_ref_list(db, "source", handle, media_list)
|
||||
# FIXME: reporef_list, datamap
|
||||
#print "FIXME: reporef_list", reporef_list
|
||||
#print "FIXME: datamap", datamap
|
||||
@ -976,10 +984,9 @@ def exportData(database, filename, option_box=None, callback=None):
|
||||
private) VALUES (?,?,?,?,?,?,?,?,?);""",
|
||||
handle, gid, path, mime, desc,
|
||||
change, marker[0], marker[1], private)
|
||||
if date:
|
||||
export_date(db, "media", handle, date)
|
||||
export_date(db, "media", handle, date)
|
||||
export_list(db, "media", handle, "note", note_list)
|
||||
export_source_list(db, "media", handle, source_list)
|
||||
export_source_ref_list(db, "media", handle, source_list)
|
||||
export_attribute_list(db, "media", handle, attribute_list)
|
||||
count += 1
|
||||
callback(100 * count/total)
|
||||
|
||||
@ -54,6 +54,9 @@ from gui.utils import ProgressMeter
|
||||
from Utils import create_id
|
||||
|
||||
def lookup(handle, event_ref_list):
|
||||
"""
|
||||
Find the handle in a unserialized event_ref_list and return code.
|
||||
"""
|
||||
if handle is None:
|
||||
return -1
|
||||
else:
|
||||
@ -125,37 +128,44 @@ class SQLReader(object):
|
||||
# -----------------------------------------------
|
||||
|
||||
def get_address_list(self, sql, from_type, from_handle):
|
||||
# FIXME
|
||||
return []
|
||||
results = self.get_links(sql, from_type, from_handle, "address")
|
||||
retval = []
|
||||
for handle in results:
|
||||
result = sql.query("select * from address where handle = ?;",
|
||||
handle)
|
||||
retval.append(self.pack_address(sql, result[0]))
|
||||
return retval
|
||||
|
||||
def get_attribute_list(self, sql, from_type, from_handle):
|
||||
rows = sql.query("select * from attribute where from_type = ? and from_handle = ?;",
|
||||
from_type, from_handle)
|
||||
handles = self.get_links(sql, from_type, from_handle, "attribute")
|
||||
retval = []
|
||||
for row in rows:
|
||||
(handle,
|
||||
from_type,
|
||||
from_handle,
|
||||
the_type0,
|
||||
the_type1,
|
||||
value,
|
||||
private) = row
|
||||
source_list = self.get_source_list(sql, "attribute", handle)
|
||||
note_list = self.get_note_list(sql, "attribute", handle)
|
||||
retval.append((private, source_list, note_list,
|
||||
(the_type0, the_type1), value))
|
||||
for handle in handles:
|
||||
rows = sql.query("select * from attribute where handle = ?;",
|
||||
handle)
|
||||
for row in rows:
|
||||
(handle,
|
||||
the_type0,
|
||||
the_type1,
|
||||
value,
|
||||
private) = row
|
||||
source_list = self.get_source_ref_list(sql, "attribute", handle)
|
||||
note_list = self.get_note_list(sql, "attribute", handle)
|
||||
retval.append((private, source_list, note_list,
|
||||
(the_type0, the_type1), value))
|
||||
return retval
|
||||
|
||||
def get_child_ref_list(self, sql, from_type, from_handle):
|
||||
rows = sql.query("select * from child_ref where from_type = ? and from_handle = ?;",
|
||||
from_type, from_handle)
|
||||
results = self.get_links(sql, from_type, from_handle, "child_ref")
|
||||
retval = []
|
||||
for row in rows:
|
||||
(rtype, rhandle, ref, frel0, frel1, mrel0, mrel1, private) = row
|
||||
source_list = self.get_source_list(sql, "child_ref", rhandle)
|
||||
note_list = self.get_note_list(sql, "child_ref", rhandle)
|
||||
retval.append((private, source_list, note_list, ref,
|
||||
(frel0, frel1), (mrel0, mrel1)))
|
||||
for handle in results:
|
||||
rows = sql.query("select * from child_ref where handle = ?;",
|
||||
handle)
|
||||
for row in rows:
|
||||
(handle, ref, frel0, frel1, mrel0, mrel1, private) = row
|
||||
source_list = self.get_source_ref_list(sql, "child_ref", handle)
|
||||
note_list = self.get_note_list(sql, "child_ref", handle)
|
||||
retval.append((private, source_list, note_list, ref,
|
||||
(frel0, frel1), (mrel0, mrel1)))
|
||||
return retval
|
||||
|
||||
def get_datamap(self, sql, from_type, from_handle):
|
||||
@ -163,79 +173,169 @@ class SQLReader(object):
|
||||
return {}
|
||||
|
||||
def get_event_ref_list(self, sql, from_type, from_handle):
|
||||
results = sql.query("select * from event_ref where from_type = ? and from_handle = ?;",
|
||||
from_type,
|
||||
from_handle)
|
||||
return [self.pack_event_ref(sql, result) for result in results]
|
||||
results = self.get_links(sql, from_type, from_handle, "event_ref")
|
||||
retval = []
|
||||
for handle in results:
|
||||
result = sql.query("select * from event_ref where handle = ?;",
|
||||
handle)
|
||||
retval.append(self.pack_event_ref(sql, result[0]))
|
||||
return retval
|
||||
|
||||
def get_family_list(self, sql, from_type, from_handle):
|
||||
return self.get_list(sql, from_type, from_handle, "family")
|
||||
return self.get_links(sql, from_type, from_handle, "family")
|
||||
|
||||
def get_parent_family_list(self, sql, from_type, from_handle):
|
||||
return self.get_list(sql, from_type, from_handle, "parent_family")
|
||||
return self.get_links(sql, from_type, from_handle, "parent_family")
|
||||
|
||||
def get_person_ref_list(self, sql, from_type, from_handle):
|
||||
rows = sql.query("select * from person_ref where from_type = ? and from_handle = ?;",
|
||||
from_type, from_handle)
|
||||
handles = self.get_links(sql, from_type, from_handle, "person_ref")
|
||||
retval = []
|
||||
for row in rows:
|
||||
(from_type,
|
||||
from_handle,
|
||||
handle,
|
||||
description,
|
||||
private) = row
|
||||
source_list = self.get_source_list(sql, "person_ref", handle)
|
||||
note_list = self.get_note_list(sql, "person_ref", handle)
|
||||
retval.append((private,
|
||||
source_list,
|
||||
note_list,
|
||||
handle,
|
||||
description))
|
||||
for ref_handle in handles:
|
||||
rows = sql.query("select * from person_ref where handle = ?;",
|
||||
ref_handle)
|
||||
for row in rows:
|
||||
(handle,
|
||||
description,
|
||||
private) = row
|
||||
source_list = self.get_source_ref_list(sql, "person_ref", handle)
|
||||
note_list = self.get_note_list(sql, "person_ref", handle)
|
||||
retval.append((private,
|
||||
source_list,
|
||||
note_list,
|
||||
handle,
|
||||
description))
|
||||
return retval
|
||||
|
||||
def get_location_list(self, sql, from_type, from_handle):
|
||||
# FIXME
|
||||
return []
|
||||
handles = self.get_links(sql, from_type, from_handle, "location")
|
||||
results = []
|
||||
for handle in handles:
|
||||
results += sql.query("""select * from location where handle = ?;""",
|
||||
handle)
|
||||
return [self.pack_location(sql, result, with_parish=True) for result in results]
|
||||
|
||||
def get_lds_list(self, sql, from_type, from_handle):
|
||||
# FIXME
|
||||
return []
|
||||
handles = self.get_links(sql, from_type, from_handle, "lds")
|
||||
results = []
|
||||
for handle in handles:
|
||||
results += sql.query("""select * from lds where handle = ?;""",
|
||||
handle)
|
||||
return [self.pack_lds(sql, result) for result in results]
|
||||
|
||||
def get_media_list(self, sql, from_type, from_handle):
|
||||
# FIXME
|
||||
return []
|
||||
handles = self.get_links(sql, from_type, from_handle, "media_ref")
|
||||
results = []
|
||||
for handle in handles:
|
||||
results += sql.query("""select * from media_ref where handle = ?;""",
|
||||
handle)
|
||||
return [self.pack_media_ref(sql, result) for result in results]
|
||||
|
||||
def get_note_list(self, sql, from_type, from_handle):
|
||||
return self.get_list(sql, from_type, from_handle, "note")
|
||||
return self.get_links(sql, from_type, from_handle, "note")
|
||||
|
||||
def get_repository_ref_list(self, sql, from_type, from_handle):
|
||||
# FIXME
|
||||
return []
|
||||
def get_repository_list(self, sql, from_type, from_handle):
|
||||
handles = self.get_links(sql, from_type, from_handle, "repository")
|
||||
results = []
|
||||
for handle in handles:
|
||||
results += sql.query("""select * from repository where handle = ?;""",
|
||||
handle)
|
||||
return [self.pack_repository(sql, result) for result in results]
|
||||
|
||||
def get_source_list(self, sql, from_type, from_handle):
|
||||
results = sql.query("""select * from source where from_type = ? and handle = ?;""",
|
||||
from_type, from_handle)
|
||||
return [self.pack_source(sql, result) for result in results]
|
||||
def get_source_ref_list(self, sql, from_type, from_handle):
|
||||
handles = self.get_links(sql, from_type, from_handle, "source_ref")
|
||||
results = []
|
||||
for handle in handles:
|
||||
results += sql.query("""select * from source_ref where handle = ?;""",
|
||||
handle)
|
||||
return [self.pack_source_ref(sql, result) for result in results]
|
||||
|
||||
def get_url_list(self, sql, from_type, from_handle):
|
||||
# FIXME
|
||||
return []
|
||||
handles = self.get_links(sql, from_type, from_handle, "url")
|
||||
results = []
|
||||
for handle in handles:
|
||||
results += sql.query("""select * from url where handle = ?;""",
|
||||
handle)
|
||||
return [self.pack_url(sql, result) for result in results]
|
||||
|
||||
# ---------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------
|
||||
|
||||
def pack_event_ref(self, sql, data):
|
||||
(from_type,
|
||||
from_handle,
|
||||
def pack_address(self, sql, data):
|
||||
(handle, private) = data
|
||||
source_list = self.get_source_ref_list(sql, "address", handle)
|
||||
date_handle = self.get_link(sql, "address", handle, "date")
|
||||
date = self.get_date(sql, date_handle)
|
||||
note_list = self.get_note_list(sql, "address", handle)
|
||||
location = self.get_location(sql, "address", handle)
|
||||
return (private, source_list, note_list, date, location)
|
||||
|
||||
def pack_lds(self, sql, data):
|
||||
(handle, type, place, famc, temple, status, private) = data
|
||||
source_list = self.get_source_ref_list(sql, "lds", handle)
|
||||
note_list = self.get_note_list(sql, "lds", handle)
|
||||
date_handle = self.get_link(sql, "lds", handle, "date")
|
||||
date = self.get_date(sql, date_handle)
|
||||
return (source_list, note_list, date, type, place,
|
||||
famc, temple, status, private)
|
||||
|
||||
def pack_media_ref(self, sql, data):
|
||||
(handle,
|
||||
ref,
|
||||
role0,
|
||||
role1,
|
||||
private) = data
|
||||
note_list = self.get_note_list(sql, "event_ref", from_handle)
|
||||
attribute_list = self.get_attribute_list(sql, "event_ref", from_handle)
|
||||
source_list = self.get_source_ref_list(sql, "media_ref", handle)
|
||||
note_list = self.get_note_list(sql, "media_ref", handle)
|
||||
attribute_list = self.get_attribute_list(sql, "event_ref", handle)
|
||||
return (private, source_list, note_list, attribute_list, ref, (role0, role1))
|
||||
|
||||
def pack_repository(self, sql, data):
|
||||
(handle,
|
||||
gid,
|
||||
the_type0,
|
||||
the_type1,
|
||||
name,
|
||||
change,
|
||||
marker0,
|
||||
marker1,
|
||||
private) = data
|
||||
note_list = self.get_note_list(sql, "repository", handle)
|
||||
address_list = self.get_address_list(sql, "repository", handle)
|
||||
urls = self.get_url_list(sql, "repository", handle)
|
||||
return (handle, gid, (the_type0, the_type1), name, note_list,
|
||||
address_list, urls, change, (marker0, marker1), private)
|
||||
|
||||
def pack_url(self, sql, data):
|
||||
(handle,
|
||||
path,
|
||||
desc,
|
||||
type0,
|
||||
type1,
|
||||
private) = data
|
||||
return (private, path, desc, (type0, type1))
|
||||
|
||||
def pack_event_ref(self, sql, data):
|
||||
(handle,
|
||||
ref,
|
||||
role0,
|
||||
role1,
|
||||
private) = data
|
||||
note_list = self.get_note_list(sql, "event_ref", handle)
|
||||
attribute_list = self.get_attribute_list(sql, "event_ref", handle)
|
||||
return (private, note_list, attribute_list, ref, (role0, role1))
|
||||
|
||||
def pack_source_ref(self, sql, data):
|
||||
(handle,
|
||||
ref,
|
||||
confidence,
|
||||
page,
|
||||
private) = data
|
||||
date_handle = self.get_link(sql, "source_ref", handle, "date")
|
||||
date = self.get_date(sql, date_handle)
|
||||
note_list = self.get_note_list(sql, "source_ref", handle)
|
||||
return (date, private, note_list, confidence, ref, page)
|
||||
|
||||
def pack_source(self, sql, data):
|
||||
(handle,
|
||||
gid,
|
||||
@ -247,12 +347,10 @@ class SQLReader(object):
|
||||
marker0,
|
||||
marker1,
|
||||
private) = data
|
||||
|
||||
note_list = self.get_note_list(sql, "source", handle)
|
||||
media_list = self.get_media_list(sql, "source", handle)
|
||||
reporef_list = self.get_repository_ref_list(sql, "source", handle)
|
||||
datamap = None
|
||||
|
||||
reporef_list = self.get_repository_list(sql, "source", handle)
|
||||
datamap = {}
|
||||
return (handle, gid, title,
|
||||
author, pubinfo,
|
||||
note_list,
|
||||
@ -262,29 +360,36 @@ class SQLReader(object):
|
||||
reporef_list,
|
||||
(marker0, marker1), private)
|
||||
|
||||
def get_list(self, sql, from_type, from_handle, to_type):
|
||||
results = sql.query("""select to_handle from link where from_type = ? and from_handle = ? and to_type = ?;""",
|
||||
from_type, from_handle, to_type)
|
||||
return [str(result) for result in results]
|
||||
def get_location(self, sql, from_type, from_handle):
|
||||
handle = self.get_link(sql, from_type, from_handle, "location")
|
||||
if handle:
|
||||
results = sql.query("""select * from location where handle = ?;""",
|
||||
handle)
|
||||
if len(results) == 1:
|
||||
return self.pack_location(sql, results[0], with_parish=True)
|
||||
|
||||
def get_names(self, sql, handle, primary):
|
||||
names = sql.query("""select * from name where from_handle = ? and primary_name = ?;""",
|
||||
handle, primary)
|
||||
def get_names(self, sql, from_type, from_handle, primary):
|
||||
handles = self.get_links(sql, from_type, from_handle, "name")
|
||||
names = []
|
||||
for handle in handles:
|
||||
results = sql.query("""select * from name where handle = ? and primary_name = ?;""",
|
||||
handle, primary)
|
||||
if len(results) > 0:
|
||||
names += results
|
||||
result = [self.pack_name(sql, name) for name in names]
|
||||
if primary:
|
||||
if len(result) == 1:
|
||||
return result[0]
|
||||
elif len(result) == 0:
|
||||
return None
|
||||
return gen.lib.Name().serialize()
|
||||
else:
|
||||
print Exception("too many primary names")
|
||||
raise Exception("too many primary names")
|
||||
else:
|
||||
return result
|
||||
|
||||
def pack_name(self, sql, data):
|
||||
# unpack name from SQL table:
|
||||
(from_handle,
|
||||
handle,
|
||||
(handle,
|
||||
primary_name,
|
||||
private,
|
||||
first_name,
|
||||
@ -300,47 +405,101 @@ class SQLReader(object):
|
||||
display_as,
|
||||
call) = data
|
||||
|
||||
source_list = self.get_source_list(sql, "name", from_handle)
|
||||
note_list = self.get_note_list(sql, "name", from_handle)
|
||||
date = self.get_date(sql, "name", from_handle)
|
||||
source_list = self.get_source_ref_list(sql, "name", handle)
|
||||
note_list = self.get_note_list(sql, "name", handle)
|
||||
date_handle = self.get_link(sql, "name", handle, "date")
|
||||
date = self.get_date(sql, date_handle)
|
||||
return (private, source_list, note_list, date,
|
||||
first_name, surname, suffix, title,
|
||||
(name_type0, name_type1), prefix, patronymic,
|
||||
group_as, sort_as, display_as, call)
|
||||
|
||||
def get_place(self, sql, from_type, handle):
|
||||
row = self.get_list(sql, from_type, handle, "place")
|
||||
if len(row) == 1:
|
||||
return row[0]
|
||||
def pack_location(self, sql, data, with_parish):
|
||||
(handle,
|
||||
street,
|
||||
city,
|
||||
county,
|
||||
state,
|
||||
country,
|
||||
postal,
|
||||
phone,
|
||||
parish) = data
|
||||
if with_parish:
|
||||
return ((street, city, county, state, country, postal, phone), parish)
|
||||
else:
|
||||
print AttributeError("invalid place '%s' '%s'" % (from_type, handle))
|
||||
return (street, city, county, state, country, postal, phone)
|
||||
|
||||
def get_date(self, sql, from_type, from_handle):
|
||||
rows = sql.query("select * from date where from_type = ? and from_handle = ?;",
|
||||
from_type, from_handle)
|
||||
def get_place_from_handle(self, sql, ref_handle):
|
||||
if ref_handle:
|
||||
place_row = sql.query("select * from place where handle = ?;",
|
||||
ref_handle)
|
||||
if len(place_row) == 1:
|
||||
# return raw DB data here:
|
||||
return place_row[0]
|
||||
elif len(place_row) == 0:
|
||||
print "ERROR: get_place_from_handle('%s'), no such handle." % (ref_handle, )
|
||||
else:
|
||||
print "ERROR: get_place_from_handle('%s') should be unique; returned %d records." % (ref_handle, len(place_row))
|
||||
return None
|
||||
|
||||
def get_location_from_handle(self, sql, ref_handle, with_parish=False):
|
||||
if ref_handle:
|
||||
place_row = sql.query("select * from location where handle = ?;",
|
||||
ref_handle)
|
||||
if len(place_row) == 1:
|
||||
return self.pack_location(sql, place_row[0], with_parish)
|
||||
elif len(place_row) == 0:
|
||||
print "ERROR: get_location_from_handle('%s'), no such handle." % (ref_handle, )
|
||||
else:
|
||||
print "ERROR: get_location_from_handle('%s') should be unique; returned %d records." % (ref_handle, len(place_row))
|
||||
return gen.lib.Location().serialize()
|
||||
|
||||
def get_link(self, sql, from_type, from_handle, to_link):
|
||||
"""
|
||||
Return a link, and return handle.
|
||||
"""
|
||||
assert type(from_handle) in [unicode, str], "from_handle is wrong type: %s is %s" % (from_handle, type(from_handle))
|
||||
rows = self.get_links(sql, from_type, from_handle, to_link)
|
||||
if len(rows) == 1:
|
||||
(from_type,
|
||||
from_handle,
|
||||
calendar,
|
||||
modifier,
|
||||
quality,
|
||||
day1,
|
||||
month1,
|
||||
year1,
|
||||
slash1,
|
||||
day2,
|
||||
month2,
|
||||
year2,
|
||||
slash2,
|
||||
text,
|
||||
sortval,
|
||||
newyear) = rows[0]
|
||||
dateval = day1, month1, year1, slash1, day2, month2, year2, slash2
|
||||
return (calendar, modifier, quality, dateval, text, sortval, newyear)
|
||||
elif len(rows) == 0:
|
||||
return None
|
||||
else:
|
||||
print Exception("ERROR, wrong number of dates: %s" % rows)
|
||||
return rows[0]
|
||||
elif len(rows) > 1:
|
||||
print "ERROR: too many links %s:%s -> %s (%d)" % (from_type, from_handle, to_link, len(rows))
|
||||
return None
|
||||
|
||||
def get_links(self, sql, from_type, from_handle, to_link):
|
||||
"""
|
||||
Return a list of handles (possibly none).
|
||||
"""
|
||||
results = sql.query("""select to_handle from link where from_type = ? and from_handle = ? and to_type = ?;""",
|
||||
from_type, from_handle, to_link)
|
||||
return [result[0] for result in results]
|
||||
|
||||
def get_date(self, sql, handle):
|
||||
assert type(handle) in [unicode, str, type(None)], "handle is wrong type: %s" % handle
|
||||
if handle:
|
||||
rows = sql.query("select * from date where handle = ?;", handle)
|
||||
if len(rows) == 1:
|
||||
(handle,
|
||||
calendar,
|
||||
modifier,
|
||||
quality,
|
||||
day1,
|
||||
month1,
|
||||
year1,
|
||||
slash1,
|
||||
day2,
|
||||
month2,
|
||||
year2,
|
||||
slash2,
|
||||
text,
|
||||
sortval,
|
||||
newyear) = rows[0]
|
||||
dateval = day1, month1, year1, slash1, day2, month2, year2, slash2
|
||||
return (calendar, modifier, quality, dateval, text, sortval, newyear)
|
||||
elif len(rows) == 0:
|
||||
return None
|
||||
else:
|
||||
print Exception("ERROR, wrong number of dates: %s" % rows)
|
||||
|
||||
def process(self):
|
||||
sql = self.openSQL()
|
||||
@ -355,7 +514,7 @@ class SQLReader(object):
|
||||
self.trans = self.db.transaction_begin("",batch=True)
|
||||
self.db.disable_signals()
|
||||
count = 0.0
|
||||
t = time.time()
|
||||
self.t = time.time()
|
||||
# ---------------------------------
|
||||
# Process note
|
||||
# ---------------------------------
|
||||
@ -372,6 +531,7 @@ class SQLReader(object):
|
||||
marker1,
|
||||
private) = note
|
||||
styled_text = [text, []]
|
||||
# direct connection with note handle
|
||||
markups = sql.query("""select * from markup where handle = ?""", handle)
|
||||
for markup in markups:
|
||||
(mhandle,
|
||||
@ -386,6 +546,42 @@ class SQLReader(object):
|
||||
(marker0, marker1), private)
|
||||
count += 1
|
||||
self.callback(100 * count/total)
|
||||
|
||||
# ---------------------------------
|
||||
# Process event
|
||||
# ---------------------------------
|
||||
events = sql.query("""select * from event;""")
|
||||
for event in events:
|
||||
(handle,
|
||||
gid,
|
||||
the_type0,
|
||||
the_type1,
|
||||
description,
|
||||
change,
|
||||
marker0,
|
||||
marker1,
|
||||
private) = event
|
||||
|
||||
note_list = self.get_note_list(sql, "event", handle)
|
||||
source_list = self.get_source_ref_list(sql, "event", handle)
|
||||
media_list = self.get_media_list(sql, "event", handle)
|
||||
attribute_list = self.get_attribute_list(sql, "event", handle)
|
||||
|
||||
date_handle = self.get_link(sql, "event", handle, "date")
|
||||
date = self.get_date(sql, date_handle)
|
||||
|
||||
place_handle = self.get_link(sql, "event", handle, "place")
|
||||
place = self.get_place_from_handle(sql, place_handle)
|
||||
|
||||
data = (str(handle), gid, (the_type0, the_type1), date, description, place,
|
||||
source_list, note_list, media_list, attribute_list,
|
||||
change, (marker0, marker1), private)
|
||||
|
||||
self.db.event_map[str(handle)] = data
|
||||
|
||||
count += 1
|
||||
self.callback(100 * count/total)
|
||||
|
||||
# ---------------------------------
|
||||
# Process person
|
||||
# ---------------------------------
|
||||
@ -403,8 +599,8 @@ class SQLReader(object):
|
||||
marker1, # 18
|
||||
private, # 19
|
||||
) = person
|
||||
primary_name = self.get_names(sql, handle, True) # one
|
||||
alternate_names = self.get_names(sql, handle, False) # list
|
||||
primary_name = self.get_names(sql, "person", handle, True) # one
|
||||
alternate_names = self.get_names(sql, "person", handle, False) # list
|
||||
event_ref_list = self.get_event_ref_list(sql, "person", handle)
|
||||
family_list = self.get_family_list(sql, "person", handle)
|
||||
parent_family_list = self.get_parent_family_list(sql, "person", handle)
|
||||
@ -413,7 +609,7 @@ class SQLReader(object):
|
||||
attribute_list = self.get_attribute_list(sql, "person", handle)
|
||||
urls = self.get_url_list(sql, "person", handle)
|
||||
lds_ord_list = self.get_lds_list(sql, "person", handle)
|
||||
psource_list = self.get_source_list(sql, "person", handle)
|
||||
psource_list = self.get_source_ref_list(sql, "person", handle)
|
||||
pnote_list = self.get_note_list(sql, "person", handle)
|
||||
person_ref_list = self.get_person_ref_list(sql, "person", handle)
|
||||
death_ref_index = lookup(death_ref_handle, event_ref_list)
|
||||
@ -443,37 +639,6 @@ class SQLReader(object):
|
||||
count += 1
|
||||
self.callback(100 * count/total)
|
||||
# ---------------------------------
|
||||
# Process event
|
||||
# ---------------------------------
|
||||
events = sql.query("""select * from event;""")
|
||||
for event in events:
|
||||
(handle,
|
||||
gid,
|
||||
the_type0,
|
||||
the_type1,
|
||||
description,
|
||||
change,
|
||||
marker0,
|
||||
marker1,
|
||||
private) = event
|
||||
|
||||
source_list = self.get_source_list(sql, "event", handle)
|
||||
note_list = self.get_note_list(sql, "event", handle)
|
||||
media_list = self.get_media_list(sql, "event", handle)
|
||||
attribute_list = self.get_attribute_list(sql, "event", handle)
|
||||
|
||||
date = self.get_date(sql, "event", handle)
|
||||
place = self.get_place(sql, "event", handle)
|
||||
|
||||
data = (str(handle), gid, (the_type0, the_type1), date, description, place,
|
||||
source_list, note_list, media_list, attribute_list,
|
||||
change, (marker0, marker1), private)
|
||||
|
||||
self.db.event_map[str(handle)] = data
|
||||
|
||||
count += 1
|
||||
self.callback(100 * count/total)
|
||||
# ---------------------------------
|
||||
# Process family
|
||||
# ---------------------------------
|
||||
families = sql.query("""select * from family;""")
|
||||
@ -494,7 +659,7 @@ class SQLReader(object):
|
||||
media_list = self.get_media_list(sql, "family", handle)
|
||||
attribute_list = self.get_attribute_list(sql, "family", handle)
|
||||
lds_seal_list = self.get_lds_list(sql, "family", handle)
|
||||
source_list = self.get_source_list(sql, "family", handle)
|
||||
source_list = self.get_source_ref_list(sql, "family", handle)
|
||||
note_list = self.get_note_list(sql, "family", handle)
|
||||
|
||||
self.db.family_map[str(handle)] = (str(handle), gid,
|
||||
@ -542,6 +707,7 @@ class SQLReader(object):
|
||||
(handle,
|
||||
gid,
|
||||
title,
|
||||
main_loc,
|
||||
long,
|
||||
lat,
|
||||
change,
|
||||
@ -549,11 +715,13 @@ class SQLReader(object):
|
||||
marker1,
|
||||
private) = place
|
||||
|
||||
main_loc = None # FIXME
|
||||
alt_location_list = self.get_location_list(sql, "place", handle)
|
||||
# We could look this up by "place_main", but we have the handle:
|
||||
main_loc = self.get_location_from_handle(sql, main_loc,
|
||||
with_parish=True)
|
||||
alt_location_list = self.get_location_list(sql, "place_alt", handle)
|
||||
urls = self.get_url_list(sql, "place", handle)
|
||||
media_list = self.get_media_list(sql, "place", handle)
|
||||
source_list = self.get_source_list(sql, "place", handle)
|
||||
source_list = self.get_source_ref_list(sql, "place", handle)
|
||||
note_list = self.get_note_list(sql, "place", handle)
|
||||
|
||||
self.db.place_map[str(handle)] = (str(handle), gid, title, long, lat,
|
||||
@ -570,8 +738,7 @@ class SQLReader(object):
|
||||
# ---------------------------------
|
||||
sources = sql.query("""select * from source;""")
|
||||
for source in sources:
|
||||
(from_type,
|
||||
handle,
|
||||
(handle,
|
||||
gid,
|
||||
title,
|
||||
author,
|
||||
@ -584,7 +751,7 @@ class SQLReader(object):
|
||||
note_list = self.get_note_list(sql, "source", handle)
|
||||
media_list = self.get_media_list(sql, "source", handle)
|
||||
datamap = self.get_datamap(sql, "source", handle)
|
||||
reporef_list = self.get_repository_ref_list(sql, "source", handle)
|
||||
reporef_list = self.get_repository_list(sql, "source", handle)
|
||||
|
||||
self.db.source_map[str(handle)] = (str(handle), gid, title,
|
||||
author, pubinfo,
|
||||
@ -612,10 +779,11 @@ class SQLReader(object):
|
||||
private) = med
|
||||
|
||||
attribute_list = self.get_attribute_list(sql, "media", handle)
|
||||
source_list = self.get_source_list(sql, "media", handle)
|
||||
source_list = self.get_source_ref_list(sql, "media", handle)
|
||||
note_list = self.get_note_list(sql, "media", handle)
|
||||
|
||||
date = self.get_date(sql, "media", handle)
|
||||
date_handle = self.get_link(sql, "media", handle, "date")
|
||||
date = self.get_date(sql, date_handle)
|
||||
|
||||
self.db.media_map[str(handle)] = (str(handle), gid, path, mime, desc,
|
||||
attribute_list,
|
||||
@ -627,18 +795,21 @@ class SQLReader(object):
|
||||
private)
|
||||
count += 1
|
||||
self.callback(100 * count/total)
|
||||
return None
|
||||
|
||||
t = time.time() - t
|
||||
msg = ngettext('Import Complete: %d second','Import Complete: %d seconds', t ) % t
|
||||
def cleanup(self):
|
||||
self.t = time.time() - self.t
|
||||
msg = ngettext('Import Complete: %d second','Import Complete: %d seconds', self.t ) % self.t
|
||||
self.db.transaction_commit(self.trans,_("SQL import"))
|
||||
self.db.enable_signals()
|
||||
self.db.request_rebuild()
|
||||
print msg
|
||||
return None
|
||||
|
||||
|
||||
def importData(db, filename, callback=None):
|
||||
g = SQLReader(db, filename, callback)
|
||||
g.process()
|
||||
g.cleanup()
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user