def delete_taxonomy(cls, taxonomy: Taxonomy):
"""Delete a taxonomy.
:param taxonomy: taxonomy instance to be deleted
:raise TaxonomyDeleteError
"""
before_taxonomy_deleted.send(taxonomy, taxonomy=taxonomy)
check_references_before_delete(taxonomy, taxonomy=taxonomy)
taxonomy.delete()
db.session.commit()
after_taxonomy_deleted.send(taxonomy)
def update_taxonomy(cls, taxonomy: Taxonomy, extra_data) -> Taxonomy:
"""Updates a taxonomy.
:param taxonomy: taxonomy instance to be updated
:param extra_data: new taxonomy metadata
:return Taxonomy: updated taxonomy
"""
before_taxonomy_updated.send(taxonomy, taxonomy=taxonomy, extra_data=extra_data)
taxonomy.update(extra_data)
db.session.commit()
after_taxonomy_updated.send(taxonomy, taxonomy=taxonomy)
return taxonomy
def delete_term(cls, taxonomy: Taxonomy, term: TaxonomyTerm):
"""Delete a taxonomy term.
:param taxonomy: taxonomy of the term
:param term: term instance to be deleted
:raise TaxonomyDeleteError
"""
taxonomy.lock()
before_taxonomy_term_deleted.send(term, taxonomy=taxonomy, term=term)
check_references_before_delete(term, taxonomy=taxonomy, term=term)
term.delete()
db.session.commit()
after_taxonomy_term_deleted.send(term, taxonomy=taxonomy, term=term)
def update_term(cls, taxonomy: Taxonomy, term: TaxonomyTerm, changes) -> TaxonomyTerm:
"""Updates a taxonomy term.
:param taxonomy: taxonomy instance of the term
:param term: term instance to be updated
:param extra_data: new term metadata
:return TaxonomyTerm: updated taxonomy term
"""
taxonomy.lock()
before_taxonomy_term_updated.send(term, term=term, taxonomy=taxonomy,
extra_data=changes['extra_data'])
term.update(**changes)
db.session.commit()
after_taxonomy_term_updated.send(term, term=term, taxonomy=taxonomy)
return term
def convert_ref(self, in_data, **kwargs):
ref = None
if '$ref' in in_data:
ref = in_data['$ref']
elif 'links' in in_data:
ref = (in_data['links'] or {}).get('self', None)
if not ref:
# No reference found - don't convert anything
return in_data
resp = before_taxonomy_marshmallow.send(self, ref=ref)
for r in resp:
if r[1]:
if r[1] is True:
return {'$ref': ref}
return r[1]
path = url_to_path(ref)
term = Taxonomy.get_taxonomy_term(path)
if not term:
raise ValidationError(
'Taxonomy $ref link is invalid: {}'.format(ref)) # noqa
after_taxonomy_marshmallow.send(self, ref=ref, taxonomy_term=term)
return {'$ref': ref}
def move_term(cls, taxonomy, term_path='', target_path=None, destination_order=''):
"""Moves a taxonomy term to a different path.
:param taxonomy: source taxonomy instance
:param term_path: current path of a term
:param target_path: desired path of a term
:param destination_order: order in a destination tree
:raise AttributeError
:raise NoResultFound
:return Tuple(Taxonomy, Taxonomy, Optional[Taxonomy]): target taxonomy and moved term
"""
taxonomy.lock()
term = taxonomy.find_term(term_path)
if not term:
raise AttributeError('Invalid Term path given.')
before_taxonomy_term_moved.send(
term, taxonomy=taxonomy,
target_path=target_path, order=destination_order)
if not target_path:
target_path = f'{taxonomy.code}/'
target_taxonomy, target_term = Taxonomy.find_taxonomy_and_term(target_path)
term.move(target_term, position=MovePosition(destination_order or 'inside'))
db.session.commit()
after_taxonomy_term_moved.send(term, taxonomy=taxonomy, term=term)
db.session.refresh(term)
return (term, target_taxonomy, target_term)
def root_taxonomy(db):
"""Create root taxonomy element."""
from flask_taxonomies.models import Taxonomy
root = Taxonomy.create_taxonomy(code="root")
db.session.add(root)
db.session.commit()
return root
def transform_degree_discipline(paths, el, results, phase, **kwargs):
value_array = el["cs_CZ"][0]["value"]
assert len(value_array) == 1
tax = Taxonomy.get("studyfields")
results[-1]["studyField"] = studyfield_ref(value_array[0].strip(),
tax)["studyField"]
return OAITransformer.PROCESSED
def create_taxonomy_term(slug, cz_keyword, en_keyword, type):
tax = Taxonomy.get("subjects")
parent_term = tax.get_term(type)
if not parent_term:
parent_term = tax.create_term(slug=type)
db.session.add(parent_term)
db.session.commit()
extra_data = {
"title": [{
"value": cz_keyword,
"lang": "cze"
}, {
"value": en_keyword,
"lang": "eng"
}],
"approved":
False
}
term = tax.get_term(slug=slug)
if not term:
term = parent_term.create_term(slug=slug, extra_data=extra_data)
db.session.add(term)
db.session.commit()
current_flask_taxonomies_es.set(term, timestamp=datetime.utcnow())
return term
def test_db_search(app, db):
tax = Taxonomy.get("studyfields", required=True)
fields = db_search("Arteterapie", tax, json_address=("title", 0, "value"))
assert isinstance(fields, list)
for field in fields:
assert "slug" in field.keys()
assert "title" in field.keys()
assert "links" in field.keys()
def get_taxonomy_term(code=None, slug=None):
try:
taxonomy = Taxonomy.get(code)
term = taxonomy.find_term(slug)
except:
term = None
taxonomy = None
return jsonify_taxonomy_term(term, taxonomy.code, term.tree_path,
term.parent.tree_path or '')
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 create_update_taxonomy(data, drop):
tax_dict = next(convert_data_to_dict(data))
if 'code' not in tax_dict:
raise ValueError('Taxonomy does not contain "code"')
code = tax_dict.pop('code')
taxonomy = Taxonomy.get(code=code)
if taxonomy and drop:
db.session.delete(taxonomy)
db.session.commit()
taxonomy = None
if taxonomy:
merged_dict = taxonomy.extra_data
merged_dict.update(tax_dict)
taxonomy.update(extra_data=merged_dict)
else:
taxonomy = Taxonomy.create_taxonomy(code, tax_dict)
db.session.commit()
return taxonomy
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 study_programme_field(self, key, value):
"""Study programme."""
source = value.get("a")
tax = Taxonomy.get("studyfields", required=True)
if "/" not in source:
return studyfield_ref(source.strip(), tax)
else:
programme, field = source.split("/", maxsplit=1)
field = field.strip()
return studyfield_ref(field, tax)
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 create_taxonomy(cls, code, extra_data=None) -> Taxonomy:
"""Creates a new taxonomy.
:param code: taxonomy code
:param extra_data: taxonomy metadata
:raises IntegrityError
:returns Taxonomy
"""
before_taxonomy_created.send(current_app._get_current_object(),
code=code, extra_data=extra_data)
created = Taxonomy.create_taxonomy(code=code, extra_data=extra_data)
db.session.commit()
after_taxonomy_created.send(created)
return created
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 get_taxonomy_term(code=None, slug=None, timestamp=None):
try:
taxonomy = Taxonomy.get(code)
term = taxonomy.find_term(slug)
parents = [format_ancestor(x) for x in term.ancestors]
except:
traceback.print_exc()
raise ValueError("The taxonomy term does not exist.")
resp = _fix_links(
jsonify_taxonomy_term(term,
taxonomy.code,
term.tree_path,
term.parent.tree_path or '',
parents,
timestamp=timestamp))
return resp
def fix_keywords(data):
"""
Converts keywords that match PSH to subject field.
:param data: GroupableOrderedDict of all fields
:return: Fixed GroupableOrderedDict
"""
tax = Taxonomy.get("subject")
data = dict(data)
subject_tuple = []
if "653__" in data:
values = data.get("653__")
values = split_keywords(values)
data["653__"] = values
delete_position = []
for idx, value in enumerate(values):
parsed_keyword = value.get("a")
psh_list_terms = find_in_json_contains(parsed_keyword, tax,
"title").all()
if len(psh_list_terms) == 0:
psh_list_terms = find_in_json_contains(parsed_keyword, tax,
"altTitle").all()
term = psh_term_filter(psh_list_terms, parsed_keyword)
if len(psh_list_terms) == 0 or term is None:
continue
record_dict = {"2": "psh", "7": term.slug, "a": parsed_keyword}
subject_tuple.append(GroupableOrderedDict(
OrderedDict(record_dict)))
delete_position.append(idx)
if len(delete_position) > 0:
keyword_list = list(data["653__"])
for position in reversed(delete_position):
del keyword_list[position]
data["653__"] = tuple(keyword_list)
if len(subject_tuple) > 0:
if "650_7" in data:
old_subject_tuple = list(data["650_7"])
subject_tuple.extend(old_subject_tuple)
data["650_7"] = tuple(subject_tuple)
if "6530_" in data:
values = data.get("6530_")
values = split_keywords(values)
data["6530_"] = values
if "__order__" in data:
del data["__order__"]
return GroupableOrderedDict(OrderedDict(data))
def language(self, key, value):
"""Language Code."""
languages = []
tax = Taxonomy.get("languages")
if not value.get("a"):
return None
if "a" in value:
lang = get_lang("a", value)
if lang is None:
return None
languages.append(get_ref(lang, tax))
if "b" in value:
lang = get_lang("b", value)
if lang is None:
return None
languages.append(get_ref(lang, tax))
return languages
def convert_ref(self, in_data, **kwargs):
ref = None
if '$ref' in in_data:
ref = in_data['$ref']
elif 'links' in in_data:
ref = (in_data['links'] or {}).get('self', None)
if not ref:
raise ValidationError('Either links or $ref must be provided for a Taxonomy record') # noqa
path = url_to_path(ref)
try:
tax, term = Taxonomy.find_taxonomy_and_term(path)
except NoResultFound:
raise ValidationError('Taxonomy $ref link is invalid: {}'.format(ref)) # noqa
if not tax:
raise ValidationError('Taxonomy $ref link is invalid: {}'.format(ref)) # noqa
return {'$ref': ref}
def get_taxonomy_term(code=None, slug=None):
resp = before_taxonomy_jsonresolve.send(None, code=code, slug=slug)
for r in resp:
if r[1] is not None:
return r[1]
try:
taxonomy = Taxonomy.get(code)
term = taxonomy.find_term(slug)
parents = [format_ancestor(x) for x in term.ancestors]
except:
traceback.print_exc()
raise ValueError("The taxonomy term does not exist.")
resp = jsonify_taxonomy_term(term, taxonomy.code, term.tree_path,
term.parent.tree_path or '', parents)
after_taxonomy_jsonresolve.send(None,
code=code,
slug=slug,
taxonomy_term=resp)
return resp
def find_uni_by_name(name,
parent_name=None,
parent_slug=None,
query_type="term"):
if query_type == "match":
query = Q("term", taxonomy__keyword=TAXONOMY_CODE) & Q(
query_type, title__value=name)
else:
query = Q("term", taxonomy__keyword=TAXONOMY_CODE) & Q(
query_type, title__value__keyword=name)
if parent_slug or parent_name:
if parent_slug:
parent_query = Q("term", ancestors__slug__keyword=parent_slug)
else:
parent_query = Q("term",
ancestors__title__value__keyword=parent_slug)
query = Q('bool', must=[parent_query, query])
if query_type == "match":
results = current_flask_taxonomies_es.search(query, match=True)
else:
results = current_flask_taxonomies_es.search(query)
if not results:
if query_type == "match":
query1 = Q(query_type, formerNames=name)
query2 = Q(query_type, aliases=name)
else:
query1 = Q(query_type, formerNames__keyword=name)
query2 = Q(query_type, aliases__keyword=name)
q = Q('bool', should=[query1, query2])
if query_type == "match":
results = current_flask_taxonomies_es.search(q, match=True)
else:
results = current_flask_taxonomies_es.search(q)
if not results:
tax = Taxonomy.get(TAXONOMY_CODE)
results = db_search(name, tax, json_address=("title", 0, "value"))
if results:
return results[0]
def delete_taxonomy(code):
t = Taxonomy.get(code)
db.session.delete(t)
db.session.commit()
def list_taxonomies():
for t in Taxonomy.taxonomies():
print(t.code)
def subject(self, key, values):
"""Subject."""
taxonomy = Taxonomy.get("subjects")
return get_subject(taxonomy, values)
def delete_taxonomy(code):
t = Taxonomy.get(code)
current_flask_taxonomies.delete_taxonomy(t)
def set_(taxonomy: str, slug: str):
taxonomy = Taxonomy.get(taxonomy)
term = taxonomy.get_term(slug)
current_flask_taxonomies_es.set(term)
