def __init__(self, name, include_private=True, include_living=True):
"""Initialize the database object for family tree `name`.
This will raise if the database backend is not `sqlite`.
The constructor does not open/lock the database yet.
Parameters:
- `include_private`: include records marked as private. Default True
- `include_living`: include living people. Default True
"""
self.name = name
self.include_private = include_private
self.include_living = include_living
self.dbstate = DbState()
self.dbman = CLIDbManager(self.dbstate)
self.user = User()
self.smgr = CLIManager(self.dbstate, True, self.user)
self.path = self.dbman.get_family_tree_path(name)
if not self.path:
raise ValueError(
"Family tree {} not found. Known trees: {}".format(
name, self.dbman.family_tree_list()))
self.db_backend = self.get_dbid()
if self.db_backend not in ALLOWED_DB_BACKENDS:
raise ValueError(
"Database backend '{}' of tree '{}' not supported.".format(
self.db_backend, name))
def test_dialog(self):
"""
Tests report dialog integration
"""
uistate = Familychroniclestest.__mock_uistate(TEST_PERSON_ID)
dbstate = DbState()
dbstate.change_database_noclose(self.db)
TextReportDialog(dbstate, uistate, FamilyChroniclesOptions, "Familiy Chronicles", None)
def test_mediapath(self):
"""
Test media path variables.
"""
# Create database
dbstate = DbState()
db = dbstate.make_database("bsddb")
path = get_empty_tempdir("utils_file_test")
db.write_version(path)
db.load(path)
dbstate.change_database(db)
# Test without db.mediapath set
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(USER_HOME))))
self.assertTrue(os.path.exists(media_path(db)))
# Test with absolute db.mediapath
db.set_mediapath(os.path.abspath(USER_HOME) + "/test_abs")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(USER_HOME + "/test_abs"))))
# Test with relative db.mediapath
db.set_mediapath("test_rel")
self.assertEqual(
media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(TEMP_DIR + "/utils_file_test/test_rel")))
)
# Test with environment variable
db.set_mediapath("/test/{VERSION}/test_var")
self.assertEqual(
media_path(db), os.path.normcase(os.path.normpath(os.path.abspath("/test/" + VERSION + "/test_var")))
)
db.set_mediapath("{USER_PLUGINS}/test_var")
self.assertEqual(
media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(USER_PLUGINS + "/test_var")))
)
db.set_mediapath("{VERSION}/test_var")
self.assertEqual(
media_path(db),
os.path.normcase(os.path.normpath(os.path.abspath(TEMP_DIR + "/utils_file_test/" + VERSION + "/test_var"))),
)
# Test with $GRAMPSHOME environment variable not set
old_env = os.environ.copy()
if "GRAMPSHOME" in os.environ:
del os.environ["GRAMPSHOME"]
db.set_mediapath("{GRAMPSHOME}/test_var")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(USER_HOME + "/test_var"))))
# Test with $GRAMPSHOME environment variable set
os.environ["GRAMPSHOME"] = "/this/is/a/test"
db.set_mediapath("{GRAMPSHOME}/test_var")
self.assertEqual(
media_path(db), os.path.normcase(os.path.normpath(os.path.abspath("/this/is/a/test/test_var")))
)
# Restore environment
os.environ = old_env
def show_preview_data(self, widget):
from gramps.gen.dbstate import DbState
from ..quick import run_quick_report_by_name
if widget.proxy_name == "unfiltered":
dbstate = self.dbstate
else:
dbstate = DbState()
dbstate.db = self.proxy_dbase[widget.proxy_name]
dbstate.open = True
run_quick_report_by_name(dbstate, self.uistate, 'filterbyname', 'all')
def setUp(self):
def dummy_callback(dummy):
pass
self.dbstate = DbState()
self.dbman = CLIDbManager(self.dbstate)
dirpath, name = self.dbman.create_new_db_cli("Test: bsddb",
dbid="bsddb")
self._db = self.dbstate.make_database("bsddb")
self._db.load(dirpath, None)
def test_editreference(self):
dbstate = DbState()
dbstate.db = self.db
source = Place()
source.gramps_id = "P0001"
self.db.place_map[source.handle] = source
editor = MockEditReference(dbstate, uistate=None, track=[],
source=source, source_ref=None, update=None)
with patch('gramps.gui.editors.editreference.ErrorDialog') as MockED:
editor.check_for_duplicate_id("Place")
self.assertTrue(MockED.called)
def show_preview_data(self, widget):
from gramps.gen.dbstate import DbState
from ..quick import run_quick_report_by_name
if widget.proxy_name == "unfiltered":
dbstate = self.dbstate
else:
dbstate = DbState()
dbstate.db = self.proxy_dbase[widget.proxy_name]
dbstate.open = True
run_quick_report_by_name(dbstate,
self.uistate,
'filterbyname',
'all')
def test_editreference(self):
dbstate = DbState()
dbstate.db = self.db
source = Place()
source.gramps_id = "P0001"
self.db.place_map[source.handle] = source
editor = MockEditReference(dbstate,
uistate=None,
track=[],
source=source,
source_ref=None,
update=None)
with patch('gramps.gui.editors.editreference.ErrorDialog') as MockED:
editor.check_for_duplicate_id("Place")
self.assertTrue(MockED.called)
def write(self) -> None:
"""Write the example DB to a SQLite DB and change the DB path."""
self.tmp_dbdir = tempfile.mkdtemp()
self.old_path = getconfig("database.path")
setconfig("database.path", self.tmp_dbdir)
dbman = CLIDbManager(DbState())
dbman.import_new_db(self.path, User())
def __init__(self, argparser):
from gramps.gen.dbstate import DbState
from guiQML.viewmanager import ViewManager
from gramps.cli.arghandler import ArgHandler
from PySide import QtGui
self.app = QtGui.QApplication(sys.argv)
dbstate = DbState()
self.vm = ViewManager(dbstate)
#act based on the given arguments
ah = ArgHandler(dbstate, argparser, self.vm, self.argerrorfunc,
gui=True)
ah.handle_args_gui()
if ah.open or ah.imp_db_path:
# if we opened or imported something, only show the interface
self.vm.post_init_interface()
elif config.get('paths.recent-file') and config.get('behavior.autoload'):
# if we need to autoload last seen file, do so
filename = config.get('paths.recent-file')
if os.path.isdir(filename) and \
os.path.isfile(os.path.join(filename, "name.txt")) and \
ah.check_db(filename):
self.vm.open_activate(filename)
self.vm.post_init_interface()
else:
self.vm.post_init_interface()
else:
# open without fam tree loaded
self.vm.post_init_interface()
#start the QT loop
self.app.exec_()
def export_file(db, filename, user):
"""
Export the db to a file (such as a GEDCOM file).
>>> export_file(DbDjango(), "/home/user/Untitled_1.ged", User())
"""
dbstate = DbState()
climanager = CLIManager(dbstate, setloader=False,
user=user) # do not load db_loader
climanager.do_reg_plugins(dbstate, None)
pmgr = BasePluginManager.get_instance()
(name, ext) = os.path.splitext(os.path.basename(filename))
format = ext[1:].lower()
export_list = pmgr.get_reg_exporters()
for pdata in export_list:
if format == pdata.extension:
mod = pmgr.load_plugin(pdata)
if not mod:
for item in pmgr.get_fail_list():
name, error_tuple, pdata = item
etype, exception, traceback = error_tuple
print("ERROR:", name, exception)
return False
export_function = getattr(mod, pdata.export_function)
export_function(db, filename, user)
return True
return False
def import_file(db, filename, user):
"""
Import a file (such as a GEDCOM file) into the given db.
>>> import_file(DbDjango(), "/home/user/Untitled_1.ged", User())
"""
from .grampsdb.models import Person
dbstate = DbState()
climanager = CLIManager(dbstate, setloader=False,
user=user) # do not load db_loader
climanager.do_reg_plugins(dbstate, None)
pmgr = BasePluginManager.get_instance()
(name, ext) = os.path.splitext(os.path.basename(filename))
format = ext[1:].lower()
import_list = pmgr.get_reg_importers()
for pdata in import_list:
if format == pdata.extension:
mod = pmgr.load_plugin(pdata)
if not mod:
for item in pmgr.get_fail_list():
name, error_tuple, pdata = item
# (filename, (exception-type, exception, traceback), pdata)
etype, exception, traceback = error_tuple
print("ERROR:", name, exception)
return False
import_function = getattr(mod, pdata.import_function)
db.prepare_import()
retval = import_function(db, filename, user)
db.commit_import()
return retval
return False
def setUpClass(cls):
cls.name = "Test Web API"
cls.dbman = CLIDbManager(DbState())
_, _name = cls.dbman.create_new_db_cli(cls.name, dbid="sqlite")
with patch.dict("os.environ", {ENV_CONFIG_FILE: TEST_CONFIG}):
cls.app = create_app()
cls.app.config["TESTING"] = True
cls.client = cls.app.test_client()
def __init__(self, user=None, dbstate=None):
## Setup:
from gramps.cli.clidbman import CLIDbManager
self.dbstate = dbstate or DbState()
#we need a manager for the CLI session
self.user = user or User()
self.climanager = CLIManager(self.dbstate, setloader=True, user=self.user)
self.clidbmanager = CLIDbManager(self.dbstate)
def test_editreference(self):
dbstate = DbState()
db = make_database("bsddb")
path = "/tmp/edit_ref_test"
try:
os.mkdir(path)
except:
pass
db.load(path)
dbstate.change_database(db)
source = Place()
source.gramps_id = "P0001"
dbstate.db.place_map[source.handle] = source.serialize()
editor = MockEditReference(dbstate, uistate=None, track=[],
source=source, source_ref=None, update=None)
with patch('gramps.gui.editors.editreference.ErrorDialog') as MockED:
editor.check_for_duplicate_id("Place")
self.assertTrue(MockED.called)
def setUp(self):
def dummy_callback(dummy):
pass
self.dbstate = DbState()
self.dbman = CLIDbManager(self.dbstate)
dirpath, name = self.dbman.create_new_db_cli("Test: bsddb", dbid="bsddb")
self._db = self.dbstate.make_database("bsddb")
self._db.load(dirpath, None)
def __init__(self, argparser):
from gramps.gen.dbstate import DbState
from . import viewmanager
from .viewmanager import ViewManager
from gramps.cli.arghandler import ArgHandler
from .tipofday import TipOfDay
from .dialog import WarningDialog
import gettext
_display_welcome_message()
register_stock_icons()
if lin() and glocale.lang != 'C' and not gettext.find(GTK_GETTEXT_DOMAIN):
LOG.warn("GTK translations missing, GUI will be broken, especially for RTL languages!")
# Note: the warning dialog below will likely have wrong stock icons!
# Translators: the current language will be the one you translate into.
WarningDialog(
_("Gramps detected an incomplete GTK installation"),
_("GTK translations for the current language (%(language)s) "
"are missing.\n%(bold_start)sGramps%(bold_end)s will "
"proceed nevertheless.\nThe GUI will likely be broken "
"as a result, especially for RTL languages!\n\n"
"See the Gramps README documentation for installation "
"prerequisites,\ntypically located in "
"/usr/share/doc/gramps.\n") % {
'language' : glocale.lang ,
'bold_start' : '<b>' ,
'bold_end' : '</b>' } )
dbstate = DbState()
self.vm = ViewManager(dbstate,
config.get("interface.view-categories"))
self.vm.init_interface()
#act based on the given arguments
ah = ArgHandler(dbstate, argparser, self.vm, self.argerrorfunc,
gui=True)
ah.handle_args_gui()
if ah.open or ah.imp_db_path:
# if we opened or imported something, only show the interface
self.vm.post_init_interface(show_manager=False)
elif config.get('paths.recent-file') and config.get('behavior.autoload'):
# if we need to autoload last seen file, do so
filename = config.get('paths.recent-file')
if os.path.isdir(filename) and \
os.path.isfile(os.path.join(filename, "name.txt")) and \
ah.check_db(filename):
self.vm.post_init_interface(show_manager=False)
self.vm.open_activate(filename)
else:
self.vm.post_init_interface()
else:
# open without fam tree loaded
self.vm.post_init_interface()
if config.get('behavior.use-tips'):
TipOfDay(self.vm.uistate)
def setUpClass(cls):
# print("doing setup with", cls.param)
set_det_id(True) # handles must be deterministic for this test
cls.dbstate = DbState()
cls.dbman = CLIDbManager(cls.dbstate)
dirpath, _name = cls.dbman.create_new_db_cli("Test: %s" % cls.param,
dbid=cls.param)
cls.db = make_database(cls.param)
cls.db.load(dirpath, None)
def setUp(self):
def dummy_callback(dummy):
pass
self._tmpdir = tempfile.mkdtemp()
self._db = DbBsddb()
dbman = CLIDbManager(DbState())
self._filename, title = dbman.create_new_db_cli(title="Test")
self._db.load(self._filename, dummy_callback, "w")
def test_editreference(self):
dbstate = DbState()
db = dbstate.make_database("bsddb")
path = "/tmp/edit_ref_test"
try:
os.mkdir(path)
except:
pass
db.write_version(path)
db.load(path)
dbstate.change_database(db)
source = Place()
source.gramps_id = "P0001"
dbstate.db.place_map[source.handle] = source.serialize()
editor = MockEditReference(dbstate, uistate=None, track=[],
source=source, source_ref=None, update=None)
with patch('gramps.gui.editors.editreference.ErrorDialog') as MockED:
editor.check_for_duplicate_id("Place")
self.assertTrue(MockED.called)
def _get_path(self) -> str:
"""Get the path of the family tree database."""
dbstate = DbState() # dbstate instance used only for this method
dbman = CLIDbManager(dbstate)
path = dbman.get_family_tree_path(self.name)
if path is None:
raise ValueError(
"Database path for family tree '{}' not found in databse directory {}"
.format(self.name, config.get("database.path")))
return path
def setUpClass(cls):
cls.name = "Test Web API"
cls.dbman = CLIDbManager(DbState())
_, _name = cls.dbman.create_new_db_cli(cls.name, dbid="sqlite")
with patch.dict("os.environ", {ENV_CONFIG_FILE: TEST_AUTH_CONFIG}):
cls.app = create_app()
cls.app.config["TESTING"] = True
cls.client = cls.app.test_client()
sqlauth = cls.app.config["AUTH_PROVIDER"]
sqlauth.create_table()
sqlauth.add_user(name="user", password="******")
def setUp(self):
from gramps.cli.clidbman import CLIDbManager
from gramps.gen.config import set as setconfig, get as getconfig
from gramps.gen.dbstate import DbState
self.newpath = os.path.join(os.path.dirname(__file__),
'\u0393\u03c1\u03b1\u03bc\u03c3\u03c0')
self.newtitle = 'Gr\u00e4mps T\u00e9st'
os.makedirs(self.newpath)
self.old_path = getconfig('database.path')
setconfig('database.path', self.newpath)
self.cli = CLIDbManager(DbState())
def setUp(self):
self.name = "Test Web API"
self.dbman = CLIDbManager(DbState())
_, _name = self.dbman.create_new_db_cli(self.name, dbid="sqlite")
with patch.dict("os.environ", {ENV_CONFIG_FILE: TEST_AUTH_CONFIG}):
self.app = create_app()
self.app.config["TESTING"] = True
self.client = self.app.test_client()
sqlauth = self.app.config["AUTH_PROVIDER"]
sqlauth.create_table()
self.ctx = self.app.test_request_context()
self.ctx.push()
def __init__(self, argparser):
from gramps.gen.dbstate import DbState
from . import viewmanager
from .viewmanager import ViewManager
from gramps.cli.arghandler import ArgHandler
from .tipofday import TipOfDay
import gettext
# Append image directory to the theme search path
theme = Gtk.IconTheme.get_default()
theme.append_search_path(IMAGE_DIR)
dbstate = DbState()
self._vm = ViewManager(dbstate,
config.get("interface.view-categories"))
if (lin() and glocale.lang != 'C'
and not gettext.find(GTK_GETTEXT_DOMAIN)):
_display_gtk_gettext_message(parent=self._vm.window)
#_display_welcome_message(parent=self._vm.window)
_display_translator_message(parent=self._vm.window)
self._vm.init_interface()
#act based on the given arguments
arg_h = ArgHandler(dbstate,
argparser,
self._vm,
self.argerrorfunc,
gui=True)
arg_h.handle_args_gui()
if arg_h.open or arg_h.imp_db_path:
# if we opened or imported something, only show the interface
self._vm.post_init_interface(show_manager=False)
elif (config.get('paths.recent-file')
and config.get('behavior.autoload')):
# if we need to autoload last seen file, do so
filename = config.get('paths.recent-file')
if (os.path.isdir(filename)
and os.path.isfile(os.path.join(filename, "name.txt"))
and arg_h.check_db(filename)):
self._vm.post_init_interface(show_manager=False)
self._vm.open_activate(filename)
else:
self._vm.post_init_interface()
else:
# open without fam tree loaded
self._vm.post_init_interface()
if config.get('behavior.use-tips'):
TipOfDay(self._vm.uistate)
def get_db(self, force_unlock: bool = False) -> DbState:
"""Open the database and return a dbstate instance.
If `force_unlock` is `True`, will break an existing lock (use with care!).
"""
dbstate = DbState()
user = User()
smgr = CLIManager(dbstate, True, user)
if force_unlock:
self.break_lock()
smgr.open_activate(self.path)
return dbstate
def __init__(self, name: str = None) -> None:
"""Prepare and import the example DB."""
ExampleDbBase.__init__(self)
self.db_path = os.path.join(os.environ["GRAMPSHOME"], "gramps",
"grampsdb")
os.makedirs(self.db_path, exist_ok=True)
setconfig("database.path", self.db_path)
dbstate = DbState()
dbman = CLIDbManager(dbstate)
user = User()
smgr = CLIManager(dbstate, True, user)
smgr.do_reg_plugins(dbstate, uistate=None)
self.path, self.name = dbman.import_new_db(self.path, User())
WebDbManager.__init__(self, self.name)
def setUpClass(cls):
cls.name = "Test Web API"
cls.dbman = CLIDbManager(DbState())
cls.dbman.create_new_db_cli(cls.name, dbid="sqlite")
with patch.dict("os.environ", {ENV_CONFIG_FILE: TEST_AUTH_CONFIG}):
cls.app = create_app()
cls.app.config["TESTING"] = True
cls.media_base_dir = tempfile.mkdtemp()
cls.app.config["MEDIA_BASE_DIR"] = cls.media_base_dir
cls.client = cls.app.test_client()
sqlauth = cls.app.config["AUTH_PROVIDER"]
sqlauth.create_table()
sqlauth.add_user(name="user", password="******", role=ROLE_GUEST)
sqlauth.add_user(name="admin", password="******", role=ROLE_OWNER)
def test_editreference(self):
dbstate = DbState()
db = make_database("sqlite")
path = "/tmp/edit_ref_test"
try:
os.mkdir(path)
except:
pass
db.load(path)
dbstate.change_database(db)
source = Place()
source.gramps_id = "P0001"
with DbTxn("test place", dbstate.db) as trans:
dbstate.db.add_place(source, trans)
editor = MockEditReference(dbstate,
uistate=None,
track=[],
source=source,
source_ref=None,
update=None)
with patch('gramps.gui.editors.editreference.ErrorDialog') as MockED:
editor.check_for_duplicate_id("Place")
self.assertTrue(MockED.called)
def get_db(self, lock: bool = False, force_unlock: bool = False) -> DbState:
"""Open the database and return a dbstate instance.
If `lock` is `False`, will not write a lock file (use with care!).
If `force_unlock` is `True`, will break an existing lock (use with care!).
"""
dbstate = DbState()
user = User()
smgr = WebDbSessionManager(dbstate, user)
smgr.do_reg_plugins(dbstate, uistate=None)
if force_unlock:
self.break_lock()
mode = DBMODE_W if lock else DBMODE_R
smgr.open_activate(self.path, mode=mode)
return dbstate
def setUpClass(cls):
cls.name = "Test Web API"
cls.dbman = CLIDbManager(DbState())
cls.dbman.create_new_db_cli(cls.name, dbid="sqlite")
with patch.dict("os.environ", {ENV_CONFIG_FILE: TEST_AUTH_CONFIG}):
cls.app = create_app()
cls.app.config["TESTING"] = True
cls.client = cls.app.test_client()
sqlauth = cls.app.config["AUTH_PROVIDER"]
sqlauth.create_table()
sqlauth.add_user(name="user", password="******", role=ROLE_GUEST)
sqlauth.add_user(name="contributor", password="******", role=ROLE_CONTRIBUTOR)
sqlauth.add_user(name="admin", password="******", role=ROLE_OWNER)
sqlauth.add_user(name="editor", password="******", role=ROLE_EDITOR)
sqlauth.add_user(name="member", password="******", role=ROLE_MEMBER)
def test_example_db_sqlite(self):
"""Test the SQLite example DB."""
test_grampshome = tempfile.mkdtemp()
os.environ["GRAMPSHOME"] = test_grampshome
db = ExampleDbSQLite()
self.assertEqual(getconfig("database.path"), db.db_path)
dbman = CLIDbManager(DbState())
db_info = dbman.current_names
# there is only one DB here
self.assertEqual(len(db_info), 1)
# DB name
self.assertEqual(db_info[0][0], "example")
# DB path
self.assertEqual(os.path.dirname(db_info[0][1]), db.db_path)
# DB cleanup
shutil.rmtree(test_grampshome)
self.assertTrue(not os.path.exists(test_grampshome))
def setUpClass(cls):
cls.name = "Test Web API"
cls.dbman = CLIDbManager(DbState())
_, _name = cls.dbman.create_new_db_cli(cls.name, dbid="sqlite")
cls.config_file = tempfile.NamedTemporaryFile(delete=False)
cls.user_db = tempfile.NamedTemporaryFile(delete=False)
config = """TREE="Test Web API"
SECRET_KEY="C2eAhXGrXVe-iljXTjnp4paeRT-m68pq"
USER_DB_URI="sqlite:///{}"
""".format(cls.user_db.name)
with open(cls.config_file.name, "w") as f:
f.write(config)
with patch.dict("os.environ", {ENV_CONFIG_FILE: cls.config_file.name}):
cls.app = create_app()
cls.app.config["TESTING"] = True
cls.client = cls.app.test_client()
cls.runner = CliRunner()
def run_report(db, name, **options_str_dict):
"""
Given a database, run a given report.
db is a Db database
name is the name of a report
options_str_dict is the same kind of options
given at the command line. For example:
>>> run_report(db, "ancestor_report", off="txt",
of="ancestor-007.txt", pid="I37")
returns CommandLineReport (clr) if successfully runs the report,
None otherwise.
You can see:
options and values used in clr.option_class.options_dict
filename in clr.option_class.get_output()
"""
dbstate = DbState()
climanager = CLIManager(dbstate, setloader=False, user=User()) # don't load db
climanager.do_reg_plugins(dbstate, None)
pmgr = BasePluginManager.get_instance()
cl_list = pmgr.get_reg_reports()
clr = None
for pdata in cl_list:
if name == pdata.id:
mod = pmgr.load_plugin(pdata)
if not mod:
#import of plugin failed
return clr
category = pdata.category
report_class = getattr(mod, pdata.reportclass)
options_class = getattr(mod, pdata.optionclass)
if category in (CATEGORY_BOOK, CATEGORY_CODE):
options_class(db, name, category,
options_str_dict)
else:
clr = cl_report(db, name, category,
report_class, options_class,
options_str_dict)
return clr
return clr
def get_plugin_options(db, pid):
"""
Get the default options and help for this plugin.
"""
dbstate = DbState()
climanager = CLIManager(dbstate, setloader=False,
user=GUser()) # do not load db_loader
climanager.do_reg_plugins(dbstate, None)
pmgr = BasePluginManager.get_instance()
pdata = pmgr.get_plugin(pid)
if hasattr(pdata, "optionclass") and pdata.optionclass:
mod = pmgr.load_plugin(pdata)
optionclass = eval("mod." + pdata.optionclass)
optioninstance = optionclass("Name", db)
optioninstance.load_previous_values()
return optioninstance.options_dict, optioninstance.options_help
else:
return {}, {}
if commit:
db.transaction_commit(tran)
tran = None
def print_db_content(db):
for h in db.get_person_handles():
print("DB contains: person %s" % h)
for h in db.get_source_handles():
print("DB contains: source %s" % h)
tmpdir = tempfile.mkdtemp()
try:
filename1 = os.path.join(tmpdir,'test1.grdb')
filename2 = os.path.join(tmpdir,'test2.grdb')
print("\nUsing Database file: %s" % filename1)
dbstate = DbState()
dbman = CLIDbManager(dbstate)
dirpath, name = dbman.create_new_db_cli(filename1, dbid="bsddb")
db = dbstate.make_database("bsddb")
db.load(dirpath, None)
print("Add person 1")
add_person( db,"Anton", "Albers",True,False)
print("Add source")
add_source( db,"A short test",True,False)
print("Add person 2 without commit")
add_person( db,"Bernd","Beta",False,False)
print("Add source")
add_source( db,"A short test",True,False)
print("Add person 3")
add_person( db,"Chris","Connor",True,False)
print_db_content( db)
class GrampsConnect(Application):
"""
Main Gramps Connect webapp class
"""
def __init__(self, options, settings=None):
self.options = options
if settings is None:
settings = self.default_settings()
if self.options.database is None:
raise Exception("Need to specify Gramps Family Tree name with --database='NAME'")
else:
self.database = DbState().open_database(self.options.database)
if self.database is None:
raise Exception("Unable to open database '%s'" % self.options.database)
self.sitename = self.options.sitename
super().__init__([
url(r"/", HomeHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="main"),
url(r'/login', LoginHandler,
{
"sitename": self.sitename,
"opts" : self.options,
},
name="login"),
url(r'/logout', LogoutHandler,
{
"sitename": self.sitename,
"opts" : self.options,
},
name="logout"),
url(r'/(.*)/(.*)/delete', DeleteHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
),
url(r'/action/?(.*)', ActionHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="action"),
url(r'/person/?(.*)', PersonHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="person"),
url(r'/note/?(.*)', NoteHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="note"),
url(r'/family/?(.*)', FamilyHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="family"),
url(r'/citation/?(.*)', CitationHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="citation"),
url(r'/event/?(.*)', EventHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="event"),
url(r'/media/?(.*)', MediaHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="media"),
url(r'/place/?(.*)', PlaceHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="place"),
url(r'/repository/?(.*)', RepositoryHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="repository"),
url(r'/source/?(.*)', SourceHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="source"),
url(r'/tag/?(.*)', TagHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="tag"),
url(r'/imageserver/(.*)', ImageHandler,
{
"database": self.database,
"opts" : self.options,
"HOMEDIR": self.options.home_dir,
"PORT": self.options.port,
"HOSTNAME": self.options.hostname,
"GET_IMAGE_FN": self.get_image_path_from_handle,
"sitename": self.sitename,
},
name="imageserver",
),
url(r"/json/", JsonHandler,
{
"database": self.database,
}
),
url(r"/data/(.*)", StaticFileHandler,
{
'path': self.options.data_dir,
}),
url(r"/css/(.*)", StaticFileHandler,
{
'path': os.path.join(gramps.gen.const.DATA_DIR, "css"),
}),
url(r"/images/(.*)", StaticFileHandler,
{
'path': os.path.join(gramps.gen.const.DATA_DIR, "images"),
}),
url(r"/misc/(.*)", StaticFileHandler,
{
'path': gramps.gen.const.IMAGE_DIR,
}),
url(r"/img/(.*)", StaticFileHandler,
{
'path': os.path.join(gramps.gen.const.PLUGINS_DIR, "webstuff", "img"),
}),
], **settings)
def default_settings(self):
"""
"""
return {
"cookie_secret": base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes),
"login_url": "/login",
'template_path': os.path.join(self.options.data_dir, "templates"),
'debug': self.options.debug,
"xsrf_cookies": self.options.xsrf,
}
def get_image_path_from_handle(self, identifier):
"""
Given an image handle, return the full path/filename.
"""
media = self.database.get_media_from_handle(identifier)
if media:
return media_path_full(self.database, media.get_path())
return ""
def __init__(self, options, settings=None):
self.options = options
if settings is None:
settings = self.default_settings()
if self.options.database is None:
raise Exception("Need to specify Gramps Family Tree name with --database='NAME'")
else:
self.database = DbState().open_database(self.options.database)
if self.database is None:
raise Exception("Unable to open database '%s'" % self.options.database)
self.sitename = self.options.sitename
super().__init__([
url(r"/", HomeHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="main"),
url(r'/login', LoginHandler,
{
"sitename": self.sitename,
"opts" : self.options,
},
name="login"),
url(r'/logout', LogoutHandler,
{
"sitename": self.sitename,
"opts" : self.options,
},
name="logout"),
url(r'/(.*)/(.*)/delete', DeleteHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
),
url(r'/action/?(.*)', ActionHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="action"),
url(r'/person/?(.*)', PersonHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="person"),
url(r'/note/?(.*)', NoteHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="note"),
url(r'/family/?(.*)', FamilyHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="family"),
url(r'/citation/?(.*)', CitationHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="citation"),
url(r'/event/?(.*)', EventHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="event"),
url(r'/media/?(.*)', MediaHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="media"),
url(r'/place/?(.*)', PlaceHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="place"),
url(r'/repository/?(.*)', RepositoryHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="repository"),
url(r'/source/?(.*)', SourceHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="source"),
url(r'/tag/?(.*)', TagHandler,
{
"database": self.database,
"sitename": self.sitename,
"opts" : self.options,
},
name="tag"),
url(r'/imageserver/(.*)', ImageHandler,
{
"database": self.database,
"opts" : self.options,
"HOMEDIR": self.options.home_dir,
"PORT": self.options.port,
"HOSTNAME": self.options.hostname,
"GET_IMAGE_FN": self.get_image_path_from_handle,
"sitename": self.sitename,
},
name="imageserver",
),
url(r"/json/", JsonHandler,
{
"database": self.database,
}
),
url(r"/data/(.*)", StaticFileHandler,
{
'path': self.options.data_dir,
}),
url(r"/css/(.*)", StaticFileHandler,
{
'path': os.path.join(gramps.gen.const.DATA_DIR, "css"),
}),
url(r"/images/(.*)", StaticFileHandler,
{
'path': os.path.join(gramps.gen.const.DATA_DIR, "images"),
}),
url(r"/misc/(.*)", StaticFileHandler,
{
'path': gramps.gen.const.IMAGE_DIR,
}),
url(r"/img/(.*)", StaticFileHandler,
{
'path': os.path.join(gramps.gen.const.PLUGINS_DIR, "webstuff", "img"),
}),
], **settings)
class GrampsDbBaseTest(unittest.TestCase):
"""Base class for unittest that need to be able to create
test databases."""
def setUp(self):
def dummy_callback(dummy):
pass
self.dbstate = DbState()
self.dbman = CLIDbManager(self.dbstate)
dirpath, name = self.dbman.create_new_db_cli("Test: bsddb", dbid="bsddb")
self._db = self.dbstate.make_database("bsddb")
self._db.load(dirpath, None)
def tearDown(self):
self._db.close()
self.dbman.remove_database("Test: bsddb")
def _populate_database(self,
num_sources = 1,
num_persons = 0,
num_families = 0,
num_events = 0,
num_places = 0,
num_media_objects = 0,
num_links = 1):
# start with sources
sources = []
for i in range(num_sources):
sources.append(self._add_source())
# now for each of the other tables. Give each entry a link
# to num_link sources, sources are chosen on a round robin
# basis
for num, add_func in ((num_persons, self._add_person_with_sources),
(num_families, self._add_family_with_sources),
(num_events, self._add_event_with_sources),
(num_places, self._add_place_with_sources),
(num_media_objects, self._add_media_object_with_sources)):
source_idx = 1
for person_idx in range(num):
# Get the list of sources to link
lnk_sources = set()
for i in range(num_links):
lnk_sources.add(sources[source_idx-1])
source_idx = (source_idx+1) % len(sources)
try:
add_func(lnk_sources)
except:
print ("person_idx = ", person_idx)
print ("lnk_sources = ", repr(lnk_sources))
raise
return
def _add_source(self,repos=None):
# Add a Source
with DbTxn("Add Source and Citation", self._db) as tran:
source = Source()
if repos is not None:
repo_ref = RepoRef()
repo_ref.set_reference_handle(repos.get_handle())
source.add_repo_reference(repo_ref)
self._db.add_source(source, tran)
self._db.commit_source(source, tran)
citation = Citation()
citation.set_reference_handle(source.get_handle())
self._db.add_citation(citation, tran)
self._db.commit_citation(citation, tran)
return citation
def _add_repository(self):
# Add a Repository
with DbTxn("Add Repository", self._db) as tran:
repos = Repository()
self._db.add_repository(repos, tran)
self._db.commit_repository(repos, tran)
return repos
def _add_object_with_source(self, citations, object_class, add_method,
commit_method):
object = object_class()
with DbTxn("Add Object", self._db) as tran:
for citation in citations:
object.add_citation(citation.get_handle())
add_method(object, tran)
commit_method(object, tran)
return object
def _add_person_with_sources(self, citations):
return self._add_object_with_source(citations,
Person,
self._db.add_person,
self._db.commit_person)
def _add_family_with_sources(self, citations):
return self._add_object_with_source(citations,
Family,
self._db.add_family,
self._db.commit_family)
def _add_event_with_sources(self, citations):
return self._add_object_with_source(citations,
Event,
self._db.add_event,
self._db.commit_event)
def _add_place_with_sources(self, citations):
return self._add_object_with_source(citations,
Place,
self._db.add_place,
self._db.commit_place)
def _add_media_object_with_sources(self, citations):
return self._add_object_with_source(citations,
MediaObject,
self._db.add_object,
self._db.commit_media_object)
