def get_term(slug):
res = current_flask_taxonomies_es.get('licenses', slug)
if not res:
res = get_taxonomy_term(code="licenses", slug=slug)
if not res:
res = current_flask_taxonomies_es.get('licenses', "copyright")
return get_ref_es(res)
def test_set_get_remove(app, db, root_taxonomy, sample_term, sample_term_dict):
current_flask_taxonomies_es.set(sample_term)
time.sleep(1)
result = current_flask_taxonomies_es.get(root_taxonomy.slug, sample_term.slug)
del result['date_of_serialization']
assert result == sample_term_dict
current_flask_taxonomies_es.remove(sample_term)
time.sleep(1)
result = current_flask_taxonomies_es.get(root_taxonomy.slug, sample_term.slug)
assert result is None
def test_after_taxonomy_term_deleted(app, db, sample_term, sample_term_dict):
taxonomy_code = sample_term.taxonomy.slug
slug = sample_term.slug
current_flask_taxonomies_es.set(sample_term)
time.sleep(1)
taxonomy_dict = current_flask_taxonomies_es.get(taxonomy_code, slug)
del taxonomy_dict['date_of_serialization']
assert taxonomy_dict == sample_term_dict
after_taxonomy_term_deleted.connect(delete_taxonomy_term)
after_taxonomy_term_deleted.send(term=sample_term)
time.sleep(1)
term_dict = current_flask_taxonomies_es.get(taxonomy_code, slug)
time.sleep(1)
assert term_dict is None
def test_get_ref(app, db, root_taxonomy, child_term, child_term_dict):
current_flask_taxonomies_es.set(child_term)
time.sleep(1)
res = current_flask_taxonomies_es.get(root_taxonomy.slug, child_term.slug)
res2 = current_flask_taxonomies_es.get_ref(res["links"]["self"])
del res['date_of_serialization']
del res2['date_of_serialization']
assert res == res2 == child_term_dict
def get_ref_by_provider(provider):
provider_slug = get_slug(provider)
if not provider_slug:
return
provider = current_flask_taxonomies_es.get('institutions', provider_slug)
if provider:
return provider
return get_taxonomy_term(TAXONOMY_CODE, provider_slug)
def test_reindex(app, db, root_taxonomy, sample_term, child_term):
current_flask_taxonomies_es.set(sample_term)
time.sleep(1)
term1 = current_flask_taxonomies_es.get(sample_term.taxonomy.slug, sample_term.slug)
timestamp1 = term1['date_of_serialization']
time.sleep(1)
reindex_timestamp = current_flask_taxonomies_es.reindex()
time.sleep(1)
term2 = current_flask_taxonomies_es.get(sample_term.taxonomy.slug, sample_term.slug)
time.sleep(1)
timestamp2 = term2["date_of_serialization"]
assert timestamp1 != timestamp2
time.sleep(1)
terms = current_flask_taxonomies_es.list("root")
assert len(terms) == 2
for term in terms:
assert term['date_of_serialization'] == str(reindex_timestamp)
def get_ref(slug, code):
res = current_flask_taxonomies_es.get(code, slug)
if len(res) > 0 and isinstance(res, dict):
return get_ref_es(res)
tax = Taxonomy.get(code)
term = tax.get_term(slug)
if term is None:
return None
return {"$ref": link_self(tax.slug, term)}
def doctype(self, key, values):
doc_type = values[0].get('a')
es_result = current_flask_taxonomies_es.get("doctypes", doc_type)
if es_result:
return get_ref_es(es_result)
doctype_tax = Taxonomy.get("doctypes", required=True)
doctype = doctype_tax.descendants.filter(
TaxonomyTerm.slug == doc_type).one()
return {"$ref": link_self(doctype_tax.slug, doctype)}
def get_ref(lang, taxonomy):
res = current_flask_taxonomies_es.get("languages", lang)
if len(res) > 0 and isinstance(res, dict):
return get_ref_es(res)
lang_tax = taxonomy.get_term(lang)
if lang_tax is None:
return None
return {
"$ref": link_self(taxonomy.slug, lang_tax)
}
def test_set_remove_2(app, db, root_taxonomy, sample_term):
current_flask_taxonomies_es.set(sample_term)
time.sleep(1)
current_flask_taxonomies_es.remove(
taxonomy_code=sample_term.taxonomy.slug,
slug=sample_term.slug
)
time.sleep(1)
result = current_flask_taxonomies_es.get(root_taxonomy.slug, sample_term.slug)
assert result is None
def get_ref(slug):
res = current_flask_taxonomies_es.get("accessRights", slug)
if len(res) > 0 and isinstance(res, dict):
return get_ref_es(res)
tax = Taxonomy.get("accessRights", required=True)
res = tax.get_term(slug)
if res is None:
return None
return {
"$ref": link_self(res.slug, tax)
}
def get_role(role):
res = current_flask_taxonomies_es.get("contributor-type", role)
if not res:
tax = Taxonomy.get("contributor-type")
term = tax.get_term(role)
if term:
return {
"$ref": link_self(tax.slug, term)
}
else:
return
return get_ref_es(res)
def provider(self, key, value):
nusl_slug = value.get("a")
slug = get_slug(nusl_slug).strip()
if not slug:
return
provider = current_flask_taxonomies_es.get('institutions', slug)
if provider:
return get_ref_es(provider)
tax = Taxonomy.get("institutions", required=True)
provider = tax.descendants.filter(TaxonomyTerm.slug == slug).one() # viz:
# https://stackoverflow.com/questions/29974143/python-sqlalchemy-and-postgres-how-to-query-a
# -json-element
return {"$ref": link_self(tax.slug, provider)}
def test_before_taxonomy_jsonresolve(app, db, sample_term, sample_term_dict):
taxonomy_code = sample_term.taxonomy.slug
slug = sample_term.slug
current_flask_taxonomies_es.set(sample_term)
time.sleep(1)
taxonomy_dict = current_flask_taxonomies_es.get(taxonomy_code, slug)
del taxonomy_dict['date_of_serialization']
assert taxonomy_dict == sample_term_dict
resp = before_taxonomy_jsonresolve.send(None,
code=taxonomy_code,
slug=slug)
sample_term_dict = sample_term_dict
del sample_term_dict["taxonomy"]
assert resp[0][1] == sample_term_dict
def test_subject_1(app, db, overdo_instance):
value = [
{
'2': 'mednas',
'7': 'nlk20040148348',
'a': 'přírodní vědy',
},
{
'2': 'czmesh',
'7': 'D002626',
'a': 'chemie farmaceutická',
},
{
'2': 'czmesh',
'7': 'D002620',
'a': 'farmakologické a toxikologické jevy a procesy',
},
{
'2': 'czenas',
'0': 'ph114722',
'a': 'hudebniny',
},
{
'2': 'czenas',
'0': 'ph114722',
'a': 'hudba',
},
{
'0': 'http://psh.ntkcz.cz/skos/PSH11857',
'2': 'PSH',
'a': 'hudba',
'j': 'music'
},
]
results = subject(overdo_instance, "key", value)
assert len(results) == 6
for result in results:
assert "$ref" in result.keys()
url = urlparse(result["$ref"])
path_array = url.path.split("/")
slug = path_array[-2]
assert current_flask_taxonomies_es.get("subjects", slug) is not None
def find_org_by_slug(slug):
result = current_flask_taxonomies_es.get(TAXONOMY_CODE, slug)
if not result:
result = get_taxonomy_term(code=TAXONOMY_CODE, slug=slug)
return get_ref_es(result)
def test_set_get_child_term(app, db, root_taxonomy, child_term):
current_flask_taxonomies_es.set(child_term)
time.sleep(1)
result = current_flask_taxonomies_es.get(root_taxonomy.slug, child_term.slug)
del result['date_of_serialization']
assert result["path"] == '/1/3'
def get_(taxonomy: str, slug: str):
current_flask_taxonomies_es.get(taxonomy, slug)
