def create_update_taxonomy_post(prefer=None, q=None):
if q:
json_abort(
422, {
'message':
'Query not appropriate when creating or updating taxonomy',
'reason': 'search-query-not-allowed'
})
data = request.json
if 'code' not in data:
abort(Response('Code missing', status=400))
code = data.pop('code')
url = data.pop('url', None)
select = data.pop('select', None)
tax = current_flask_taxonomies.get_taxonomy(code=code, fail=False)
if not tax:
current_flask_taxonomies.permissions.taxonomy_create.enforce(
request=request, code=code)
current_flask_taxonomies.create_taxonomy(code=code,
extra_data=data,
url=url,
select=select)
status_code = 201
else:
current_flask_taxonomies.permissions.taxonomy_update.enforce(
request=request, taxonomy=tax)
current_flask_taxonomies.update_taxonomy(tax,
extra_data=data,
url=url,
select=select)
status_code = 200
current_flask_taxonomies.commit()
return get_taxonomy(code, prefer=prefer, status_code=status_code)
def test_create_taxonomy(app, db):
"""
Test if creating taxonomy working. Test uses SQLite db.
"""
# management task that creates flask-taxonomies tables
# subprocess.run(["invenio", "taxonomies", "init"])
current_flask_taxonomies.create_taxonomy("root", extra_data={}, session=db.session)
db.session.commit()
res = current_flask_taxonomies.list_taxonomies(session=db.session).all()
print(res)
assert len(res) == 1
def test_api(app, db):
taxonomy = current_flask_taxonomies.create_taxonomy("root",
extra_data={},
session=db.session)
db.session.commit()
identification = TermIdentification(taxonomy=taxonomy, slug="a")
term = current_flask_taxonomies.create_term(identification,
extra_data={"a": 1})
assert term.slug == "a"
db.session.commit()
identification2 = TermIdentification(parent=term, slug="b")
term2 = current_flask_taxonomies.create_term(identification2,
extra_data={"b": 2})
assert term2.slug == "a/b"
db.session.commit()
res = current_flask_taxonomies.list_taxonomies().all()
print(res)
# filter
term_identification = TermIdentification(taxonomy=taxonomy, slug=term.slug)
assert list(
current_flask_taxonomies.filter_term(term_identification)) == [term]
assert list(
current_flask_taxonomies.filter_term(
TermIdentification(taxonomy=taxonomy,
slug=term2.slug))) == [term2]
res_term = current_flask_taxonomies.filter_term(
term_identification).one_or_none()
assert isinstance(res_term, TaxonomyTerm)
def taxonomy(app, db):
taxonomy = current_flask_taxonomies.create_taxonomy(
"test_taxonomy",
extra_data={"title": {
"cs": "test_taxonomy",
"en": "test_taxonomy"
}})
db.session.commit()
return taxonomy
def create_update_taxonomy(code=None,
prefer=None,
page=None,
size=None,
q=None):
if q:
json_abort(
422, {
'message':
'Query not appropriate when creating or updating taxonomy',
'reason': 'search-query-not-allowed'
})
tax = current_flask_taxonomies.get_taxonomy(code=code, fail=False)
if tax:
current_flask_taxonomies.permissions.taxonomy_update.enforce(
request=request, taxonomy=tax)
else:
current_flask_taxonomies.permissions.taxonomy_create.enforce(
request=request, code=code)
data = request.json
url = data.pop('url', None)
select = data.pop('select', None)
if not tax:
current_flask_taxonomies.create_taxonomy(code=code,
extra_data=request.json,
url=url,
select=select)
status_code = 201
else:
current_flask_taxonomies.update_taxonomy(tax,
extra_data=request.json,
url=url,
select=select)
status_code = 200
current_flask_taxonomies.commit()
return get_taxonomy(code,
prefer=prefer,
page=page,
size=size,
status_code=status_code)
def test_create(self, db, Taxonomy, TaxonomyTerm):
"""Test create taxonomy."""
tax = current_flask_taxonomies.create_taxonomy('code', {'extra': 'data'})
db.session.add(tax)
db.session.commit()
retrieved = Taxonomy(TaxonomyTerm.query.get(tax.id))
assert retrieved.code == "code"
assert retrieved.extra_data == {"extra": "data"}
tax.check()
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 taxonomy_create(code: str, extra_data: dict = None):
"""Create a new Taxonomy."""
try:
created = current_flask_taxonomies.create_taxonomy(
code=code, extra_data=extra_data)
created_dict = jsonify_taxonomy(created)
response = jsonify(created_dict)
response.status_code = 201
response.headers['Location'] = created_dict['links']['self']
return response
except IntegrityError:
raise BadRequest("Taxonomy with this code already exists.")
def test_create_update_terms_2(app, db, taxonomy_data_list):
taxonomy_code = "licenses"
slug = "copyright"
taxonomy = current_flask_taxonomies.create_taxonomy(
taxonomy_code,
extra_data={"title": {
"cs": "Licence",
"en": "Licenses"
}})
create_update_terms(taxonomy, taxonomy_data_list,
resolve_list=True) # creating
create_update_terms(taxonomy, taxonomy_data_list,
resolve_list=True) # updating
term_identification = TermIdentification(taxonomy=taxonomy_code, slug=slug)
res = list(current_flask_taxonomies.filter_term(term_identification))
assert isinstance(res[0].extra_data["list"], list)
def import_countries(db):
# with db.session.begin_nested():
try:
Base.metadata.create_all(db.engine)
except:
pass
tax = current_flask_taxonomies.get_taxonomy(code='country', fail=False)
if tax:
return
tax = current_flask_taxonomies.create_taxonomy(
code='country',
extra_data={'title': 'List of countries'},
url='https://www.kaggle.com/nikitagrec/world-capitals-gps/data')
continents = {}
with open(os.path.join(os.path.dirname(__file__), 'countries.csv'),
'r') as f:
rdr = csv.DictReader(f)
for row in rdr:
try:
continent = row['ContinentName']
country = row['CountryCode']
if continent not in continents:
print('Creating continent', continent.lower())
continent_term = current_flask_taxonomies.create_term(
TermIdentification(taxonomy=tax,
slug=continent.lower().replace(
' ', '-')), )
continents[continent] = continent_term
slug = '%s/%s' % (continent.lower(), country.lower())
slug = slug.replace(' ', '-')
print('Importing', slug)
current_flask_taxonomies.create_term(TermIdentification(
taxonomy=tax, slug=slug),
extra_data=row)
except:
traceback.print_exc()
return
try:
db.session.commit()
except:
traceback.print_exc()
sys.exit(1)
def create_update_taxonomy(data, drop) -> Taxonomy:
tax_dict = convert_data_to_dict(data)[0]
if 'code' not in tax_dict:
raise ValueError('Taxonomy does not contain "code"')
code = tax_dict.pop('code')
taxonomy = current_flask_taxonomies.get_taxonomy(code, fail=False)
if taxonomy and drop:
current_flask_taxonomies.delete_taxonomy(taxonomy)
taxonomy = None
if taxonomy:
merged_dict = taxonomy.extra_data
merged_dict.update(tax_dict)
current_flask_taxonomies.update_taxonomy(taxonomy, merged_dict)
else:
taxonomy = current_flask_taxonomies.create_taxonomy(code, extra_data=tax_dict)
db.session.commit()
return taxonomy
