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 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 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_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 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 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 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 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 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 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 get_taxonomy_term(type: str): taxonomy = Taxonomy.get("subjects") taxonomy_term = taxonomy.get_term(type.lower()) return taxonomy_term
def subject(self, key, values): """Subject.""" taxonomy = Taxonomy.get("subjects") return get_subject(taxonomy, values)
def set_(taxonomy: str, slug: str): taxonomy = Taxonomy.get(taxonomy) term = taxonomy.get_term(slug) current_flask_taxonomies_es.set(term)
def delete_taxonomy(code): t = Taxonomy.get(code) current_flask_taxonomies.delete_taxonomy(t)