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 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, 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 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 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 = make_database("bsddb")
self._db.load(dirpath, None)
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 _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 setUp(self):
def dummy_callback(dummy):
pass
self._tmpdir = tempfile.mkdtemp()
self._db = DbBsddb()
dbman = CLIDbManager(None)
self._filename, title = dbman.create_new_db_cli(title=cuni("Test"))
self._db.load(self._filename, dummy_callback, "w")
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 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):
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, 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 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 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 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 test_example_db_sqlite(self):
"""Test the SQLite example DB."""
db = ExampleDbSQLite()
db.write()
self.assertEqual(getconfig("database.path"), db.tmp_dbdir)
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.tmp_dbdir)
db.delete()
# just check that this is not at the tmp dir anymore
self.assertNotEqual(getconfig("database.path"), db.tmp_dbdir)
# ... and that the tmp dir is gone
self.assertTrue(not os.path.exists(db.tmp_dbdir))
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="******", role=ROLE_GUEST)
sqlauth.add_user(name="admin", password="******", role=ROLE_OWNER)
dbstate = cls.app.config["DB_MANAGER"].get_db(force_unlock=True)
with DbTxn("Add test objects", dbstate.db) as trans:
_add_person(Person.MALE, "John", "Allen", trans, dbstate.db)
_add_person(
Person.FEMALE, "Jane", "Secret", trans, dbstate.db, private=True
)
dbstate.db.close()
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()
sqlauth.add_user(name="user",
password="******",
email="*****@*****.**",
role=ROLE_MEMBER)
sqlauth.add_user(name="owner",
password="******",
email="*****@*****.**",
role=ROLE_OWNER)
self.assertTrue(self.app.testing)
self.ctx = self.app.test_request_context()
self.ctx.push()
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()
sqlauth.add_user(name="user",
password="******",
email="*****@*****.**",
role=ROLE_MEMBER)
sqlauth.add_user(name="admin",
password="******",
email="*****@*****.**",
role=ROLE_OWNER)
self.ctx = self.app.test_request_context()
self.ctx.push()
rv = self.client.post(BASE_URL + "/token/",
json={
"username": "******",
"password": "******"
})
self.header_member = {
"Authorization": f"Bearer {rv.json['access_token']}"
}
rv = self.client.post(BASE_URL + "/token/",
json={
"username": "******",
"password": "******"
})
self.header_owner = {
"Authorization": f"Bearer {rv.json['access_token']}"
}
def setUpClass(cls):
"""Test class setup."""
cls.name = "empty"
cls.dbman = CLIDbManager(DbState())
_, _name = cls.dbman.create_new_db_cli(cls.name, dbid="sqlite")
cls.dbman.create_new_db_cli(cls.name, dbid="sqlite")
with patch.dict(
"os.environ",
{
ENV_CONFIG_FILE: TEST_EMPTY_GRAMPS_AUTH_CONFIG,
"TREE": "empty",
},
):
cls.test_app = create_app()
cls.test_app.config["TESTING"] = True
cls.client = cls.test_app.test_client()
sqlauth = cls.test_app.config["AUTH_PROVIDER"]
sqlauth.create_table()
for role in TEST_USERS:
sqlauth.add_user(
name=TEST_USERS[role]["name"],
password=TEST_USERS[role]["password"],
role=role,
)
def get(self) -> Response:
"""Get active database and application related metadata information."""
catalog = GRAMPS_LOCALE.get_language_dict()
for entry in catalog:
if catalog[entry] == GRAMPS_LOCALE.language[0]:
language_name = entry
break
db_handle = self.db_handle
db_name = db_handle.get_dbname()
db_type = "Unknown"
dbstate = DbState()
db_summary = CLIDbManager(dbstate).family_tree_summary(
database_names=[db_name])
if len(db_summary) == 1:
db_key = GRAMPS_LOCALE.translation.sgettext("Database")
for key in db_summary[0]:
if key == db_key:
db_type = db_summary[0][key]
result = {
"database": {
"id": db_handle.get_dbid(),
"name": db_name,
"type": db_type,
},
"default_person": db_handle.get_default_handle(),
"gramps": {
"version": ENV["VERSION"],
},
"gramps_webapi": {
"schema": VERSION,
"version": VERSION,
},
"locale": {
"lang":
GRAMPS_LOCALE.lang,
"language":
GRAMPS_LOCALE.language[0],
"description":
language_name,
"incomplete_translation":
bool(GRAMPS_LOCALE.language[0] in INCOMPLETE_TRANSLATIONS),
},
"object_counts": {
"people": db_handle.get_number_of_people(),
"families": db_handle.get_number_of_families(),
"sources": db_handle.get_number_of_sources(),
"citations": db_handle.get_number_of_citations(),
"events": db_handle.get_number_of_events(),
"media": db_handle.get_number_of_media(),
"places": db_handle.get_number_of_places(),
"repositories": db_handle.get_number_of_repositories(),
"notes": db_handle.get_number_of_notes(),
"tags": db_handle.get_number_of_tags(),
},
"researcher": db_handle.get_researcher(),
"surnames": db_handle.get_surname_list(),
}
data = db_handle.get_summary()
db_version_key = GRAMPS_LOCALE.translation.sgettext("Database version")
db_module_key = GRAMPS_LOCALE.translation.sgettext(
"Database module version")
db_schema_key = GRAMPS_LOCALE.translation.sgettext("Schema version")
for item in data:
if item == db_version_key:
result["database"]["version"] = data[item]
elif item == db_module_key:
result["database"]["module"] = data[item]
elif item == db_schema_key:
result["database"]["schema"] = data[item]
return self.response(200, result)
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)
print("Closing Database file: %s" % filename1)
def setUpClass(cls):
cls.name = "Test Web Db Manager"
cls.dbman = CLIDbManager(DbState())
dirpath, _name = cls.dbman.create_new_db_cli(cls.name, dbid="sqlite")
cls.db = make_database("sqlite")
