def convert_string_to_type_asserions(self, predicate_uuid): """ Converts xsd:string objects to type objects in the Assertions table """ output = False try: # look for the predicate item pred = Predicate.objects.get(uuid=predicate_uuid) pdata_type = pred.data_type except Predicate.DoesNotExist: pdata_type = False if pdata_type == 'id': # yes, the predicate has data_type = 'id', so it can take types bad_assertions = Assertion.objects\ .filter(predicate_uuid=predicate_uuid, object_type='xsd:string') output = len(bad_assertions) for bad_ass in bad_assertions: new_ass = bad_ass tm = TypeManagement() tm.get_make_type_pred_uuid_content_uuid(predicate_uuid, bad_ass.object_uuid) new_ass.object_uuid = tm.oc_type.uuid new_ass.object_type = 'types' Assertion.objects\ .filter(hash_id=bad_ass.hash_id).delete() new_ass.save() return output
def make_type_event_from_type_label_records(self, type_pred_uuid, type_field_num, start_field_num, stop_field_num): """ make event records from types identified by the predicate uuid for a type and its field number """ type_list = ImportCell.objects\ .filter(source_id=self.source_id, field_num=type_field_num) if len(type_list) > 0: for type_row in type_list: row = type_row.row_num type_label = type_row.record start_date = self.get_date_record(start_field_num, row) stop_date = self.get_date_record(stop_field_num, row) if start_date is not False\ and stop_date is not False: tmo = TypeManagement() tmo.project_uuid = self.project_uuid tmo.source_id = self.source_id type_obj = tmo.get_make_type_within_pred_uuid( type_pred_uuid, type_label) tet = TimeEventType() tet.uuid = type_obj.uuid tet.start_date = start_date tet.stop_date = stop_date tet.source_id = self.source_id tet.project_uuid = self.project_uuid tet.create_type_event()
def make_type_event_from_type_label_records(self, type_pred_uuid, type_field_num, start_field_num, stop_field_num): """ make event records from types identified by the predicate uuid for a type and its field number """ type_list = ImportCell.objects\ .filter(source_id=self.source_id, field_num=type_field_num) if len(type_list) > 0: for type_row in type_list: row = type_row.row_num type_label = type_row.record start_date = self.get_date_record(start_field_num, row) stop_date = self.get_date_record(stop_field_num, row) if start_date is not False\ and stop_date is not False: tmo = TypeManagement() tmo.project_uuid = self.project_uuid tmo.source_id = self.source_id type_obj = tmo.get_make_type_within_pred_uuid(type_pred_uuid, type_label) tet = TimeEventType() tet.uuid = type_obj.uuid tet.start_date = start_date tet.stop_date = stop_date tet.source_id = self.source_id tet.project_uuid = self.project_uuid tet.create_type_event()
def convert_string_to_type_asserions(self, predicate_uuid): """ Converts xsd:string objects to type objects in the Assertions table """ output = False try: # look for the predicate item pred = Predicate.objects.get(uuid=predicate_uuid) pdata_type = pred.data_type except Predicate.DoesNotExist: pdata_type = False if pdata_type == 'id': # yes, the predicate has data_type = 'id', so it can take types bad_assertions = Assertion.objects\ .filter(predicate_uuid=predicate_uuid, object_type='xsd:string') output = len(bad_assertions) for bad_ass in bad_assertions: new_ass = bad_ass tm = TypeManagement() tm.get_make_type_pred_uuid_content_uuid( predicate_uuid, bad_ass.object_uuid) new_ass.object_uuid = tm.oc_type.uuid new_ass.object_type = 'types' Assertion.objects\ .filter(hash_id=bad_ass.hash_id).delete() new_ass.save() return output
def make_type_ld_annotations(self, sub_type_pred_uuid, sub_type_f_num, rel_pred, obj_le_f_num): """ Makes linked data annotations for a type in an import """ rels = [] sub_type_list = ImportCell.objects\ .filter(source_id=self.source_id, field_num=sub_type_f_num) if len(sub_type_list) > 0: distinct_records = {} for cell in sub_type_list: if cell.rec_hash not in distinct_records: distinct_records[cell.rec_hash] = {} distinct_records[cell.rec_hash]['rows'] = [] distinct_records[cell.rec_hash]['imp_cell_obj'] = cell distinct_records[cell.rec_hash]['rows'].append(cell.row_num) for rec_hash_key, distinct_type in distinct_records.items(): # iterate through the distinct types and get associated linked data type_label = distinct_type['imp_cell_obj'].record rows = distinct_type['rows'] if len(type_label) > 0: # the type isn't blank, so we can use it pc = ProcessCells(self.source_id, 0) ld_entities = pc.get_field_records(obj_le_f_num, rows) for ld_hash_key, distinct_ld in ld_entities.items(): obj_uri = distinct_ld['imp_cell_obj'].record if len(obj_uri) > 8: if obj_uri[:7] == 'http://'\ or obj_uri[:8] == 'https://': # we have a valid linked data entity # # now get the UUID for the type tm = TypeManagement() tm.project_uuid = self.project_uuid tm.source_id = self.source_id sub_type = tm.get_make_type_within_pred_uuid(sub_type_pred_uuid, type_label) rel = {'subject_label': type_label, 'subject': sub_type.uuid, 'object_uri': obj_uri} rels.append(rel) if len(rels) > 0: for rel in rels: new_la = LinkAnnotation() new_la.subject = rel['subject'] new_la.subject_type = 'types' new_la.project_uuid = self.project_uuid new_la.source_id = self.source_id new_la.predicate_uri = rel_pred new_la.object_uri = rel['object_uri'] new_la.creator_uuid = '' new_la.save() web_le = WebLinkEntity() web_le.check_add_link_entity(rel['object_uri'])
def make_type_relations(self, sub_type_pred_uuid, sub_type_f_num, rel_pred, obj_type_pred_uuid, obj_type_f_num): """ Makes semantic relationships between different types in an import """ rels = {} sub_type_list = ImportCell.objects\ .filter(source_id=self.source_id, field_num=sub_type_f_num) for sub_type_obj in sub_type_list: sub_type_text = sub_type_obj.record row = sub_type_obj.row_num if len(sub_type_text) > 0: tm = TypeManagement() tm.project_uuid = self.project_uuid tm.source_id = self.source_id sub_type = tm.get_make_type_within_pred_uuid( sub_type_pred_uuid, sub_type_text) obj_type_list = ImportCell.objects\ .filter(source_id=self.source_id, field_num=obj_type_f_num, row_num=row)[:1] if len(obj_type_list) > 0: obj_type_text = obj_type_list[0].record if len(obj_type_text) > 0 \ and sub_type_text != obj_type_text: tmo = TypeManagement() tmo.project_uuid = self.project_uuid tmo.source_id = self.source_id obj_type = tmo.get_make_type_within_pred_uuid( obj_type_pred_uuid, obj_type_text) # make a uri for this, since we're making a link assertion obj_uri = URImanagement.make_oc_uri( obj_type.uuid, 'types') # the following bit is so we don't make the # same link assertions over and over. rel_id = str(sub_type.uuid) + ' ' + str(obj_type.uuid) if rel_id not in rels: rels[rel_id] = { 'subject': sub_type.uuid, 'object_uri': obj_uri } # now make the link data annotation relating these types. for rel_id, rel in rels.items(): new_la = LinkAnnotation() new_la.subject = rel['subject'] new_la.subject_type = 'types' new_la.project_uuid = self.project_uuid new_la.source_id = self.source_id new_la.predicate_uri = rel_pred new_la.object_uri = rel['object_uri'] new_la.creator_uuid = '' new_la.save()
def db_save_reconcile_entity_predicates_types(self, act_dir): """ saves predicates and type items to the Open Context database, and / or reconciles these items with previously saved items from the same project """ key = self.oc_config_entity_types json_obj = self.fm.get_dict_from_file(key, act_dir) if json_obj is None: print('Need to 1st generate an attributes file from the ArchEnts!') ok = False else: # we have JSON with dictionary for the entity_types self.entity_types = json_obj make_entity_types_assertions = False for faims_ent_type_id, ent_dict in json_obj.items(): if isinstance(ent_dict['item_type'], str) \ and ent_dict['add_type_as_attribute']: # OK we have some items that need entity types made as # a descriptive attribute make_entity_types_assertions = True break if make_entity_types_assertions: # we have entity_types that need to have a descriptive # predicate, so create a new predicate in Open Context # to describe entity_types for this project sup_dict = LastUpdatedOrderedDict() sup_dict[self.reconcile_key] = self.ent_type_pred_sup_id pm = PredicateManagement() pm.project_uuid = self.project_uuid pm.source_id = self.source_id pm.sup_dict = sup_dict pm.sup_reconcile_key = self.reconcile_key pm.sup_reconcile_value = self.ent_type_pred_sup_id pred_obj = pm.get_make_predicate( self.FAIMS_ENTITY_TYPE_PREDICATE_LABEL, 'variable', 'id') if pred_obj is not False: # we reconciled or created the predicate! # now we mint oc_types for all the entity_types predicate_uuid = str(pred_obj.uuid) for faims_ent_type_id, ent_dict in json_obj.items(): if isinstance(ent_dict['item_type'], str) \ and ent_dict['add_type_as_attribute']: # OK, we have an item entity type to be used as a description sup_dict = LastUpdatedOrderedDict() sup_dict[self.reconcile_key] = faims_ent_type_id tm = TypeManagement() tm.project_uuid = self.project_uuid tm.source_id = self.source_id tm.sup_dict = sup_dict tm.sup_reconcile_key = self.reconcile_key tm.sup_reconcile_value = faims_ent_type_id type_obj = tm.get_make_type_within_pred_uuid( predicate_uuid, ent_dict['label']) if type_obj is not False: # we have reconciled the type! ent_dict['type_uuid'] = str(type_obj.uuid) ent_dict['predicate_uuid'] = predicate_uuid self.entity_types[faims_ent_type_id] = ent_dict # now save the results self.fm.save_serialized_json(key, act_dir, self.entity_types)
def create_concept_parents(self, new_hierachic_list): """ Creates new types for superior (more general) types from a list of types that have hiearchies implicit in their labels once the superior types are created, linked data annotations noting hierarchy are stored """ parent_children_pairs = [] for manifest in new_hierachic_list: try: oc_type = OCtype.objects.get(uuid=manifest.uuid) except OCtype.DoesNotExist: oc_type = False if (oc_type is not False): child_parts = manifest.label.split(self.HIERARCHY_DELIM) act_delim = '' act_new_label = '' current_parent = False for label_part in child_parts: act_new_label = act_new_label + act_delim + label_part act_delim = self.HIERARCHY_DELIM type_manage = TypeManagement() type_manage.project_uuid = oc_type.project_uuid type_manage.source_id = self.source_id ptype = type_manage.get_make_type_within_pred_uuid( oc_type.predicate_uuid, act_new_label) if (current_parent is not False): parent_child = { 'parent': current_parent, 'child': ptype.uuid } parent_children_pairs.append(parent_child) current_parent = ptype.uuid if (len(parent_children_pairs) > 0): # now make some linked data annotations for parent_child in parent_children_pairs: if (parent_child['parent'] is not False): new_la = LinkAnnotation() new_la.subject = parent_child['child'] new_la.subject_type = 'types' new_la.project_uuid = oc_type.project_uuid new_la.source_id = self.source_id new_la.predicate_uri = self.p_for_superobjs new_la.object_uri = URImanagement.make_oc_uri( parent_child['parent'], 'types') new_la.creator_uuid = '' new_la.save() return parent_children_pairs
def create_concept_parents(self, new_hierachic_list): """ Creates new types for superior (more general) types from a list of types that have hiearchies implicit in their labels once the superior types are created, linked data annotations noting hierarchy are stored """ parent_children_pairs = [] for manifest in new_hierachic_list: try: oc_type = OCtype.objects.get(uuid=manifest.uuid) except OCtype.DoesNotExist: oc_type = False if(oc_type is not False): child_parts = manifest.label.split(self.HIERARCHY_DELIM) act_delim = '' act_new_label = '' current_parent = False for label_part in child_parts: act_new_label = act_new_label + act_delim + label_part act_delim = self.HIERARCHY_DELIM type_manage = TypeManagement() type_manage.project_uuid = oc_type.project_uuid type_manage.source_id = self.source_id ptype = type_manage.get_make_type_within_pred_uuid(oc_type.predicate_uuid, act_new_label) if(current_parent is not False): parent_child = {'parent': current_parent, 'child': ptype.uuid} parent_children_pairs.append(parent_child) current_parent = ptype.uuid if(len(parent_children_pairs) > 0): # now make some linked data annotations for parent_child in parent_children_pairs: if(parent_child['parent'] is not False): new_la = LinkAnnotation() new_la.subject = parent_child['child'] new_la.subject_type = 'types' new_la.project_uuid = oc_type.project_uuid new_la.source_id = self.source_id new_la.predicate_uri = self.p_for_superobjs new_la.object_uri = URImanagement.make_oc_uri(parent_child['parent'], 'types') new_la.creator_uuid = '' new_la.save() return parent_children_pairs
def db_save_reconcile_predicates_types(self, act_dir): """ saves predicates and type items to the Open Context database, and / or reconciles these items with previously saved items from the same project """ key = self.oc_config_attributes json_obj = self.fm.get_dict_from_file(key, act_dir) if json_obj is None: print('Need to 1st generate an attributes file from the ArchEnts!') ok = False else: # we have JSON with dictionary for the attributes ok = True self.attributes = json_obj for faims_id_pred, attrib_dict in json_obj.items(): # default to always making a predicate and a type for attributes sup_dict = LastUpdatedOrderedDict() sup_dict[self.reconcile_key] = faims_id_pred pm = PredicateManagement() pm.project_uuid = self.project_uuid pm.source_id = self.source_id pm.sup_dict = sup_dict pm.sup_reconcile_key = self.reconcile_key pm.sup_reconcile_value = faims_id_pred pred_obj = pm.get_make_predicate(attrib_dict['label'], attrib_dict['predicate_type'], attrib_dict['data_type']) if pred_obj is not False: # we reconciled the predicate! self.attributes[faims_id_pred]['predicate_uuid'] = str( pred_obj.uuid) if 'objects' in attrib_dict: for faims_id_type, type_dict in attrib_dict[ 'objects'].items(): sup_dict = LastUpdatedOrderedDict() sup_dict[self.reconcile_key] = faims_id_type tm = TypeManagement() tm.project_uuid = self.project_uuid tm.source_id = self.source_id tm.sup_dict = sup_dict tm.sup_reconcile_key = self.reconcile_key tm.sup_reconcile_value = faims_id_type type_obj = tm.get_make_type_within_pred_uuid( pred_obj.uuid, type_dict['label']) if type_obj is not False: # we have reconciled the type! type_dict['type_uuid'] = str(type_obj.uuid) type_dict['predicate_uuid'] = str( pred_obj.uuid) self.attributes[faims_id_pred]['objects'][ faims_id_type] = type_dict # now save the results self.fm.save_serialized_json(key, act_dir, self.attributes)
def make_type_relations(self, sub_type_pred_uuid, sub_type_f_num, rel_pred, obj_type_pred_uuid, obj_type_f_num): """ Makes semantic relationships between different types in an import """ rels = {} sub_type_list = ImportCell.objects\ .filter(source_id=self.source_id, field_num=sub_type_f_num) for sub_type_obj in sub_type_list: sub_type_text = sub_type_obj.record row = sub_type_obj.row_num if len(sub_type_text) > 0: tm = TypeManagement() tm.project_uuid = self.project_uuid tm.source_id = self.source_id sub_type = tm.get_make_type_within_pred_uuid(sub_type_pred_uuid, sub_type_text) obj_type_list = ImportCell.objects\ .filter(source_id=self.source_id, field_num=obj_type_f_num, row_num=row)[:1] if len(obj_type_list) > 0: obj_type_text = obj_type_list[0].record if len(obj_type_text) > 0 \ and sub_type_text != obj_type_text: tmo = TypeManagement() tmo.project_uuid = self.project_uuid tmo.source_id = self.source_id obj_type = tmo.get_make_type_within_pred_uuid(obj_type_pred_uuid, obj_type_text) # make a uri for this, since we're making a link assertion obj_uri = URImanagement.make_oc_uri(obj_type.uuid, 'types') # the following bit is so we don't make the # same link assertions over and over. rel_id = str(sub_type.uuid) + ' ' + str(obj_type.uuid) if rel_id not in rels: rels[rel_id] = {'subject': sub_type.uuid, 'object_uri': obj_uri} # now make the link data annotation relating these types. for rel_id, rel in rels.items(): new_la = LinkAnnotation() new_la.subject = rel['subject'] new_la.subject_type = 'types' new_la.project_uuid = self.project_uuid new_la.source_id = self.source_id new_la.predicate_uri = rel_pred new_la.object_uri = rel['object_uri'] new_la.creator_uuid = '' new_la.save()
def add_type(self, predicate_uuid, type_uuid, string_uuid, label): """ adds the predicate """ tm = TypeManagement() tm.source_id = self.source_id tm.project_uuid = self.project_uuid tm.suggested_uuid = type_uuid tm.suggested_content_uuid = string_uuid type_obj = tm.get_make_type_within_pred_uuid(predicate_uuid, label) return type_obj
def reconcile_type_cell(self, predicate_uuid, content_uuid, imp_cell, row_num=False): """ reconciles a distinct type, with consideration for how the """ output = False if len(imp_cell.record) > 0 \ and predicate_uuid is not False \ and content_uuid is not False: output = True tm = TypeManagement() tm.project_uuid = imp_cell.project_uuid tm.source_id = imp_cell.source_id self.oc_type = tm.get_make_type_pred_uuid_content_uuid(predicate_uuid, content_uuid) # self.source_id = self.oc_type.source_id if self.oc_type.uuid != imp_cell.fl_uuid \ or self.oc_type.content_uuid != imp_cell.l_uuid: # update the reconcilted UUID for import cells with same rec_hash if row_num is False: up_cells = ImportCell.objects\ .filter(source_id=self.source_id, field_num=imp_cell.field_num, rec_hash=imp_cell.rec_hash) else: up_cells = ImportCell.objects\ .filter(source_id=self.source_id, field_num=imp_cell.field_num, row_num=row_num) for up_cell in up_cells: # save each cell with the correct UUID up_cell.fl_uuid = self.oc_type.uuid up_cell.l_uuid = self.oc_type.content_uuid up_cell.uuids_save() return output
def db_save_reconcile_predicates_types(self, act_dir): """ saves predicates and type items to the Open Context database, and / or reconciles these items with previously saved items from the same project """ key = self.oc_config_attributes json_obj = self.fm.get_dict_from_file(key, act_dir) if json_obj is None: print('Need to 1st generate an attributes file from the ArchEnts!') ok = False else: # we have JSON with dictionary for the attributes ok = True self.attributes = json_obj for faims_id_pred, attrib_dict in json_obj.items(): # default to always making a predicate and a type for attributes sup_dict = LastUpdatedOrderedDict() sup_dict[self.reconcile_key] = faims_id_pred pm = PredicateManagement() pm.project_uuid = self.project_uuid pm.source_id = self.source_id pm.sup_dict = sup_dict pm.sup_reconcile_key = self.reconcile_key pm.sup_reconcile_value = faims_id_pred pred_obj = pm.get_make_predicate(attrib_dict['label'], attrib_dict['predicate_type'], attrib_dict['data_type']) if pred_obj is not False: # we reconciled the predicate! self.attributes[faims_id_pred]['predicate_uuid'] = str(pred_obj.uuid) if 'objects' in attrib_dict: for faims_id_type, type_dict in attrib_dict['objects'].items(): sup_dict = LastUpdatedOrderedDict() sup_dict[self.reconcile_key] = faims_id_type tm = TypeManagement() tm.project_uuid = self.project_uuid tm.source_id = self.source_id tm.sup_dict = sup_dict tm.sup_reconcile_key = self.reconcile_key tm.sup_reconcile_value = faims_id_type type_obj = tm.get_make_type_within_pred_uuid(pred_obj.uuid, type_dict['label']) if type_obj is not False: # we have reconciled the type! type_dict['type_uuid'] = str(type_obj.uuid) type_dict['predicate_uuid'] = str(pred_obj.uuid) self.attributes[faims_id_pred]['objects'][faims_id_type] = type_dict # now save the results self.fm.save_serialized_json(key, act_dir, self.attributes)
def create_type(self, post_data): """ creates a type item into a project """ ok = True required_params = [ 'source_id', 'item_type', 'predicate_uuid', 'label', 'note' ] for r_param in required_params: if r_param not in post_data: # we're missing some required data # don't create the item ok = False message = 'Missing paramater: ' + r_param + '' if self.errors['params'] is False: self.errors['params'] = message else: self.errors['params'] += '; ' + message # now prep the type management ! tm = TypeManagement() tm.project_uuid = self.project_uuid uuid = False content_uuid = False if ok: # now check to see if this already exists label = post_data['label'].strip() type_note = post_data['note'].strip() tm.source_id = post_data['source_id'].strip() predicate_uuid = post_data['predicate_uuid'].strip() if self.check_non_blank_param(post_data, 'uuid')\ and self.check_non_blank_param(post_data, 'content_uuid'): uuid = post_data['uuid'].strip() if self.check_uuid_format(uuid): uuid_exists = self.check_uuid_exists(uuid) if uuid_exists: ok = False self.errors[ 'uuid'] = 'Cannot create a category called "' + label + '"' self.errors[ 'uuid'] += ', becuase the submitted UUID: ' + uuid self.errors['uuid'] += ' already exists.' note = self.errors['uuid'] else: # ok! use this as the suggested UUID for making a new type tm.suggested_uuid = uuid content_uuid = self.validate_content_uuid( tm, post_data) if content_uuid is False: ok = False note = self.errors['content_uuid'] else: # ok! the content uuid is also OK to use tm.suggested_content_uuid = content_uuid else: ok = False self.errors[ 'uuid'] = 'Cannot create a category called "' + label + '"' self.errors[ 'uuid'] += ', becuase the submitted UUID: ' + uuid self.errors['uuid'] += ' is badly formed.' note = self.errors['uuid'] elif self.check_non_blank_param(post_data, 'uuid') \ and not self.check_non_blank_param(post_data, 'content_uuid'): # we have a uuid for the type, but not the content. We can't # create the type however, since we're missing a content uuid uuid = post_data['uuid'].strip() ok = False self.errors[ 'uuid'] = 'Cannot create a category called "' + label + '"' self.errors['uuid'] += ', becuase the submitted UUID: ' + str( uuid) self.errors['uuid'] += ' needs to have a valid Content UUID.' note = self.errors['uuid'] elif not self.check_non_blank_param(post_data, 'uuid') \ and self.check_non_blank_param(post_data, 'content_uuid'): # we have a uuid for the content only. a weird case, but possible content_uuid = self.validate_content_uuid(tm, post_data) if content_uuid is False: ok = False note = self.errors['content_uuid'] else: # ok! the content uuid is also OK to use tm.suggested_content_uuid = content_uuid else: label = '[Item not created]' uuid = False if ok: type_uuid = tm.check_exists_pred_uuid_content( predicate_uuid, label, True) if type_uuid is not False: # we already have this type! ok = False uuid = type_uuid self.errors[ 'uuid'] = 'Cannot create a category called "' + label + '"' self.errors[ 'uuid'] += ', becuase it already exists with UUID: ' + uuid note = self.errors['uuid'] if ok: tm.source_id = post_data['source_id'].strip() if content_uuid is False: newtype = tm.get_make_type_within_pred_uuid( predicate_uuid, label) content_uuid = newtype.content_uuid uuid = newtype.uuid else: tm.content = label newtype = tm.get_make_type_pred_uuid_content_uuid( predicate_uuid, content_uuid) content_uuid = newtype.content_uuid uuid = newtype.uuid # now add the note if not empty self.add_description_note(newtype.uuid, 'types', newtype.source_id, type_note) self.response = { 'action': 'create-item-into', 'ok': ok, 'change': { 'uuid': uuid, 'content_uuid': content_uuid, 'label': label, 'note': self.add_creation_note(ok) } } return self.response
def db_save_reconcile_entity_predicates_types(self, act_dir): """ saves predicates and type items to the Open Context database, and / or reconciles these items with previously saved items from the same project """ key = self.oc_config_entity_types json_obj = self.fm.get_dict_from_file(key, act_dir) if json_obj is None: print('Need to 1st generate an attributes file from the ArchEnts!') ok = False else: # we have JSON with dictionary for the entity_types self.entity_types = json_obj make_entity_types_assertions = False for faims_ent_type_id, ent_dict in json_obj.items(): if isinstance(ent_dict['item_type'], str) \ and ent_dict['add_type_as_attribute']: # OK we have some items that need entity types made as # a descriptive attribute make_entity_types_assertions = True break if make_entity_types_assertions: # we have entity_types that need to have a descriptive # predicate, so create a new predicate in Open Context # to describe entity_types for this project sup_dict = LastUpdatedOrderedDict() sup_dict[self.reconcile_key] = self.ent_type_pred_sup_id pm = PredicateManagement() pm.project_uuid = self.project_uuid pm.source_id = self.source_id pm.sup_dict = sup_dict pm.sup_reconcile_key = self.reconcile_key pm.sup_reconcile_value = self.ent_type_pred_sup_id pred_obj = pm.get_make_predicate(self.FAIMS_ENTITY_TYPE_PREDICATE_LABEL, 'variable', 'id') if pred_obj is not False: # we reconciled or created the predicate! # now we mint oc_types for all the entity_types predicate_uuid = str(pred_obj.uuid) for faims_ent_type_id, ent_dict in json_obj.items(): if isinstance(ent_dict['item_type'], str) \ and ent_dict['add_type_as_attribute']: # OK, we have an item entity type to be used as a description sup_dict = LastUpdatedOrderedDict() sup_dict[self.reconcile_key] = faims_ent_type_id tm = TypeManagement() tm.project_uuid = self.project_uuid tm.source_id = self.source_id tm.sup_dict = sup_dict tm.sup_reconcile_key = self.reconcile_key tm.sup_reconcile_value = faims_ent_type_id type_obj = tm.get_make_type_within_pred_uuid(predicate_uuid, ent_dict['label']) if type_obj is not False: # we have reconciled the type! ent_dict['type_uuid'] = str(type_obj.uuid) ent_dict['predicate_uuid'] = predicate_uuid self.entity_types[faims_ent_type_id] = ent_dict # now save the results self.fm.save_serialized_json(key, act_dir, self.entity_types)
def create_type(self, post_data): """ creates a type item into a project """ ok = True required_params = ['source_id', 'item_type', 'predicate_uuid', 'label', 'note'] for r_param in required_params: if r_param not in post_data: # we're missing some required data # don't create the item ok = False message = 'Missing paramater: ' + r_param + '' self.errors.append(message) # now prep the type management ! tm = TypeManagement() tm.project_uuid = self.project_uuid uuid = False content_uuid = False if ok: # now check to see if this already exists label = post_data['label'].strip() type_note = post_data['note'].strip() tm.source_id = post_data['source_id'].strip() predicate_uuid = post_data['predicate_uuid'].strip() if self.check_non_blank_param(post_data, 'uuid')\ and self.check_non_blank_param(post_data, 'content_uuid'): uuid = post_data['uuid'].strip() if self.check_uuid_format(uuid): uuid_exists = self.check_uuid_exists(uuid) if uuid_exists: ok = False message = 'Cannot create a category called "' + label + '"' message += ', becuase the submitted UUID: ' + uuid message += ' already exists.' self.errors.append(message) note = '; '.join(self.errors) else: # ok! use this as the suggested UUID for making a new type tm.suggested_uuid = uuid content_uuid = self.validate_content_uuid(tm, post_data) if content_uuid is False: ok = False note = '; '.join(self.errors) else: # ok! the content uuid is also OK to use tm.suggested_content_uuid = content_uuid else: ok = False mesaage = 'Cannot create a category called "' + label + '"' mesaage += ', becuase the submitted UUID: ' + uuid mesaage += ' is badly formed.' self.errors.append(message) note = '; '.join(self.errors) elif self.check_non_blank_param(post_data, 'uuid') \ and not self.check_non_blank_param(post_data, 'content_uuid'): # we have a uuid for the type, but not the content. We can't # create the type however, since we're missing a content uuid uuid = post_data['uuid'].strip() ok = False mesaage = 'Cannot create a category called "' + label + '"' mesaage += ', becuase the submitted UUID: ' + str(uuid) mesaage += ' needs to have a valid Content UUID.' self.errors.append(message) note = '; '.join(self.errors) elif not self.check_non_blank_param(post_data, 'uuid') \ and self.check_non_blank_param(post_data, 'content_uuid'): # we have a uuid for the content only. a weird case, but possible content_uuid = self.validate_content_uuid(tm, post_data) if content_uuid is False: ok = False note = '; '.join(self.errors) else: # ok! the content uuid is also OK to use tm.suggested_content_uuid = content_uuid else: label = '[Item not created]' uuid = False if ok: type_uuid = tm.check_exists_pred_uuid_content(predicate_uuid, label, True) if type_uuid is not False: # we already have this type! ok = False uuid = str(type_uuid) message = 'Cannot create a category called "' + label + '"' message += ', becuase it already exists with UUID: ' + uuid self.errors.append(message) note = '; '.join(self.errors) if ok: tm.source_id = post_data['source_id'].strip() if content_uuid is False: newtype = tm.get_make_type_within_pred_uuid(predicate_uuid, label) content_uuid = str(newtype.content_uuid) uuid = str(newtype.uuid) else: tm.content = label newtype = tm.get_make_type_pred_uuid_content_uuid(predicate_uuid, content_uuid) content_uuid = newtype.content_uuid uuid = newtype.uuid # now add the note if not empty self.add_description_note(newtype.uuid, 'types', newtype.source_id, type_note) if ok: # now clear the cache a change was made self.created_uuid = uuid self.clear_caches() self.response = {'action': 'create-item-into', 'ok': ok, 'change': {'uuid': uuid, 'content_uuid': content_uuid, 'label': label, 'note': self.add_creation_note(ok)}} return self.response