def test_move_term(app, db, taxonomy_tree):
taxonomy = current_flask_taxonomies.get_taxonomy("test_taxonomy")
terms = current_flask_taxonomies.list_taxonomy(taxonomy).all()
print(terms)
ti = TermIdentification(term=terms[2])
current_flask_taxonomies.move_term(ti,
new_parent=terms[0],
remove_after_delete=False)
db.session.commit()
terms = current_flask_taxonomies.list_taxonomy(taxonomy).all()
print(terms)
def test_taxonomy_term_delete_2(app, db, taxonomy_tree, test_record):
taxonomy = current_flask_taxonomies.get_taxonomy("test_taxonomy")
terms = current_flask_taxonomies.list_taxonomy(taxonomy).all()
term = terms[1]
ti = TermIdentification(term=term)
with pytest.raises(DeleteAbortedError):
current_flask_taxonomies.delete_term(ti)
def run():
for res in tqdm(
current_flask_taxonomies.list_taxonomy(
'institutions', return_descendants_count=True)):
tax = res.TaxonomyTerm
if tax.level > 0:
continue
with db.session.begin_nested():
primary_community = tax.slug.strip('/').rsplit('/', maxsplit=1)[-1]
title = tax.extra_data.get('title', {}).get('cs')
provider_type = tax.extra_data.get('type', ['neznámý'])[0]
# TODO: fix this
if len(primary_community) > 60 or not title:
continue
comm_data = {
# "curation_policy": policy,
"id": primary_community,
"description": f'{provider_type} - {title}',
# TODO: "logo": "data/community-logos/ecfunded.jpg"
}
try:
comm = OARepoCommunity.create(comm_data,
id_=primary_community,
title=title,
ctype='other')
except IntegrityError:
traceback.print_exc()
except OARepoCommunityCreateError as e:
traceback.print_exc()
db.session.commit()
def find_in_title(field: str, taxonomy_code: str, first_lang: str = "cs", second_lang: str = "en"):
sqlalchemy_query = current_flask_taxonomies.list_taxonomy(taxonomy_code)
sqlalchemy_query = current_flask_taxonomies.apply_term_query(sqlalchemy_query,
f'title.{first_lang}:"{field}" OR '
f'title.{second_lang}:"{field}"',
taxonomy_code)
return sqlalchemy_query
def test_import_taxonomy(app, db):
file_path = pathlib.Path(__file__).parent.absolute()
data_path = file_path / "data" / "licenses_v2.xlsx"
import_taxonomy(str(data_path))
taxonomy = current_flask_taxonomies.list_taxonomies(session=None).all()[0]
taxonomy_list = current_flask_taxonomies.list_taxonomy(taxonomy).all()
assert len(taxonomy_list) > 0
assert isinstance(taxonomy_list[1], TaxonomyTerm)
def test_query(app, db):
sqlalchemy_query = current_flask_taxonomies.list_taxonomy('countries')
sqlalchemy_query = current_flask_taxonomies.apply_term_query(
sqlalchemy_query, 'title.cs:"Angola" OR '
'title.en:"Anglola"', "countries")
print("\n\nQUERY:", sqlalchemy_query, "\n\n")
term = sqlalchemy_query.one_or_none()
assert isinstance(term, TaxonomyTerm)
assert term.slug == 'ao'
def test_taxonomy_term_moved(app, db, taxonomy_tree, test_record):
taxonomy = current_flask_taxonomies.get_taxonomy("test_taxonomy")
terms = current_flask_taxonomies.list_taxonomy(taxonomy).all()
old_record = Record.get_record(id_=test_record.id)
old_taxonomy = old_record["taxonomy"]
assert old_taxonomy == [{
'is_ancestor': True,
'level': 1,
'links': {
'self': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a'
},
'test': 'extra_data'
},
{
'is_ancestor': True,
'level': 2,
'links': {
'parent':
'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a',
'self': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b'
},
'test': 'extra_data'
},
{
'is_ancestor': False,
'level': 3,
'links': {
'parent':
'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b',
'self':
'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b/c'
},
'test': 'extra_data'
}]
ti = TermIdentification(term=terms[2])
current_flask_taxonomies.move_term(ti, new_parent=terms[0], remove_after_delete=False)
db.session.commit()
new_record = Record.get_record(id_=test_record.id)
new_taxonomy = new_record["taxonomy"]
new_terms = current_flask_taxonomies.list_taxonomy(taxonomy).all()
assert new_terms[-1].parent_id == 1
def test_create_update_terms(app, db, taxonomy_data):
taxonomy = current_flask_taxonomies.create_taxonomy(
"licenses", extra_data={"title": {
"cs": "Licence",
"en": "Licenses"
}})
create_update_terms(taxonomy, taxonomy_data) # creating
create_update_terms(taxonomy, taxonomy_data) # updating
res = current_flask_taxonomies.list_taxonomy(taxonomy).all()
assert res[0].slug == "cc"
assert res[0].level == 0
assert res[1].slug == "cc/1-0"
assert res[1].level == 1
def export_taxonomy(taxonomy_code: str):
# get cwd path
cwd = pathlib.Path().absolute()
path = str(cwd / f"{taxonomy_code}.csv")
# get taxonomy flatten dicts (header and content)
taxonomy = current_flask_taxonomies.get_taxonomy(taxonomy_code)
first_level_list = current_flask_taxonomies.list_taxonomy(taxonomy,
levels=1).all()
taxonomy_header_dict = get_taxonomy_header_dict(taxonomy)
taxonomy_terms_list = get_taxonomy_terms_list(first_level_list)
csv_path = convert_to_csv(path, taxonomy_terms_list)
excel_path = convert_csv_to_excel(path, taxonomy_header_dict)
return csv_path, excel_path
def test_get_taxonomy_terms_list(app, db):
file_path = pathlib.Path(__file__).parent.absolute()
data_path = file_path / "data" / "licenses_v2.xlsx"
str_path = str(data_path)
import_taxonomy(str_path)
taxonomy = current_flask_taxonomies.get_taxonomy("licenses")
first_level = current_flask_taxonomies.list_taxonomy(taxonomy,
levels=1).all()
res = get_taxonomy_terms_list(first_level)
assert res[0]["level"] == 1
assert res[1]["level"] == 2
assert res[2]["level"] == 3
assert res[3]["level"] == 3
assert res[8]["level"] == 2
def test_taxonomy_term_delete(app, db, taxonomy_tree):
taxonomy = current_flask_taxonomies.get_taxonomy("test_taxonomy")
terms = current_flask_taxonomies.list_taxonomy(taxonomy).all()
term = terms[1]
ti = TermIdentification(term=term)
current_flask_taxonomies.delete_term(ti)
def find_in_json_list(taxonomy_code: str, field: str, value: str):
sqlalchemy_query = current_flask_taxonomies.list_taxonomy(f'{taxonomy_code}')
sqlalchemy_query = sqlalchemy_query.filter(
func.jsonb_extract_path(TaxonomyTerm.extra_data, field).op('?')(
value))
return sqlalchemy_query
def find_in_title_jsonb(value: str, taxonomy_code: str, lang: str = "cs"):
json_ = '{"title": {"%s": "%s"}}' % (lang, value)
sqlalchemy_query = current_flask_taxonomies.list_taxonomy(taxonomy_code)
sqlalchemy_query = sqlalchemy_query.filter(TaxonomyTerm.extra_data.op("@>")(json_))
return sqlalchemy_query
def get_query_by_slug(taxonomy_code: str, slug: str):
slug = f"*.{slug.lower()}"
sqlalchemy_query = current_flask_taxonomies.list_taxonomy(f'{taxonomy_code}')
sqlalchemy_query = sqlalchemy_query.filter(
TaxonomyTerm.slug.op('~')(slug))
return sqlalchemy_query
def find_in_json(taxonomy_code: str, field: str, value: str):
sqlalchemy_query = current_flask_taxonomies.list_taxonomy(taxonomy_code)
sqlalchemy_query = current_flask_taxonomies.apply_term_query(sqlalchemy_query,
f'{field}:{value}', taxonomy_code)
return sqlalchemy_query
def get_role(role):
sqlalchemy_query = current_flask_taxonomies.list_taxonomy(
'contributor-type')
sqlalchemy_query = current_flask_taxonomies.apply_term_query(
sqlalchemy_query, f'title.en:"{role}"', "contributor-type")
return sqlalchemy_query.one_or_none()
def get_taxonomy(code=None,
prefer=None,
page=None,
size=None,
status_code=200,
q=None):
try:
taxonomies = current_flask_taxonomies.filter_taxonomy(
code,
return_descendants_count=INCLUDE_DESCENDANTS_COUNT in prefer,
return_descendants_busy_count=INCLUDE_STATUS in prefer)
taxonomy = taxonomies.one()
taxonomy = enrich_data_with_computed(taxonomy)
except NoResultFound:
json_abort(404, {})
return # make pycharm happy
current_flask_taxonomies.permissions.taxonomy_read.enforce(request=request,
status_code=404)
prefer = taxonomy.merge_select(prefer)
try:
if INCLUDE_SELF in prefer:
paginator = Paginator(
prefer, [taxonomy],
page=0,
size=0,
json_converter=lambda data: [x.json(prefer) for x in data],
envelope_links=lambda prefer, data, original_data:
original_data[0].links(prefer)
if original_data else EnvelopeLinks({}, {}),
single_result=True,
allow_empty=False)
if INCLUDE_DESCENDANTS not in prefer:
return paginator.jsonify(status_code=status_code)
else:
paginator = None
if INCLUDE_DESCENDANTS in prefer:
if INCLUDE_DELETED in prefer:
status_cond = sqlalchemy.sql.true()
else:
status_cond = TaxonomyTerm.status == TermStatusEnum.alive
descendants = current_flask_taxonomies.list_taxonomy(
taxonomy,
levels=prefer.options.get('levels', None),
status_cond=status_cond,
return_descendants_count=INCLUDE_DESCENDANTS_COUNT in prefer,
return_descendants_busy_count=INCLUDE_STATUS in prefer)
if q:
descendants = current_flask_taxonomies.apply_term_query(
descendants, q, code)
child_exclude = set(prefer.exclude)
child_exclude.discard(INCLUDE_SELF)
child_prefer = prefer.copy(exclude=child_exclude).extend(
include=[INCLUDE_SELF])
child_paginator = Paginator(
child_prefer,
descendants,
page,
size,
json_converter=lambda data: build_descendants(
data, prefer, root_slug=None))
if INCLUDE_SELF in prefer:
paginator.set_children(
child_paginator.paginated_data_without_envelope)
# reset page, size, count from the child paginator
paginator.page = page
paginator.size = size
paginator.count = child_paginator.count
else:
paginator = child_paginator
return paginator.jsonify(status_code=status_code)
except NoResultFound:
json_abort(404, {})
except:
traceback.print_exc()
raise
def test_taxonomy_term_update(app, db, taxonomy_tree, test_record):
taxonomy = current_flask_taxonomies.get_taxonomy("test_taxonomy")
terms = current_flask_taxonomies.list_taxonomy(taxonomy).all()
old_record = Record.get_record(id_=test_record.id)
assert old_record == {
'pid': 1,
'taxonomy': [{
'is_ancestor': True,
'level': 1,
'links': {'self': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a'},
'test': 'extra_data'
},
{
'is_ancestor': True,
'level': 2,
'links': {
'parent': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a',
'self': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b'
},
'test': 'extra_data'
},
{
'is_ancestor': False,
'level': 3,
'links': {
'parent': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b',
'self': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b/c'
},
'test': 'extra_data'
}],
'title': 'record 1'
}
term = terms[-1]
current_flask_taxonomies.update_term(term, extra_data={"new_data": "changed extra data"})
new_record = Record.get_record(id_=test_record.id)
assert new_record == {
'pid': 1,
'taxonomy': [{
'is_ancestor': True,
'level': 1,
'links': {'self': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a'},
'test': 'extra_data'
},
{
'is_ancestor': True,
'level': 2,
'links': {
'parent': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a',
'self': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b'
},
'test': 'extra_data'
},
{
'is_ancestor': False,
'level': 3,
'links': {
'parent': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b',
'self': 'http://127.0.0.1:5000/2.0/taxonomies/test_taxonomy/a/b/c'
},
'new_data': 'changed extra data',
'test': 'extra_data'
}],
'title': 'record 1'
}
