def add_skos_hierarachy(self, parent_uri, child_uri): """ Add a hiearchy assertion for linked entities """ try: parent = LinkEntity.objects.get(uri=parent_uri) except LinkEntity.DoesNotExist: parent = False try: child = LinkEntity.objects.get(uri=child_uri) except LinkEntity.DoesNotExist: child = False if parent is not False and child is not False: lr = LinkRecursion() exiting_parents = lr.get_entity_parents(child_uri) if len(exiting_parents) >= 1: print('Child has parents: ' + str(exiting_parents)) else: # child is not already in a hieararchy, ok to put it in one la = LinkAnnotation() la.subject = child.uri # the subordinate is the subject la.subject_type = 'uri' la.project_uuid = self.project_uuid la.source_id = self.source_id + '-hierarchy' la.predicate_uri = self.PRED_SBJ_IS_SUB_OF_OBJ la.object_uri = parent.uri # the parent is the object la.save() print('Made: ' + child.uri + ' child of: ' + parent.uri) else: print('Cannot find parent or child')
def add_skos_hierarachy(self, parent_uri, child_uri): """ Add a hiearchy assertion for linked entities """ try: parent = LinkEntity.objects.get(uri=parent_uri) except LinkEntity.DoesNotExist: parent = False try: child = LinkEntity.objects.get(uri=child_uri) except LinkEntity.DoesNotExist: child = False if parent is not False and child is not False: lr = LinkRecursion() exiting_parents = lr.get_entity_parents(child_uri) if len(exiting_parents) >= 1: print('Child has parents: ' + str(exiting_parents)) else: # child is not already in a hieararchy, ok to put it in one la = LinkAnnotation() la.subject = child.uri # the subordinate is the subject la.subject_type = 'uri' la.project_uuid = self.project_uuid la.source_id = self.source_id + '-hierarchy' la.predicate_uri = self.PRED_SBJ_IS_SUB_OF_OBJ la.object_uri = parent.uri # the parent is the object la.save() print('Made: ' + child.uri + ' child of: ' + parent.uri) else: print('Cannot find parent or child')
def get_uri_children(self, uri): """ gets the children for a given uri """ output = [] if isinstance(uri, str): lr = LinkRecursion() lr.get_entity_children(uri, False) children = lr.child_entities if isinstance(children, dict): child_uris = [] for ch_uri, ch_list in children.items(): if uri == ch_uri: child_uris = ch_list break # now we have child entity uris, put them in the proper order lequiv = LinkEquivalence() child_uris = lequiv.get_identifier_list_variants(child_uris) child_ents = LinkEntity.objects\ .filter(uri__in=child_uris)\ .exclude(uri=self.uri)\ .order_by('sort', 'label', 'uri') for act_ent in child_ents: ent_dict = LastUpdatedOrderedDict() ent_dict['id'] = act_ent.uri ent_dict['label'] = act_ent.label ent_dict['slug'] = act_ent.slug ent_dict['href'] = self.make_local_url(act_ent.uri) output.append(ent_dict) return output
def get_uri_children(self, uri): """ gets the children for a given uri """ output = [] if isinstance(uri, str): lr = LinkRecursion() lr.get_entity_children(uri, False) children = lr.child_entities if isinstance(children, dict): child_uris = [] for ch_uri, ch_list in children.items(): if uri == ch_uri: child_uris = ch_list break # now we have child entity uris, put them in the proper order lequiv = LinkEquivalence() child_uris = lequiv.get_identifier_list_variants(child_uris) child_ents = LinkEntity.objects\ .filter(uri__in=child_uris)\ .exclude(uri=self.uri)\ .order_by('sort', 'label', 'uri') for act_ent in child_ents: ent_dict = LastUpdatedOrderedDict() ent_dict['id'] = act_ent.uri ent_dict['label'] = act_ent.label ent_dict['slug'] = act_ent.slug ent_dict['href'] = self.make_local_url(act_ent.uri) output.append(ent_dict) return output
def make_reconcilation_json(self, search_term, geojson_ld): """ takes the geojson_ld and makes a reconcilation json output """ recon_json = False if isinstance(geojson_ld, dict): self.geojson_ld = geojson_ld recon_json = [] if 'oc-api:has-facets' in geojson_ld: facets = geojson_ld['oc-api:has-facets'] for facet in facets: if 'oc-api:has-id-options' in facet: max_count = 0 for facet_value in facet['oc-api:has-id-options']: if facet_value['count'] > max_count: max_count = facet_value['count'] id_ranks = {} for facet_value in facet['oc-api:has-id-options']: id_uri = facet_value['rdfs:isDefinedBy'] lr = LinkRecursion() lr.get_entity_children(id_uri) if len(lr.child_entities) > 0: levels = len(lr.child_entities) + 1 else: levels = 1 # calculate a ranking for items, with more specific (fewer children) # categories ranked higher rank = (facet_value['count'] / levels) / max_count match_count = self.count_label_matches( search_term, id_uri) rank = rank + (match_count / levels) id_ranks[id_uri] = rank sorted_ids = sorted(id_ranks.items(), key=operator.itemgetter(1), reverse=True) for id_key, rank in sorted_ids: if len(recon_json) < 5: for facet_value in facet[ 'oc-api:has-id-options']: if facet_value[ 'rdfs:isDefinedBy'] == id_key: rank_item = LastUpdatedOrderedDict() rank_item['id'] = id_key rank_item['label'] = facet_value[ 'label'] rank_item['rank'] = rank rank_item[ 'related-labels'] = self.get_related_labels( id_key, True) recon_json.append(rank_item) break else: break return recon_json
def get_children(self, identifier): """ Gets SKOS or OWL children for an entity """ ent = Entity() found = ent.dereference(identifier) if found: self.children = [] lr = LinkRecursion() lr.get_entity_children(identifier) self.children = lr.child_entities return self.children
def get_children(self, identifier): """ Gets SKOS or OWL children for an entity """ ent = Entity() found = ent.dereference(identifier) if found: self.children = [] lr = LinkRecursion() lr.get_entity_children(identifier) self.children = lr.child_entities return self.children
def get_jsonldish_entity_parents_db(self, entity_uri): """ returns the parents of an entity """ lr = LinkRecursion() lr.mem_cache_parents = self.entity_parents lr.mem_cache_entities = self.entities parents = lr.get_jsonldish_entity_parents(entity_uri) # now save the entities that whent into this. self.entity_parents = lr.mem_cache_parents for key, entity in lr.mem_cache_entities.items(): if key not in self.entities: self.entities[key] = entity return parents
def get_entity_parents(self): """ gets the parents of a given entity """ if isinstance(self.uri, str): lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(self.uri, False) if isinstance(parents, list): for parent in parents: ent_dict = LastUpdatedOrderedDict() ent_dict['id'] = parent['id'] ent_dict['label'] = parent['label'] ent_dict['slug'] = parent['slug'] ent_dict['href'] = self.make_local_url(parent['id']) self.parents.append(ent_dict)
def get_parent_entity_facet_field(self, entity_uri): """ Gets the parent facet field for a given category_uri. This assumes the category_uri is an entity that exists in the database. """ output = False; lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(entity_uri) if isinstance(parents, list): if len(parents) > 1: # get the penultimate field output = parents[-2]['slug'].replace('-', '_') + '___pred_id' return output
def get_entity_parents(self): """ gets the parents of a given entity """ if isinstance(self.uri, str): lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(self.uri, False) if isinstance(parents, list): for parent in parents: ent_dict = LastUpdatedOrderedDict() ent_dict['id'] = parent['id'] ent_dict['label'] = parent['label'] ent_dict['slug'] = parent['slug'] ent_dict['href'] = self.make_local_url(parent['id']) self.parents.append(ent_dict)
def get_entity_children_db(self, entity_uri): """ returns the children of an entity """ children = [] if entity_uri in self.entity_children: children = self.entity_children[entity_uri] else: lr = LinkRecursion() lr.mem_cache_entities = self.entities lr.child_entities = self.entity_children children = lr.get_entity_children(entity_uri) self.entities = lr.mem_cache_entities self.entity_children = lr.child_entities return children
def get_parent_item_type_facet_field(self, category_uri): """ Gets the parent facet field for a given category_uri. This assumes the category_uri is an entity that exists in the database. """ output = False; lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(category_uri) for par in parents: if par['slug'] in self.TYPE_MAPPINGS.values(): # the parent exists in the Type Mappings output = par['slug'].replace('-', '_') + '___pred_id' break return output
def alter_annotation_hiearchy(self): """ alters hierarchic annotations expressed in SKOS or OWL relations """ lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(self.uuid, False) if isinstance(parents, list): if len(parents) > 0: # the item has SKOS / OWL parents parent_id = parents[-1]['id'] lam = LinkAnnoManagement() lam.source_id = self.editorial_uuid # so editorial uuid associated with change lam.replace_hierarchy(self.uuid, parent_id)
def alter_annotation_hiearchy(self): """ alters hierarchic annotations expressed in SKOS or OWL relations """ lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(self.uuid, False) if isinstance(parents, list): if len(parents) > 0: # the item has SKOS / OWL parents parent_id = parents[-1]['id'] lam = LinkAnnoManagement() lam.source_id = self.editorial_uuid # so editorial uuid associated with change lam.replace_hierarchy(self.uuid, parent_id)
def _process_category(self): """ Finds category / type data ('class_uri' n the manifest table) For indexing as a type of predicate """ if 'category' in self.oc_item.json_ld: for category in self.oc_item.json_ld['category']: # get the parent entities of the current category parents = LinkRecursion( ).get_jsonldish_entity_parents(category) item_type_found = False active_predicate_field = False for index, parent in enumerate(parents): # We're ignoring the 'slug' from the LinkRecursion parents # Gets the last part of the URI ptype = parent['id'].split('/')[-1] # prefix_ptype = 'oc-gen-' + ptype # consistent with other uses of slugs for solr fields prefix_ptype = parent['slug'] if item_type_found is False: if ptype == self.oc_item.item_type: item_type_found = True if active_predicate_field is not False: solr_value = self._concat_solr_string_value( prefix_ptype, 'id', parent['id'], parent['label'] ) if active_predicate_field not in self.fields: self.fields[active_predicate_field] = [] self.fields[active_predicate_field].append(solr_value) if item_type_found: active_predicate_field = self._convert_slug_to_solr( prefix_ptype) + '___pred_id'
def make_reconcilation_json(self, search_term, geojson_ld): """ takes the geojson_ld and makes a reconcilation json output """ recon_json = False if isinstance(geojson_ld, dict): self.geojson_ld = geojson_ld recon_json = [] if 'oc-api:has-facets' in geojson_ld: facets = geojson_ld['oc-api:has-facets'] for facet in facets: if 'oc-api:has-id-options' in facet: max_count = 0 for facet_value in facet['oc-api:has-id-options']: if facet_value['count'] > max_count: max_count = facet_value['count'] id_ranks = {} for facet_value in facet['oc-api:has-id-options']: id_uri = facet_value['rdfs:isDefinedBy'] lr = LinkRecursion() lr.get_entity_children(id_uri) if len(lr.child_entities) > 0: levels = len(lr.child_entities) + 1 else: levels = 1 # calculate a ranking for items, with more specific (fewer children) # categories ranked higher rank = (facet_value['count'] / levels) / max_count match_count = self.count_label_matches(search_term, id_uri) rank = rank + (match_count / levels) id_ranks[id_uri] = rank sorted_ids = sorted(id_ranks.items(), key=operator.itemgetter(1), reverse=True) for id_key, rank in sorted_ids: if len(recon_json) < 5: for facet_value in facet['oc-api:has-id-options']: if facet_value['rdfs:isDefinedBy'] == id_key: rank_item =LastUpdatedOrderedDict() rank_item['id'] = id_key rank_item['label'] = facet_value['label'] rank_item['rank'] = rank rank_item['related-labels'] = self.get_related_labels(id_key, True) recon_json.append(rank_item) break else: break return recon_json
def get_numeric_range_from_children(self, predicate_uuids): """ gets numeric range from a list of predicates OR their children """ if not isinstance(predicate_uuids, list): predicate_uuids = [str(predicate_uuids)] all_preds = [] for predicate_uuid in predicate_uuids: all_preds.append(predicate_uuid) lr = LinkRecursion() lr.get_entity_children(predicate_uuid) for child_uuid_key, val in lr.child_entities.items(): if child_uuid_key not in all_preds: all_preds.append(child_uuid_key) # now get the summary, but don't allow recursive looking at children output = self.get_numeric_range(all_preds, False) return output
def get_numeric_range_from_children(self, predicate_uuids): """ gets numeric range from a list of predicates OR their children """ if not isinstance(predicate_uuids, list): predicate_uuids = [str(predicate_uuids)] all_preds = [] for predicate_uuid in predicate_uuids: all_preds.append(predicate_uuid) lr = LinkRecursion() lr.get_entity_children(predicate_uuid) for child_uuid_key, val in lr.child_entities.items(): if child_uuid_key not in all_preds: all_preds.append(child_uuid_key) # now get the summary, but don't allow recursive looking at children output = self.get_numeric_range(all_preds, False) return output
def get_new_hierarchic_types(self, revision_date): """ Gets a list of types items revised after a date with the default delimiter for hierachy, but no superior concept """ rdate = datetime.strptime(revision_date, '%Y-%m-%d') new_hierarchic_list = [] hi_types = Manifest.objects.filter(item_type='types', label__contains=self.HIERARCHY_DELIM, revised__gte=rdate) if(len(hi_types) > 0): for hi_type in hi_types: lr = LinkRecursion() lr.get_entity_parents(hi_type.uuid) if(len(lr.parent_entities) < 1): # no superior parents found new_hierarchic_list.append(hi_type) return new_hierarchic_list
def make_root_entity_list(self, entity_list): """ makes a list of entities that are not children of other items in the hierarchy """ root_entities = [] for act_ent in entity_list: lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(act_ent.uri, False) if parents is False: ent_dict = LastUpdatedOrderedDict() ent_dict['id'] = act_ent.uri ent_dict['label'] = act_ent.label ent_dict['slug'] = act_ent.slug ent_dict['href'] = self.make_local_url(act_ent.uri) ent_dict['children'] = self.get_uri_children(act_ent.uri) if len(ent_dict['children']) > 0: ent_dict['more'] = True root_entities.append(ent_dict) return root_entities
def get_new_hierarchic_types(self, revision_date): """ Gets a list of types items revised after a date with the default delimiter for hierachy, but no superior concept """ rdate = datetime.strptime(revision_date, '%Y-%m-%d') new_hierarchic_list = [] hi_types = Manifest.objects.filter( item_type='types', label__contains=self.HIERARCHY_DELIM, revised__gte=rdate) if (len(hi_types) > 0): for hi_type in hi_types: lr = LinkRecursion() lr.get_entity_parents(hi_type.uuid) if (len(lr.parent_entities) < 1): # no superior parents found new_hierarchic_list.append(hi_type) return new_hierarchic_list
def make_root_entity_list(self, entity_list): """ makes a list of entities that are not children of other items in the hierarchy """ root_entities = [] for act_ent in entity_list: lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(act_ent.uri, False) if parents is False: ent_dict = LastUpdatedOrderedDict() ent_dict['id'] = act_ent.uri ent_dict['label'] = act_ent.label ent_dict['slug'] = act_ent.slug ent_dict['href'] = self.make_local_url(act_ent.uri) ent_dict['children'] = self.get_uri_children(act_ent.uri) if len(ent_dict['children']) > 0: ent_dict['more'] = True; root_entities.append(ent_dict) return root_entities
def validate_make_eol_hierarchy(self, child_uri, parent_uri): """ Validated hierarchy relations for EOL entities. If a child already has a parent, this will not do anything otherwise it will create a hierachy relation """ ok_create = False le_gen = LinkEntityGeneration() child_uri = le_gen.make_clean_uri( child_uri) # strip off any cruft in the URI parent_uri = le_gen.make_clean_uri(parent_uri) ent = Entity() found = ent.dereference(child_uri) if found: lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(child_uri, False) if parents is False: # no parents, so OK to make an assertion ok_create = True else: if len(parents) == 0: # no parents, so OK to make an assertion ok_create = True else: ok_create = True # the child does not yet exist, so OK to make the relation print('Getting missing data for: ' + child_uri) self.get_save_entity_label(child_uri) if ok_create: print('OK, make rel for: ' + child_uri + ' in ' + parent_uri) la = LinkAnnotation() la.subject = child_uri la.subject_type = 'uri' la.project_uuid = '0' la.source_id = 'manual-eol-manage' la.predicate_uri = self.CHILD_PARENT_REL la.object_uri = parent_uri la.sort = 1 la.save() else: print('Already in hierarchy: ' + child_uri)
def get_entity_item_children_list(item, recursive=False): """Gets a list of children item dicts for an item entity object :param entity item: See the apps/entity/models entity object for a definition. """ use_id = item.slug if getattr(item, 'uuid', None): # Use the UUID for an item if we have it to look up parents. use_id = item.uuid item_children = LinkRecursion().get_entity_children(use_id, recursive=recursive) return item_children
def validate_make_eol_hierarchy(self, child_uri, parent_uri): """ Validated hierarchy relations for EOL entities. If a child already has a parent, this will not do anything otherwise it will create a hierachy relation """ ok_create = False le_gen = LinkEntityGeneration() child_uri = le_gen.make_clean_uri(child_uri) # strip off any cruft in the URI parent_uri = le_gen.make_clean_uri(parent_uri) ent = Entity() found = ent.dereference(child_uri) if found: lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(child_uri, False) if parents is False: # no parents, so OK to make an assertion ok_create = True else: if len(parents) == 0: # no parents, so OK to make an assertion ok_create = True else: ok_create = True # the child does not yet exist, so OK to make the relation print('Getting missing data for: ' + child_uri) self.get_save_entity_label(child_uri) if ok_create: print('OK, make rel for: ' + child_uri + ' in ' + parent_uri) la = LinkAnnotation() la.subject = child_uri la.subject_type = 'uri' la.project_uuid = '0' la.source_id = 'manual-eol-manage' la.predicate_uri = self.CHILD_PARENT_REL la.object_uri = parent_uri la.sort = 1 la.save() else: print('Already in hierarchy: ' + child_uri)
def save_sort(self, predicate_uri='http://purl.org/ontology/olo/core#index'): """ Saves sort order """ data_indexes = False if (self.graph is not False and self.vocabulary_uri is not False): data_indexes = {} index_pred = URIRef(predicate_uri) for s, p, o in self.graph.triples((None, index_pred, None)): subject_uri = s.__str__( ) # get the URI of the subject as a string index = o.__str__() # get the URI of the object as a string data_indexes[subject_uri] = int(float(index)) + 1 # add 1 # so first child does not have the exact same index as the first parent. if (len(data_indexes) > 0): for subject_uri, index in data_indexes.items(): print('Sorting: ' + subject_uri) sort_strings = [] parents = LinkRecursion().get_jsonldish_entity_parents( subject_uri) for parent in parents: if parent['id'] in data_indexes: parent_index = data_indexes[parent['id']] else: parent_index = 0 parent_sort = self.sort_digits(parent_index) sort_strings.append(parent_sort) while len(sort_strings) < self.SORT_HIERARCHY_DEPTH: deep_sort = self.sort_digits(0) sort_strings.append(deep_sort) sort = '-'.join(sort_strings) try: le = LinkEntity.objects.get(uri=subject_uri) except LinkEntity.DoesNotExist: le = False if le is not False: le.sort = sort le.save() return data_indexes
def _process_predicate_values(self, predicate_slug, predicate_type): # First generate the solr field name solr_field_name = self._convert_slug_to_solr( predicate_slug + self._get_predicate_type_string( predicate_type, prefix='___pred_') ) # Then get the predicate values if solr_field_name not in self.fields: self.fields[solr_field_name] = [] if self.oc_item.item_type == 'media' \ or self.oc_item.item_type == 'documents': # we want to make joins easier for these types of items make_join_ids = True else: make_join_ids = False predicate_key = 'oc-pred:' + predicate_slug for obs_list in self.oc_item.json_ld['oc-gen:has-obs']: if predicate_key in obs_list: predicate_values = obs_list[predicate_key] for value in predicate_values: if predicate_type == '@id': if make_join_ids and 'subjects' in value['id']: # case where we want to make a join field to link # associated subjects items with media or document # items allows join relationships between # 'join___pred_id' and 'uuid' solr fields. if 'join___pred_id' not in self.fields: self.fields['join___pred_id'] = [] # get subjects UUID from the URI sub_uuid = URImanagement.get_uuid_from_oc_uri( value['id'] ) # append to the solr field for joins self.fields['join___pred_id'].append(sub_uuid) if predicate_slug != 'link': active_solr_field = solr_field_name parents = LinkRecursion( ).get_jsonldish_entity_parents( value['id'] ) all_obj_solr_field = 'obj_all___' + active_solr_field if all_obj_solr_field not in self.fields: self.fields[all_obj_solr_field] = [] for parent in parents: if active_solr_field not in self.fields: self.fields[active_solr_field] = [] active_solr_value = \ self._concat_solr_string_value( parent['slug'], self._get_predicate_type_string( parent['type']), parent['id'], parent['label'] ) self.fields['text'] += ' ' + \ parent['label'] + ' ' self.fields[active_solr_field].append( active_solr_value ) # so all items in the hiearchy are present in the # and can be queried, even if you don't know the parent self.fields[all_obj_solr_field].append( active_solr_value ) active_solr_field = self._convert_slug_to_solr( parent['slug']) + '___' + solr_field_name else: # case of a linking relation, don't bother looking # up hierarchies or recording as a solr field, but # check for image, other media, and document counts if 'media' in value['id'] \ and 'image' in value['type']: self.fields['image_media_count'] += 1 elif 'media' in value['id'] \ and 'image' not in value['type']: # other types of media self.fields['other_binary_media_count'] += 1 elif 'documents' in value['id']: self.fields['document_count'] += 1 self.fields['text'] += value['label'] + ' ' elif predicate_type in [ 'xsd:integer', 'xsd:double', 'xsd:boolean' ]: self.fields[solr_field_name].append(value) elif predicate_type == 'xsd:date': self.fields[solr_field_name].append(value + 'T00:00:00Z') elif predicate_type == 'xsd:string': self.fields['text'] += value['xsd:string'] + ' \n' self.fields[solr_field_name].append( value['xsd:string']) else: raise Exception("Error: Could not get predicate value") self.fields['text'] += ' \n'
def get_parents(self, identifier): """ Gets SKOS or OWL parents for an entity """ parents = LinkRecursion().get_jsonldish_entity_parents(identifier)
def process_prop(self, props): """ processes 'prop' (property) parameters property parameters are tricky because they can come in hierarchies that's why there's some complexity to this """ # is the property for the item itself, or for a related item? query_dict = {'fq': [], 'facet.field': [], 'stats.field': [], 'prequery-stats': [], 'facet.range': [], 'hl-queries': [], 'ranges': {}} fq_terms = [] prop_path_lists = self.expand_hierarchy_options(props) for prop_path_list in prop_path_lists: i = 0 path_list_len = len(prop_path_list) fq_path_terms = [] act_field_fq = SolrDocument.ROOT_PREDICATE_SOLR act_field_data_type = 'id' last_field_label = False # needed for full text highlighting predicate_solr_slug = False for prop_slug in prop_path_list: field_prefix = self.get_related_slug_field_prefix(prop_slug) solr_f_prefix = field_prefix.replace('-', '_') db_prop_slug = self.clean_related_slug(prop_slug) l_prop_entity = False pred_prop_entity = False require_id_field = False if act_field_data_type == 'id': # check entity exists, and save to memory found = self.mem_cache_obj.check_entity_found(db_prop_slug, False) if found: entity = self.mem_cache_obj.get_entity(db_prop_slug, False) last_field_label = entity.label prop_slug = field_prefix + entity.slug if entity.item_type == 'uri' and 'oc-gen' not in db_prop_slug: if entity.entity_type == 'property': pred_prop_entity = True predicate_solr_slug = prop_slug.replace('-', '_') l_prop_entity = True children = self.mem_cache_obj.get_entity_children(entity.uri) if len(children) > 0: # ok, this field has children. require it # to be treated as an ID field require_id_field = True else: if entity.item_type == 'predicates': pred_prop_entity = True predicate_solr_slug = prop_slug.replace('-', '_') children = self.mem_cache_obj.get_entity_children(entity.uri) if len(children) > 0: # ok, this field has children. require it # to be treated as an ID field require_id_field = True if i == 0: if 'oc-gen' in db_prop_slug: # for open context categories / types act_field_fq = self.get_parent_item_type_facet_field(entity.uri) lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(entity.uri) if len(parents) > 1: try: p_slug = parents[-2]['slug'] act_field_fq = p_slug.replace('-', '_') + '___pred_id' act_field_fq = self.correct_solr_prefix_for_fq(solr_f_prefix, act_field_fq) except: pass elif entity.item_type == 'uri': act_field_fq = SolrDocument.ROOT_LINK_DATA_SOLR elif entity.item_type == 'predicates': temp_field_fq = self.get_parent_item_type_facet_field(entity.uri) parents = self.mem_cache_obj.get_jsonldish_entity_parents(entity.uri) if len(parents) > 1: try: p_slug = parents[-2]['slug'] temp_field_fq = p_slug.replace('-', '_') + '___pred_id' except: print('Predicate Parent exception: '+ str(parents)) temp_field_fq = False if temp_field_fq is not False: act_field_fq = temp_field_fq else: act_field_fq = SolrDocument.ROOT_PREDICATE_SOLR else: act_field_fq = SolrDocument.ROOT_PREDICATE_SOLR # --------------------------------------------------- # THIS PART BUILDS THE FACET-QUERY # fq_path_term = fq_field + ':' + self.make_solr_value_from_entity(entity) # the below is a bit of a hack. We should have a query field # as with ___pred_ to query just the slug. But this works for now fq_field = act_field_fq + '_fq' if path_list_len >= 2 and act_field_data_type == 'id': # could be an object deeper in the hierarchy, so allow the obj_all version fq_path_term = '(' + fq_field + ':' + prop_slug fq_path_term += ' OR obj_all___' + fq_field + ':' + prop_slug + ')' else: fq_path_term = fq_field + ':' + prop_slug fq_path_terms.append(fq_path_term) #--------------------------------------------------- # #--------------------------------------------------- # THIS PART PREPARES FOR LOOPING OR FINAL FACET-FIELDS # # print('pred-solr-slug: ' + predicate_solr_slug) field_parts = self.make_prop_solr_field_parts(entity) act_field_data_type = field_parts['suffix'] if require_id_field: act_field_data_type = 'id' field_parts['suffix'] = 'id' # check if the last or penultimate field has # a different data-type (for linked-data) if i >= (path_list_len - 2) \ and l_prop_entity: dtypes = self.mem_cache_obj.get_dtypes(entity.uri) if isinstance(dtypes, list): # set te data type and the act-field found = self.mem_cache_obj.check_entity_found(db_prop_slug, False) if found: entity = self.mem_cache_obj.get_entity(db_prop_slug, False) entity.date_type = dtypes[0] # store for later use self.mem_cache_obj.entities[db_prop_slug] = entity # store for later use act_field_data_type = self.get_solr_field_type(dtypes[0]) if predicate_solr_slug is False or pred_prop_entity: act_field_fq = field_parts['prefix'] + '___pred_' + field_parts['suffix'] act_field_fq = self.correct_solr_prefix_for_fq(solr_f_prefix, act_field_fq) # get a facet on this field if act_field_data_type != 'string': # adds a prefix for related properties ffield = solr_f_prefix + field_parts['prefix'] + '___pred_' + field_parts['suffix'] if ffield not in query_dict['facet.field'] \ and i >= (path_list_len - 1): query_dict['facet.field'].append(ffield) else: if act_field_data_type == 'id': act_field_fq = 'obj_all___' + predicate_solr_slug \ + '___pred_' + field_parts['suffix'] # get a facet on this field if predicate_solr_slug != field_parts['prefix']: # the predicate_solr_slug is not the # prefix of the current field part, meaning # the field_parts[prefix] is the type, and # we want facets for the predicate -> type ffield = field_parts['prefix'] \ + '___' \ + predicate_solr_slug \ + '___pred_' + field_parts['suffix'] else: # get facets for the predicate ffield = field_parts['prefix'] \ + '___pred_' \ + field_parts['suffix'] # adds a prefix, in case of a related property ffield = solr_f_prefix + ffield if ffield not in query_dict['facet.field'] \ and i >= (path_list_len - 1): query_dict['facet.field'].append(ffield) else: act_field_fq = predicate_solr_slug + '___pred_' + field_parts['suffix'] # ------------------------------------------- if act_field_data_type == 'numeric': # print('Numeric field: ' + act_field) act_field_fq = field_parts['prefix'] + '___pred_numeric' act_field_fq = self.correct_solr_prefix_for_fq(solr_f_prefix, act_field_fq) query_dict = self.add_math_facet_ranges(query_dict, act_field_fq, entity) elif act_field_data_type == 'date': # print('Date field: ' + act_field) act_field_fq = field_parts['prefix'] + '___pred_date' act_field_fq = self.correct_solr_prefix_for_fq(solr_f_prefix, act_field_fq) query_dict = self.add_date_facet_ranges(query_dict, act_field_fq, entity) # print('Current data type (' + str(i) + '): ' + act_field_data_type) # print('Current field (' + str(i) + '): ' + act_field_fq) i += 1 elif act_field_data_type == 'string': # case for a text search # last_field_label = False # turn off using the field label for highlighting string_terms = self.prep_string_search_term(prop_slug) for escaped_term in string_terms: search_term = act_field_fq + ':' + escaped_term if last_field_label is False: query_dict['hl-queries'].append(escaped_term) else: query_dict['hl-queries'].append(last_field_label + ' ' + escaped_term) fq_path_terms.append(search_term) elif act_field_data_type == 'numeric': # numeric search. assume it's well formed solr numeric request search_term = act_field_fq + ':' + prop_slug fq_path_terms.append(search_term) # now limit the numeric ranges from query to the range facets query_dict = self.add_math_facet_ranges(query_dict, act_field_fq, False, prop_slug) elif act_field_data_type == 'date': # date search. assume it's well formed solr request search_term = act_field_fq + ':' + prop_slug fq_path_terms.append(search_term) # now limit the date ranges from query to the range facets query_dict = self.add_date_facet_ranges(query_dict, act_field_fq, False, prop_slug) final_path_term = ' AND '.join(fq_path_terms) final_path_term = '(' + final_path_term + ')' fq_terms.append(final_path_term) fq_final = ' OR '.join(fq_terms) fq_final = '(' + fq_final + ')' query_dict['fq'].append(fq_final) return query_dict
def _process_predicates(self): # Get list of predicates predicates = (item for item in self.oc_item.json_ld[ '@context'][1].items() if item[0].startswith('oc-pred:')) # We need a list for "root___pred_id" because it is multi-valued self.fields[self.ROOT_PREDICATE_SOLR] = [] for predicate in predicates: # We need the predicate's uuid to get its parents predicate_uuid = predicate[1]['owl:sameAs'].split('/')[-1] predicate_type = predicate[1]['type'] parents = LinkRecursion( ).get_jsonldish_entity_parents(predicate_uuid) # Process parents link_predicate = False # link predicates get special treatment for index, parent in enumerate(parents): if parent['slug'] == 'link': link_predicate = True else: # add the label of the variable to the text field self.fields['text'] += ' ' + parent['label'] + ' ' # Treat the first parent in a special way if index == 0: if link_predicate is False: self.fields[self.ROOT_PREDICATE_SOLR].append( self._concat_solr_string_value( parent['slug'], self._get_predicate_type_string( parent['type']), parent['id'], parent['label'] ) ) # If it's the only item, process its predicate values if len(parents) == 1: self._process_predicate_values( parent['slug'], predicate_type ) else: # Process additional items # Create solr field name using parent slug solr_field_name = \ parents[index - 1]['slug'] + '___pred_id' solr_field_name = self._convert_slug_to_solr( solr_field_name ) if link_predicate is False: if solr_field_name not in self.fields: self.fields[solr_field_name] = [] # Add slug and label as json values self.fields[solr_field_name].append( self._concat_solr_string_value( parent['slug'], self._get_predicate_type_string( parent['type']), parent['id'], parent['label']) ) # If this is the last item, process the predicate values if index == len(parents) - 1: self._process_predicate_values( parent['slug'], predicate_type)
def process_prop(self, props): """ processes 'prop' (property) parameters property parameters are tricky because they can come in hierarchies that's why there's some complexity to this """ # is the property for the item itself, or for a related item? query_dict = {'fq': [], 'facet.field': [], 'stats.field': [], 'prequery-stats': [], 'facet.range': [], 'hl-queries': [], 'ranges': {}} fq_terms = [] prop_path_lists = self.expand_hierarchy_options(props) for prop_path_list in prop_path_lists: i = 0 path_list_len = len(prop_path_list) fq_path_terms = [] act_field_fq = SolrDocument.ROOT_PREDICATE_SOLR act_field_data_type = 'id' last_field_label = False # needed for full text highlighting predicate_solr_slug = False for prop_slug in prop_path_list: field_prefix = self.get_related_slug_field_prefix(prop_slug) solr_f_prefix = field_prefix.replace('-', '_') db_prop_slug = self.clean_related_slug(prop_slug) l_prop_entity = False pred_prop_entity = False require_id_field = False if act_field_data_type == 'id': # check entity exists, and save to memory entity = self.m_cache.get_entity(db_prop_slug) if entity: last_field_label = entity.label prop_slug = field_prefix + entity.slug if entity.item_type == 'uri' and not db_prop_slug.startswith('oc-gen'): if entity.entity_type == 'property': pred_prop_entity = True predicate_solr_slug = prop_slug.replace('-', '_') l_prop_entity = True children = LinkRecursion().get_entity_children(entity.uri) if len(children) > 0: # ok, this field has children. require it # to be treated as an ID field require_id_field = True else: if entity.item_type == 'predicates': pred_prop_entity = True predicate_solr_slug = prop_slug.replace('-', '_') children = LinkRecursion().get_entity_children(entity.uri) if len(children) > 0: # ok, this field has children. require it # to be treated as an ID field require_id_field = True if i == 0: if db_prop_slug.startswith('oc-gen'): # for open context categories / types act_field_fq = self.get_parent_item_type_facet_field(entity.uri) lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(entity.uri) if len(parents) > 1: try: p_slug = parents[-2]['slug'] act_field_fq = p_slug.replace('-', '_') + '___pred_id' act_field_fq = self.correct_solr_prefix_for_fq(solr_f_prefix, act_field_fq) except: pass print('Predicate Parent exception: '+ str(parents)) elif entity.item_type == 'uri': act_field_fq = SolrDocument.ROOT_LINK_DATA_SOLR elif entity.item_type == 'predicates': temp_field_fq = self.get_parent_item_type_facet_field(entity.uri) lr = LinkRecursion() parents = lr.get_jsonldish_entity_parents(entity.uri) if len(parents) > 1: try: p_slug = parents[-2]['slug'] temp_field_fq = p_slug.replace('-', '_') + '___pred_id' except: print('Predicate Parent exception: '+ str(parents)) temp_field_fq = False if temp_field_fq is not False: act_field_fq = temp_field_fq else: act_field_fq = SolrDocument.ROOT_PREDICATE_SOLR else: act_field_fq = SolrDocument.ROOT_PREDICATE_SOLR # --------------------------------------------------- # THIS PART BUILDS THE FACET-QUERY # fq_path_term = fq_field + ':' + self.make_solr_value_from_entity(entity) # the below is a bit of a hack. We should have a query field # as with ___pred_ to query just the slug. But this works for now fq_field = act_field_fq + '_fq' if path_list_len >= 2 and act_field_data_type == 'id': # could be an object deeper in the hierarchy, so allow the obj_all version fq_path_term = '(' + fq_field + ':' + prop_slug fq_path_term += ' OR obj_all___' + fq_field + ':' + prop_slug + ')' else: fq_path_term = fq_field + ':' + prop_slug fq_path_terms.append(fq_path_term) #--------------------------------------------------- # #--------------------------------------------------- # THIS PART PREPARES FOR LOOPING OR FINAL FACET-FIELDS # # print('pred-solr-slug: ' + predicate_solr_slug) field_parts = self.make_prop_solr_field_parts(entity) act_field_data_type = field_parts['suffix'] if require_id_field: act_field_data_type = 'id' field_parts['suffix'] = 'id' # check if the last or penultimate field has # a different data-type (for linked-data) if i >= (path_list_len - 2) \ and l_prop_entity: dtypes = self.s_cache.get_dtypes(entity.uri) if isinstance(dtypes, list): # set the data type and the act-field act_field_data_type = self.get_solr_field_type(dtypes[0]) if not predicate_solr_slug or pred_prop_entity: act_field_fq = field_parts['prefix'] + '___pred_' + field_parts['suffix'] act_field_fq = self.correct_solr_prefix_for_fq(solr_f_prefix, act_field_fq) # get a facet on this field if act_field_data_type != 'string': # adds a prefix for related properties ffield = solr_f_prefix + field_parts['prefix'] + '___pred_' + field_parts['suffix'] if ffield not in query_dict['facet.field'] and \ i >= (path_list_len - 1): query_dict['facet.field'].append(ffield) else: if act_field_data_type == 'id': act_field_fq = 'obj_all___' + predicate_solr_slug \ + '___pred_' + field_parts['suffix'] # get a facet on this field if predicate_solr_slug != field_parts['prefix']: # the predicate_solr_slug is not the # prefix of the current field part, meaning # the field_parts[prefix] is the type, and # we want facets for the predicate -> type ffield = field_parts['prefix'] \ + '___' \ + predicate_solr_slug \ + '___pred_' + field_parts['suffix'] else: # get facets for the predicate ffield = field_parts['prefix'] \ + '___pred_' \ + field_parts['suffix'] # adds a prefix, in case of a related property ffield = solr_f_prefix + ffield if ffield not in query_dict['facet.field'] \ and i >= (path_list_len - 1): query_dict['facet.field'].append(ffield) else: act_field_fq = predicate_solr_slug + '___pred_' + field_parts['suffix'] # ------------------------------------------- if act_field_data_type == 'numeric': # print('Numeric field: ' + act_field) act_field_fq = field_parts['prefix'] + '___pred_numeric' act_field_fq = self.correct_solr_prefix_for_fq(solr_f_prefix, act_field_fq) query_dict = self.add_math_facet_ranges(query_dict, act_field_fq, entity) elif act_field_data_type == 'date': # print('Date field: ' + act_field) act_field_fq = field_parts['prefix'] + '___pred_date' act_field_fq = self.correct_solr_prefix_for_fq(solr_f_prefix, act_field_fq) query_dict = self.add_date_facet_ranges(query_dict, act_field_fq, entity) # print('Current data type (' + str(i) + '): ' + act_field_data_type) # print('Current field (' + str(i) + '): ' + act_field_fq) i += 1 elif act_field_data_type == 'string': # case for a text search # last_field_label = False # turn off using the field label for highlighting string_terms = self.prep_string_search_term(prop_slug) for escaped_term in string_terms: search_term = act_field_fq + ':' + escaped_term if last_field_label is False: query_dict['hl-queries'].append(escaped_term) else: query_dict['hl-queries'].append(last_field_label + ' ' + escaped_term) fq_path_terms.append(search_term) elif act_field_data_type == 'numeric': # numeric search. assume it's well formed solr numeric request search_term = act_field_fq + ':' + prop_slug fq_path_terms.append(search_term) # now limit the numeric ranges from query to the range facets query_dict = self.add_math_facet_ranges(query_dict, act_field_fq, False, prop_slug) elif act_field_data_type == 'date': # date search. assume it's well formed solr request search_term = act_field_fq + ':' + prop_slug fq_path_terms.append(search_term) # now limit the date ranges from query to the range facets query_dict = self.add_date_facet_ranges(query_dict, act_field_fq, False, prop_slug) final_path_term = ' AND '.join(fq_path_terms) final_path_term = '(' + final_path_term + ')' fq_terms.append(final_path_term) fq_final = ' OR '.join(fq_terms) fq_final = '(' + fq_final + ')' query_dict['fq'].append(fq_final) return query_dict
def get_description_tree(self, entity_obj, depth=1, first_time=True, item_type=False, class_uri=False): """ gets a hierarchy for descriptive predicates and types """ lr = LinkRecursion() if entity_obj.item_type == 'projects': tree = self.make_containment_item(entity_obj) if item_type is not False and class_uri is False: # returns the classes associated with an item_type for a project tree['label'] = tree['label'] + ', ' + item_type tree['children'] = self.get_proj_type_classes_items(entity_obj.uuid, item_type) elif item_type is not False and class_uri is not False: # returns the predicates associated with an item_type and class_uri tree['children'] = self.get_proj_type_class_preds(entity_obj.uuid, item_type, class_uri, True) else: # project root, returns the item_types for the project tree['children'] = self.get_proj_types(entity_obj.uuid) if first_time: output = [] output.append(tree) else: output = tree elif entity_obj.item_type == 'predicates': tree = self.make_containment_item(entity_obj) tree['children'] = [] child_list = lr.get_entity_children(entity_obj.uuid, False) if len(child_list) > 0: for child_uuid in child_list: child_ent = Entity() found = child_ent.dereference(child_uuid) if found: if depth > 1: child = self.get_containment_children(child_ent, depth - 1, False) else: child = self.make_containment_item(child_ent) tree['children'].append(child) elif entity_obj.data_type == 'id': top_types = lr.get_pred_top_rank_types(entity_obj.uuid) for top_type in top_types: uri = top_type['id'] uuid = URImanagement.get_uuid_from_oc_uri(uri) item = False if depth > 1: child_ent = Entity() found = child_ent.dereference(uuid) if found: item = self.get_description_tree(child_ent, depth - 1, False) else: item = LastUpdatedOrderedDict() item['id'] = uuid item['label'] = top_type['label'] item['class_uri'] = 'type' item['class_label'] = 'type' tree['children'].append(item) tree['children'] = self.sort_children_by_label(tree['children']) else: pass if first_time: output = [] output.append(tree) else: output = tree elif entity_obj.item_type == 'types': tree = self.make_containment_item(entity_obj) tree['children'] = [] act_children = lr.get_entity_children(entity_obj.uuid, False) for child_uuid in act_children: if child_uuid != entity_obj.uuid: child_ent = Entity() found = child_ent.dereference(child_uuid) if found: if depth > 1: child = self.get_description_tree(child_ent, depth - 1, False) else: child = self.make_containment_item(child_ent) child['class_uri'] = 'type' child['class_label'] = 'type' tree['children'].append(child) if len(tree['children']) == 0: tree.pop('children', None) else: tree['children'] = self.sort_children_by_label(tree['children']) if first_time: output = [] output.append(tree) else: output = tree else: output = [] return output
def get_description_tree(self, entity_obj, depth=1, first_time=True, item_type=False, class_uri=False): """ gets a hierarchy for descriptive predicates and types """ lr = LinkRecursion() if entity_obj.item_type == 'projects': tree = self.make_containment_item(entity_obj) if item_type is not False and class_uri is False: # returns the classes associated with an item_type for a project tree['label'] = tree['label'] + ', ' + item_type tree['children'] = self.get_proj_type_classes_items( entity_obj.uuid, item_type) elif item_type is not False and class_uri is not False: # returns the predicates associated with an item_type and class_uri tree['children'] = self.get_proj_type_class_preds( entity_obj.uuid, item_type, class_uri, True) else: # project root, returns the item_types for the project tree['children'] = self.get_proj_types(entity_obj.uuid) if first_time: output = [] output.append(tree) else: output = tree elif entity_obj.item_type == 'predicates': tree = self.make_containment_item(entity_obj) tree['children'] = [] child_list = lr.get_entity_children(entity_obj.uuid, False) if len(child_list) > 0: for child_uuid in child_list: child_ent = Entity() found = child_ent.dereference(child_uuid) if found: if depth > 1: child = self.get_containment_children( child_ent, depth - 1, False) else: child = self.make_containment_item(child_ent) tree['children'].append(child) elif entity_obj.data_type == 'id': top_types = lr.get_pred_top_rank_types(entity_obj.uuid) for top_type in top_types: uri = top_type['id'] uuid = URImanagement.get_uuid_from_oc_uri(uri) item = False if depth > 1: child_ent = Entity() found = child_ent.dereference(uuid) if found: item = self.get_description_tree( child_ent, depth - 1, False) else: item = LastUpdatedOrderedDict() item['id'] = uuid item['label'] = top_type['label'] item['class_uri'] = 'type' item['class_label'] = 'type' tree['children'].append(item) tree['children'] = self.sort_children_by_label( tree['children']) else: pass if first_time: output = [] output.append(tree) else: output = tree elif entity_obj.item_type == 'types': tree = self.make_containment_item(entity_obj) tree['children'] = [] act_children = lr.get_entity_children(entity_obj.uuid, False) for child_uuid in act_children: if child_uuid != entity_obj.uuid: child_ent = Entity() found = child_ent.dereference(child_uuid) if found: if depth > 1: child = self.get_description_tree( child_ent, depth - 1, False) else: child = self.make_containment_item(child_ent) child['class_uri'] = 'type' child['class_label'] = 'type' tree['children'].append(child) if len(tree['children']) == 0: tree.pop('children', None) else: tree['children'] = self.sort_children_by_label( tree['children']) if first_time: output = [] output.append(tree) else: output = tree else: output = [] return output
def _process_associated_linkedata(self): """ Finds linked data to add to index """ if '@graph' in self.oc_item.json_ld: for entity in self.oc_item.json_ld['@graph']: entity_id = self.get_entity_id(entity) if 'oc-pred:' in entity_id: # a predicate with linked data pred_slug_id = entity_id pred_datatype = self.get_predicate_datatype(pred_slug_id) pres_solr_datatype = self._get_predicate_type_string(pred_datatype) obs_values = self.get_linked_predicate_values(pred_slug_id) # values for predicate in observations for equiv_pred in self.LD_EQUIVALENT_PREDICATES: if equiv_pred in entity: # a semantic equivalence predicate exists for this oc-pred for equiv_entity in entity[equiv_pred]: equiv_id = self.get_entity_id(equiv_entity) parents = LinkRecursion().get_jsonldish_entity_parents(equiv_id) act_solr_field = self.ROOT_LINK_DATA_SOLR last_index = len(parents) - 1 for index, parent in enumerate(parents): if index == last_index: # use the predicates solr-field type, which may be numeric, date, string, or ID act_solr_datatype = pres_solr_datatype else: # use an id field type, since this is in a hierarchy that contains children act_solr_datatype = 'id' solr_value = self._concat_solr_string_value(parent['slug'], act_solr_datatype, parent['id'], parent['label']) if act_solr_field not in self.fields: self.fields[act_solr_field] = [] self.fields[act_solr_field].append(solr_value) last_linked_pred_label = parent['label'] last_linked_pred_uri = parent['id'] act_solr_field = \ self._convert_slug_to_solr(parent['slug'])\ + '___pred_' \ + act_solr_datatype # since we ended the loop above by creating a solr field, let's make sure it's added to the solrdoc self.fields['text'] += last_linked_pred_label + ': \n' act_pred_root_act_solr_field = act_solr_field if act_pred_root_act_solr_field not in self.fields: self.fields[act_pred_root_act_solr_field] = [] # -------------------------------- # Now we handle the objects of this predicate! # 1. obs_values come from the item's observations, # 2. we treat literals differently than URI objects, since URI objects maybe in a hierarchy # -------------------------------- if pred_datatype != '@id' and obs_values is not False: # objects of this predicate are literals for obs_val in obs_values: if isinstance(obs_val, dict): if pred_datatype in obs_val: self.fields[act_pred_root_act_solr_field].append(obs_val[pred_datatype]) self.fields['text'] += obs_val[pred_datatype] + '\n' else: self.fields[act_pred_root_act_solr_field].append(obs_val) self.fields['text'] += str(obs_val) + '\n' else: # objects of this predicate IDed by URIs if obs_values is not False: for obs_val in obs_values: # gets the id for the observation object obs_object_id = self.get_entity_id(obs_val) # gets linked data equivalents of the obs-object-id use_objects = self.get_equivalent_linked_data(obs_object_id) if use_objects is False: # no linked data equivalents found, so make a list w. 1 item use_objects = [{'id': obs_object_id}] for use_obj in use_objects: # make sure the active solr field is reset to be from # the last equivalent predicates. important if we're looping # through multiple use_objects last_object_uri = False last_object_label = '' act_solr_field = act_pred_root_act_solr_field #------------------------------- # Now make a solr field for ALL the objects (parents, childred) # using this predicate all_obj_solr_field = 'obj_all___' + act_pred_root_act_solr_field if all_obj_solr_field not in self.fields: self.fields[all_obj_solr_field] = [] # URI objects can be in hierarchies, look for these! object_id = self.get_entity_id(use_obj) parents = LinkRecursion().get_jsonldish_entity_parents(object_id) for index, parent in enumerate(parents): solr_value = self._concat_solr_string_value(parent['slug'], 'id', parent['id'], parent['label']) last_object_uri = parent['id'] if act_solr_field not in self.fields: self.fields[act_solr_field] = [] if parent['ld_object_ok']: # only add this if it's OK for linked data use # in presenting a facet self.fields[act_solr_field].append(solr_value) #------------------------------- # This way, you don't need to know a parent to search # for a child. Since facets aren't made with this, # it's OK for on-linked-data-ok objects to be used #------------------------------- if solr_value not in self.fields[all_obj_solr_field]: self.fields[all_obj_solr_field].append(solr_value) if parent['id'] not in self.fields['text']: self.fields['text'] += parent['id'] + ' ' self.fields['text'] += parent['label'] + '\n' act_solr_field = \ self._convert_slug_to_solr(parent['slug']) \ + '___' + act_pred_root_act_solr_field if last_object_uri is not False: self.process_object_uri(last_object_uri)