def test_persist_new_positive(self): concept = Concept( mnemonic='concept1', created_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.concepts)) kwargs = { 'parent_resource': self.source1, } errors = Concept.persist_new(concept, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists()) self.assertFalse(concept.retired) self.assertEquals(self.name.name, concept.display_name) self.assertEquals(self.name.locale, concept.display_locale) self.assertEquals(self.source1.owner_name, concept.owner_name) self.assertEquals(self.source1.owner_type, concept.owner_type) self.assertEquals(self.source1.public_access, concept.public_access) self.assertEquals(1, concept.num_versions) concept_version = ConceptVersion.get_latest_version_of(concept) self.assertEquals(concept_version, concept_version.root_version) source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.concepts)) self.assertTrue(concept_version.id in source_version.concepts) self.assertEquals(concept_version.mnemonic, concept_version.id)
def create_concept(user, source, names=None, mnemonic=None, descriptions=None, concept_class=None, datatype=None, force=False): suffix = generate_random_string() if not names and not force: names = [create_localized_text("name{0}".format(suffix))] if not mnemonic and not force: mnemonic = 'concept{0}'.format(suffix) if not descriptions and not force: descriptions = [create_localized_text("desc{0}".format(suffix))] concept = Concept( mnemonic=mnemonic, updated_by=user, datatype=datatype if datatype else "None", concept_class = concept_class if concept_class else 'Diagnosis', names=names, descriptions=descriptions, ) if source is not None: kwargs = { 'parent_resource': source, } errors = Concept.persist_new(concept, user, **kwargs) else: errors = Concept.persist_new(concept, user) return concept, errors
def test_get_latest_version(self): source = Source(name='source', mnemonic='source', full_name='Source One', source_type='Dictionary', public_access=ACCESS_TYPE_EDIT, default_locale='en', supported_locales=['en'], website='www.source1.com', description='This is the first test source') kwargs = {'parent_resource': self.org1} Source.persist_new(source, self.user1, **kwargs) concept1 = Concept( mnemonic='concept12', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(concept1, self.user1, **kwargs) concept = Concept.objects.get(mnemonic=concept1.mnemonic) concept_version1 = ConceptVersion.objects.get( versioned_object_id=concept.id) self.assertEquals(concept.get_latest_version.id, concept_version1.id)
def create_concept(user, source, names=None, mnemonic=None, descriptions=None, concept_class=None): suffix = generate_random_string() if not names: names = [create_localized_text("name{0}".format(suffix))] if not mnemonic: mnemonic = 'concept{0}'.format(suffix) if not descriptions: descriptions = [create_localized_text("desc{0}".format(suffix))] concept = Concept( mnemonic=mnemonic, updated_by=user, datatype="None", concept_class=concept_class if concept_class else 'First', names=names, descriptions=descriptions, ) if source is not None: kwargs = { 'parent_resource': source, } errors = Concept.persist_new(concept, user, **kwargs) else: errors = Concept.persist_new(concept, user) return (concept, errors)
def test_concept_display_name_preferred(self): concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', ) display_name1 = LocalizedText( name='concept1', locale='en', locale_preferred=True ) concept.names.append(display_name1) display_name2 = LocalizedText( name='le concept1', locale='fr' ) concept.names.append(display_name2) concept.full_clean() concept.save() self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists()) self.assertFalse(concept.retired) self.assertEquals(display_name1.name, concept.display_name) self.assertEquals(display_name1.locale, concept.display_locale) self.assertEquals(self.source1.owner_name, concept.owner_name) self.assertEquals(self.source1.owner_type, concept.owner_type) self.assertEquals(0, concept.num_versions)
def setUp(self): super(ConceptVersionTest, self).setUp() self.concept1 = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', external_id='EXTID', names=[self.name], ) display_name = LocalizedText( name='concept1', locale='en' ) self.concept1.names.append(display_name) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept1, self.user1, **kwargs) self.concept2 = Concept( mnemonic='concept2', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='Second', names=[self.name], ) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept2, self.user1, **kwargs)
def setUp(self): super(ConceptVersionStaticMethodsTest, self).setUp() self.concept1 = Concept( mnemonic='concept1', concept_class='First', public_access=ACCESS_TYPE_EDIT) display_name = LocalizedText(name='concept1', locale='en') self.concept1.names.append(display_name) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept1, self.user1, **kwargs) initial_version = ConceptVersion.get_latest_version_of(self.concept1) self.concept2 = Concept(mnemonic='concept2', concept_class='Second', names=[self.name]) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept2, self.user1, **kwargs) self.concept_version = ConceptVersion( mnemonic='version1', versioned_object=self.concept1, concept_class='First', names=self.concept1.names, previous_version=initial_version, created_by=self.user1.username, updated_by=self.user1.username, version_created_by=self.user1.username, ) self.concept_version.full_clean() self.concept_version.save()
def test_import_job_for_change_in_data(self): stdout_stub = TestStream() concept = Concept( mnemonic='1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='Diagnosis', external_id='1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', names=[self.name]) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(concept, self.user1, **kwargs) importer = ConceptsImporter(self.source1, self.testfile, 'test', stdout_stub, TestStream()) importer.import_concepts(total=1) all_concept_versions = ConceptVersion.objects.all() self.assertEquals(len(all_concept_versions), 2) latest_concept_version = [version for version in all_concept_versions if version.previous_version][0] self.assertEquals(len(latest_concept_version.names), 4) self.assertTrue(( 'Updated concept, replacing version ID ' + latest_concept_version.previous_version.id) in stdout_stub.getvalue()) self.assertTrue('concepts of 1 1 - 1 updated' in stdout_stub.getvalue())
def test_import_job_for_change_in_data(self): stdout_stub = TestStream() concept = Concept(mnemonic='1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='Diagnosis', external_id='1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', names=[self.name]) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(concept, self.user1, **kwargs) importer = ConceptsImporter(self.source1, self.testfile, 'test', stdout_stub, TestStream()) importer.import_concepts(total=1) all_concept_versions = ConceptVersion.objects.all() self.assertEquals(len(all_concept_versions), 2) latest_concept_version = [ version for version in all_concept_versions if version.previous_version ][0] self.assertEquals(len(latest_concept_version.names), 4) self.assertTrue(('Updated concept, replacing version ID ' + latest_concept_version.previous_version.id ) in stdout_stub.getvalue()) self.assertTrue( 'concepts of 1 1 - 1 updated' in stdout_stub.getvalue())
def test_retire_positive(self): source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.concepts)) concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) kwargs = { 'parent_resource': self.source1, } errors = Concept.persist_new(concept, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists()) self.assertFalse(concept.retired) self.assertEquals(1, concept.num_versions) concept_version = ConceptVersion.get_latest_version_of(concept) self.assertTrue(concept_version.is_latest_version) self.assertFalse(concept_version.retired) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(1, len(source_version.concepts)) self.assertEquals(concept_version.id, source_version.concepts[0]) errors = Concept.retire(concept, self.user1) self.assertFalse(errors) self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists()) self.assertTrue(concept.retired) self.assertEquals(2, concept.num_versions) previous_version = ConceptVersion.objects.get(id=concept_version.id) self.assertFalse(previous_version.is_latest_version) self.assertFalse(previous_version.retired) concept_version = ConceptVersion.get_latest_version_of(concept) self.assertTrue(concept_version.is_latest_version) self.assertTrue(concept_version.retired) self.assertEquals(self.user1.username, concept_version.version_created_by) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(1, len(source_version.concepts)) self.assertEquals(concept_version.id, source_version.concepts[0]) self.assertEquals( 1, ConceptVersion.objects.filter(versioned_object_id=concept.id, retired=True).count()) self.assertEquals( 1, ConceptVersion.objects.filter(versioned_object_id=concept.id, retired=False).count()) errors = Concept.retire(concept, self.user1) self.assertEquals(1, len(errors))
def test_create_concept_negative__no_class(self): with self.assertRaises(ValidationError): concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, names=[self.name], ) concept.full_clean() concept.save()
def test_resolve(self): c = Concept(uri="http://www.digitalhps.org/concepts/CONe5b55803-1ef6-4abe-b81c-1493e97421df", authority="ConceptpowerAuthority") c.save() resolve(Concept, c) resolve(Type, c.typed) self.assertTrue(hasattr(c, 'typed')) self.assertFalse(c.typed is None) self.assertTrue(c.resolved) self.assertTrue(c.typed.resolved) self.assertEqual(c.pos, 'noun')
def test_persist_new_negative__repeated_mnemonic(self): concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.concepts)) kwargs = { 'parent_resource': self.source1, } errors = Concept.persist_new(concept, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists()) self.assertFalse(concept.retired) self.assertEquals(self.name.name, concept.display_name) self.assertEquals(self.name.locale, concept.display_locale) self.assertEquals(self.source1.owner_name, concept.owner_name) self.assertEquals(self.source1.owner_type, concept.owner_type) self.assertEquals(self.source1.public_access, concept.public_access) self.assertEquals(1, concept.num_versions) concept_version = ConceptVersion.get_latest_version_of(concept) source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.concepts)) self.assertTrue(concept_version.id in source_version.concepts) # Repeat with same mnemonic concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) kwargs = { 'parent_resource': self.source1, } errors = Concept.persist_new(concept, self.user1, **kwargs) self.assertEquals(1, len(errors)) self.assertTrue('__all__' in errors) self.assertEquals(0, concept.num_versions) source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.concepts))
def test_dispatch_with_head_and_versions(self): source_version = SourceVersion( name='version1', mnemonic='version1', versioned_object=self.source1, released=True, created_by=self.user1, updated_by=self.user1, ) source_version.full_clean() source_version.save() concept2 = Concept( mnemonic='concept2', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='not First', external_id='EXTID', names=[self.name], ) display_name = LocalizedText( name='concept2', locale='en' ) concept2.names.append(display_name) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(concept2, self.user1, **kwargs) self.client.login(username='******', password='******') kwargs = { 'org': self.org1.mnemonic, 'source': self.source1.mnemonic } response = self.client.get(reverse('concept-create', kwargs=kwargs)) self.assertEquals(response.status_code, 200) content = json.loads(response.content) self.assertEquals(2, len(content)) source_head_concepts = SourceVersion.objects.get(mnemonic='HEAD', versioned_object_id=self.source1.id).concepts self.assertEquals(2, len(source_head_concepts)) for concept in content: self.assertTrue(concept['version'] in source_head_concepts)
def setUp(self): super(ConceptVersionStaticMethodsTest, self).setUp() self.concept1 = Concept(mnemonic='concept1', concept_class='First', public_access=ACCESS_TYPE_EDIT) display_name = LocalizedText(name='concept1', locale='en') self.concept1.names.append(display_name) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept1, self.user1, **kwargs) initial_version = ConceptVersion.get_latest_version_of(self.concept1) self.concept2 = Concept(mnemonic='concept2', concept_class='Second', names=[self.name]) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept2, self.user1, **kwargs) self.concept_version = ConceptVersion( mnemonic='version1', versioned_object=self.concept1, concept_class='First', names=self.concept1.names, previous_version=initial_version, created_by=self.user1.username, updated_by=self.user1.username, version_created_by=self.user1.username, ) self.concept_version.full_clean() self.concept_version.save()
def test_create_concept_positive(self): concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) concept.full_clean() concept.save() self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists()) self.assertFalse(concept.retired) self.assertEquals(self.name.name, concept.display_name) self.assertEquals(self.name.locale, concept.display_locale) self.assertEquals(self.source1.owner_name, concept.owner_name) self.assertEquals(self.source1.owner_type, concept.owner_type) self.assertEquals(0, concept.num_versions)
def create_concept(user, source, source_version=None, names=None, mnemonic=None, descriptions=None, concept_class=None, datatype=None, force=False, extras=None): suffix = generate_random_string() if not names and not force: names = [create_localized_text("name{0}".format(suffix))] if not mnemonic and not force: mnemonic = 'concept{0}'.format(suffix) if not descriptions and not force: descriptions = [create_localized_text("desc{0}".format(suffix))] concept = Concept( mnemonic=mnemonic, updated_by=user, datatype=datatype if datatype else "None", concept_class=concept_class if concept_class else 'Diagnosis', names=names, descriptions=descriptions, extras=extras) if source is not None: kwargs = { 'parent_resource': source, } if source_version is not None: kwargs['parent_resource_version'] = source_version errors = Concept.persist_new(concept, user, **kwargs) else: errors = Concept.persist_new(concept, user) return concept, errors
def destroy(self, request, *args, **kwargs): self.permission_classes = (CanEditParentDictionary, ) concept = self.get_object_or_none() if concept is None: return Response( {'non_field_errors': 'Could not find concept to retire'}, status=status.HTTP_404_NOT_FOUND) errors = Concept.retire(concept, request.user) if errors: return Response(errors, status=status.HTTP_400_BAD_REQUEST) return Response(status=status.HTTP_204_NO_CONTENT)
def test_persist_new_negative__no_parent(self): concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.concepts)) errors = Concept.persist_new(concept, self.user1) self.assertEquals(1, len(errors)) self.assertTrue('parent' in errors) self.assertFalse(Concept.objects.filter(mnemonic='concept1').exists()) self.assertEquals(0, concept.num_versions) source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(0, len(source_version.concepts))
def test_update_concept_with_invalid_record(self): concept = Concept( mnemonic='1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='Diagnosis', external_id='1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', names=[self.name]) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(concept, self.user1, **kwargs) self.testfile = open('./integration_tests/fixtures/concept_without_fully_specified_name.json', 'rb') stderr_stub = TestStream() importer = ConceptsImporter(self.source1, self.testfile, 'test', TestStream(), stderr_stub) importer.import_concepts(total=1) self.assertTrue('Concept requires at least one fully specified name' in stderr_stub.getvalue()) self.assertEquals(1, Concept.objects.count()) self.assertEquals(1, ConceptVersion.objects.count())
def destroy(self, request, *args, **kwargs): self.permission_classes = (CanEditParentDictionary,) concept = self.get_object_or_none() if concept is None: return Response( {'non_field_errors': 'Could not find concept to retire'}, status=status.HTTP_404_NOT_FOUND) errors = Concept.retire(concept, request.user) if errors: return Response(errors, status=status.HTTP_400_BAD_REQUEST) return Response(status=status.HTTP_204_NO_CONTENT)
def test_persist_new_positive__earlier_source_version(self): version1 = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(version1.concepts)) version2 = SourceVersion.for_base_object(self.source1, label='version2') version2.save() self.assertEquals(0, len(version2.concepts)) concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) kwargs = { 'parent_resource': self.source1, 'parent_resource_version': version1 } errors = Concept.persist_new(concept, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists()) self.assertFalse(concept.retired) self.assertEquals(self.name.name, concept.display_name) self.assertEquals(self.name.locale, concept.display_locale) self.assertEquals(self.source1.owner_name, concept.owner_name) self.assertEquals(self.source1.owner_type, concept.owner_type) self.assertEquals(self.source1.public_access, concept.public_access) self.assertEquals(1, concept.num_versions) concept_version = ConceptVersion.get_latest_version_of(concept) self.assertEquals(concept_version, concept_version.root_version) version1 = SourceVersion.objects.get(id=version1.id) self.assertEquals(1, len(version1.concepts)) self.assertTrue(concept_version.id in version1.concepts) version2 = SourceVersion.objects.get(id=version2.id) self.assertEquals(0, len(version2.concepts)) self.assertFalse(concept_version.id in version2.concepts)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.data["cs_name"] = self.data["variable_name"] self.data["name"] = self.data["variable_name"].lower() self.data["dataset"] = Dataset.get_or_create( dict(name=self.data["dataset_name"].lower(), study=self.data["study_object"])).pk if self.data.get("concept_name", "") == "": self.data["concept"] = None else: self.data["concept"] = Concept.get_or_create( dict(name=self.data["concept_name"].lower())).pk
def test_concept_access_changes_with_source(self): public_access = self.source1.public_access concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, public_access=public_access, concept_class='First', names=[self.name], ) concept.full_clean() concept.save() self.assertEquals(self.source1.public_access, concept.public_access) self.source1.public_access = ACCESS_TYPE_VIEW self.source1.save() concept = Concept.objects.get(id=concept.id) self.assertNotEquals(public_access, self.source1.public_access) self.assertEquals(self.source1.public_access, concept.public_access)
def update_concept_retired_status(self, concept, new_retired_state): """ Updates and persists a new retired status for a concept """ # Do nothing if retired status is unchanged concept_version = ConceptVersion.get_latest_version_of(concept) if concept_version.retired == new_retired_state: return ImportActionHelper.IMPORT_ACTION_NONE # Retire/un-retire the concept if new_retired_state: if not self.test_mode: errors = Concept.retire(concept, self.user) if errors: raise IllegalInputException('Failed to retire concept due to %s' % errors) return ImportActionHelper.IMPORT_ACTION_RETIRE else: if not self.test_mode: errors = Concept.unretire(concept, self.user) if errors: raise IllegalInputException('Failed to un-retire concept due to %s' % errors) return ImportActionHelper.IMPORT_ACTION_UNRETIRE
def setUp(self): super(ConceptVersionTest, self).setUp() self.concept1 = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', external_id='EXTID', names=[self.name], ) display_name = LocalizedText(name='concept1', locale='en') self.concept1.names.append(display_name) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept1, self.user1, **kwargs) self.concept2 = Concept( mnemonic='concept2', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='Second', names=[self.name], ) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept2, self.user1, **kwargs)
def test_concept_display_name(self): concept = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) display_name = LocalizedText( name='concept1', locale='en', locale_preferred=True, ) concept.names.append(display_name) concept.full_clean() concept.save() self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists()) self.assertFalse(concept.retired) self.assertEquals(display_name.name, concept.display_name) self.assertEquals(display_name.locale, concept.display_locale) self.assertEquals(self.source1.owner_name, concept.owner_name) self.assertEquals(self.source1.owner_type, concept.owner_type) self.assertEquals(0, concept.num_versions)
def add_concept(request): new_con = Concept() new_con.title = request.POST['title'] new_con.description = request.POST['description'] new_con.pub_date = datetime.datetime.now() new_con.date_modified = new_con.pub_date new_con.id = bson.ObjectId() new_con.author = request.user cat_assoc = CategoryAssociation() cat = Category.objects.get(id=request.POST['category_id']) cat_assoc.category = cat new_con.categories.append(cat_assoc) form_properties = get_new_properties(request, True) for form_property in form_properties: #ugly upsert (in case its not in db) Feature.objects( title=form_property.title, is_property=True, property_type=form_property.property_type ).update_one( set__title=form_property.title, set__is_property=True, set__property_type=form_property.property_type, upsert=True) new_feature = Feature.objects.filter( title=form_property.title, is_property=True, property_type=form_property.property_type )[0] new_property = Property( feature=new_feature, property_id=bson.ObjectId(), value=form_property.value) new_con.properties.append(new_property) new_con.save() return HttpResponseRedirect(reverse('concepts:conceptdetail', args=(new_con.id,)))
def _remote_concept(uri, authority): """ Retrieve a Concept from a remote authority service. """ logging.debug("Retrieve remote concept for {0}.".format(uri)) querystring = authority.retrieveformat.format(uri) # "/Concept?id="+uri response = urllib2.urlopen(authority.host + querystring).read() root = ET.fromstring(response) data = {} if len(root) > 0: for node in root: if node.tag == '{' + authority.namespace + '/}conceptEntry': for sn in node: dkey = sn.tag.replace('{' + authority.namespace + '/}', '') data[dkey] = sn.text if sn.tag == '{' + authority.namespace + '/}type': data['type_id'] = sn.get('type_id') data['type_uri'] = sn.get('type_uri') if data == {}: # Nothing retrieved logging.warning("No such concept in ConceptAuthority for " +\ " namespace {0}".format(authority.namespace)) raise ValueError("No such concept in ConceptAuthority for " +\ " namespace {0}".format(authority.namespace)) # Get Concept type. ctype = ConceptType.objects.get_unique(data['type'], data['type_uri']) concept = Concept(uri=uri, name=data['lemma'], type=ctype, equalto=data['equal_to'], similarto=data['similar_to']) concept.save() logging.debug("Concept saved.") # Check for geonames URI in similar_to field, and get the corresponding # Location. if data['similar_to'] is not None: logging.debug("similar_to field is not empty.") try: location = retrieve_location(data['similar_to']) except RuntimeError: location = None if location is not None: logging.debug("Found a Location based on similar_to field") concept.location_id = location.id concept.save() else: logging.debug("No Location found.") return concept
def setUp(self): self.skipTest('Collections and concept references not yet supported.') super(ConceptReferenceBaseTest, self).setUp() self.concept1 = Concept( mnemonic='concept1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) display_name = LocalizedText( name='concept1', locale='en' ) self.concept1.names.append(display_name) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept1, self.user1, **kwargs) self.version1 = ConceptVersion.for_concept(self.concept1, 'version1') self.version1.save() self.concept2 = Concept( mnemonic='concept2', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='Second', names=[self.name], ) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept2, self.user1, **kwargs) self.version2 = ConceptVersion.for_concept(self.concept2, 'version2') self.version2.save()
def test_update_concept_with_invalid_record(self): concept = Concept(mnemonic='1', created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='Diagnosis', external_id='1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', names=[self.name]) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(concept, self.user1, **kwargs) self.testfile = open( './integration_tests/fixtures/concept_without_fully_specified_name.json', 'rb') stderr_stub = TestStream() importer = ConceptsImporter(self.source1, self.testfile, 'test', TestStream(), stderr_stub) importer.import_concepts(total=1) self.assertTrue('Concept requires at least one fully specified name' in stderr_stub.getvalue()) self.assertEquals(1, Concept.objects.count()) self.assertEquals(1, ConceptVersion.objects.count())
def update_concept_retired_status(self, concept, new_retired_state): """ Updates and persists a new retired status for a concept """ # Do nothing if retired status is unchanged concept_version = ConceptVersion.get_latest_version_of(concept) if concept_version.retired == new_retired_state: return ImportActionHelper.IMPORT_ACTION_NONE # Retire/un-retire the concept if new_retired_state: if not self.test_mode: errors = Concept.retire(concept, self.user) if errors: raise IllegalInputException( 'Failed to retire concept due to %s' % errors) return ImportActionHelper.IMPORT_ACTION_RETIRE else: if not self.test_mode: errors = Concept.unretire(concept, self.user) if errors: raise IllegalInputException( 'Failed to un-retire concept due to %s' % errors) return ImportActionHelper.IMPORT_ACTION_UNRETIRE
def test_create_concept_negative__no_mnemonic(self): with self.assertRaises(ValidationError): concept = Concept( created_by=self.user1, updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) concept.full_clean() concept.save()
def restore_object(self, attrs, instance=None): concept = instance if instance else Concept() concept.mnemonic = attrs.get(self.Meta.lookup_field, concept.mnemonic) concept.external_id = attrs.get('external_id', concept.external_id) concept.concept_class = attrs.get('concept_class', concept.concept_class) concept.datatype = attrs.get('datatype', concept.datatype) concept.extras = attrs.get('extras', concept.extras) concept.retired = attrs.get('retired', concept.retired) # Is this desired behavior?? concept.names = attrs.get('names', concept.names) # Is this desired behavior?? concept.descriptions = attrs.get('descriptions', concept.descriptions) concept.extras = attrs.get('extras', concept.extras) return concept
def _remote_concept(uri, authority): """ Retrieve a Concept from a remote authority service. """ logging.debug("Retrieve remote concept for {0}.".format(uri)) querystring = authority.retrieveformat.format(uri) # "/Concept?id="+uri response = urllib2.urlopen(authority.host+querystring).read() root = ET.fromstring(response) data = {} if len(root) > 0: for node in root: if node.tag == '{'+authority.namespace+'/}conceptEntry': for sn in node: dkey = sn.tag.replace('{'+authority.namespace+'/}','') data[dkey] = sn.text if sn.tag == '{'+authority.namespace+'/}type': data['type_id'] = sn.get('type_id') data['type_uri'] = sn.get('type_uri') if data == {}: # Nothing retrieved logging.warning("No such concept in ConceptAuthority for " +\ " namespace {0}".format(authority.namespace)) raise ValueError("No such concept in ConceptAuthority for " +\ " namespace {0}".format(authority.namespace)) # Get Concept type. ctype = ConceptType.objects.get_unique(data['type'], data['type_uri']) concept = Concept(uri=uri, name=data['lemma'], type=ctype, equalto=data['equal_to'], similarto=data['similar_to']) concept.save() logging.debug("Concept saved.") # Check for geonames URI in similar_to field, and get the corresponding # Location. if data['similar_to'] is not None: logging.debug("similar_to field is not empty.") try: location = retrieve_location(data['similar_to']) except RuntimeError: location = None if location is not None: logging.debug("Found a Location based on similar_to field") concept.location_id = location.id concept.save() else: logging.debug("No Location found.") return concept
def restore_object(self, attrs, instance=None): print 'ConceptDetailSerializer attrs: ', attrs concept = instance if instance else Concept() concept.mnemonic = attrs.get(self.Meta.lookup_field, concept.mnemonic) concept.external_id = attrs.get('external_id', concept.external_id) concept.concept_class = attrs.get('concept_class', concept.concept_class) concept.datatype = attrs.get('datatype', concept.datatype) concept.extras = attrs.get('extras', concept.extras) concept.retired = attrs.get('retired', concept.retired) concept.forked_from_url = attrs.get('forked_from_url', concept.forked_from_url) concept.forked_concept_version = attrs.get('version', concept.version) # Is this desired behavior?? concept.names = attrs.get('names', concept.names) # Is this desired behavior?? concept.descriptions = attrs.get('descriptions', concept.descriptions) concept.extras = attrs.get('extras', concept.extras) return concept
def test_get_method_failure(self, db): dictionary = dict(name="some-name") # TODO: Workaround with actual model. Remove this dependency object = Concept.get(dictionary) assert object is None
def create_concept(): concept = Concept(name='namestring', uri='uristring', type='E21 Person') concept.save() return concept
def save_object(self, obj, **kwargs): request_user = self.context['request'].user errors = Concept.persist_new(obj, request_user, **kwargs) self._errors.update(errors)
def test_collections_version_ids(self): kwargs = {'parent_resource': self.userprofile1} collection = Collection( name='collection2', mnemonic='collection2', full_name='Collection Two', collection_type='Dictionary', public_access=ACCESS_TYPE_EDIT, default_locale='en', supported_locales=['en'], website='www.collection2.com', description='This is the second test collection') Collection.persist_new(collection, self.user1, **kwargs) source = Source(name='source', mnemonic='source', full_name='Source One', source_type='Dictionary', public_access=ACCESS_TYPE_EDIT, default_locale='en', supported_locales=['en'], website='www.source1.com', description='This is the first test source') kwargs = {'parent_resource': self.org1} Source.persist_new(source, self.user1, **kwargs) concept1 = Concept( mnemonic='concept12', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(concept1, self.user1, **kwargs) fromConcept = Concept( mnemonic='fromConcept', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(fromConcept, self.user1, **kwargs) toConcept = Concept( mnemonic='toConcept', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(toConcept, self.user1, **kwargs) mapping = Mapping( map_type='Same As', from_concept=fromConcept, to_concept=toConcept, external_id='mapping', ) kwargs = { 'parent_resource': source, } Mapping.persist_new(mapping, self.user1, **kwargs) from_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get( mnemonic=fromConcept.mnemonic).mnemonic + '/' concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get( mnemonic=concept1.mnemonic).mnemonic + '/' mapping = Mapping.objects.filter()[1] mapping_reference = '/orgs/org1/sources/source/mappings/' + mapping.id + '/' references = [ concept1_reference, from_concept_reference, mapping_reference ] collection.expressions = references collection.full_clean() collection.save() self.assertEquals(mapping.collection_version_ids, [ Collection.objects.get(mnemonic=collection.mnemonic).get_head().id ])
def test_index_all_method_with_one_concept(self, mocker, concept): mocker.patch("concepts.models.Concept.index") Concept.index_all() Concept.index.assert_called_once()
class ConceptVersionStaticMethodsTest(ConceptBaseTest): def setUp(self): super(ConceptVersionStaticMethodsTest, self).setUp() self.concept1 = Concept(mnemonic='concept1', concept_class='First', public_access=ACCESS_TYPE_EDIT) display_name = LocalizedText(name='concept1', locale='en') self.concept1.names.append(display_name) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept1, self.user1, **kwargs) initial_version = ConceptVersion.get_latest_version_of(self.concept1) self.concept2 = Concept(mnemonic='concept2', concept_class='Second', names=[self.name]) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept2, self.user1, **kwargs) self.concept_version = ConceptVersion( mnemonic='version1', versioned_object=self.concept1, concept_class='First', names=self.concept1.names, previous_version=initial_version, created_by=self.user1.username, updated_by=self.user1.username, version_created_by=self.user1.username, ) self.concept_version.full_clean() self.concept_version.save() def test_for_concept_positive(self): self.concept1.datatype = 'Boolean' self.concept1.save() label = 'version1' version = ConceptVersion.for_concept(self.concept1, label) self.assertEquals(label, version.mnemonic) self.assertEquals(self.concept1, version.versioned_object) self.assertEquals(self.concept1.concept_class, version.concept_class) self.assertEquals(self.concept1.datatype, version.datatype) self.assertEquals(self.concept1.names, version.names) self.assertEquals(self.concept1.descriptions, version.descriptions) self.assertEquals(self.concept1.retired, version.retired) self.assertEquals(self.concept1.public_access, version.public_access) self.assertEquals(self.concept1.external_id, version.external_id) self.assertFalse(version.released) def test_persist_clone_positive(self): self.assertEquals(2, self.concept1.num_versions) self.assertEquals(self.concept_version, ConceptVersion.get_latest_version_of(self.concept1)) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.update_concept_version(self.concept_version) self.assertEquals(1, len(source_version.concepts)) self.assertEquals(self.concept_version.id, source_version.concepts[0]) version2 = self.concept_version.clone() errors = ConceptVersion.persist_clone(version2, self.user1) self.assertEquals(0, len(errors)) self.assertEquals(3, self.concept1.num_versions) self.assertEquals(version2, ConceptVersion.get_latest_version_of(self.concept1)) self.assertEquals(self.concept_version.public_access, version2.public_access) self.assertEquals(self.concept_version, version2.previous_version) self.assertEquals(self.concept_version.root_version, version2.root_version) self.assertEquals(self.concept_version.external_id, version2.external_id) self.assertEquals(self.user1.username, version2.version_created_by) source_version.update_concept_version(version2) self.assertEquals(1, len(source_version.concepts)) self.assertEquals(version2.id, source_version.concepts[0]) def test_persist_clone_negative__no_user(self): self.assertEquals(2, self.concept1.num_versions) self.assertEquals(self.concept_version, ConceptVersion.get_latest_version_of(self.concept1)) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.update_concept_version(self.concept_version) self.assertEquals(1, len(source_version.concepts)) self.assertEquals(self.concept_version.id, source_version.concepts[0]) version2 = self.concept_version.clone() errors = ConceptVersion.persist_clone(version2) self.assertEquals(1, len(errors)) self.assertTrue('version_created_by' in errors) self.assertEquals(2, self.concept1.num_versions) self.assertEquals(self.concept_version, ConceptVersion.get_latest_version_of(self.concept1))
def retrieve_concept(uri): # Determine namespace and find matching ConceptAuthority. o = urlparse(uri) namespace = o.scheme + "://" + o.netloc if o.scheme == '' or o.netloc == '': logging.error("Could not determine namespace for concept {0}".format(uri)) raise ValueError("Could not determine namespace for concept {0}".format(uri)) try: authority = ConceptAuthority.objects.filter(namespace=namespace).get() except ObjectDoesNotExist: logging.error("No ConceptAuthority for namespace {0}.".format(namespace)) raise RuntimeError("No ConceptAuthority for namespace {0}.".format(namespace)) # Check for existing concept before calling the authority. try: concept = Concept.objects.filter(uri=uri).get() logging.debug("Concept already exists.") except ObjectDoesNotExist: logging.debug("Concept does not exist.") querystring = authority.retrieveformat.format(uri) # "/Concept?id="+uri response = urllib2.urlopen(authority.host+querystring).read() root = ET.fromstring(response) data = {} if len(root) > 0: for node in root: if node.tag == '{'+authority.namespace+'/}conceptEntry': for sn in node: dkey = sn.tag.replace('{'+authority.namespace+'/}','') data[dkey] = sn.text if sn.tag == '{'+authority.namespace+'/}type': data['type_id'] = sn.get('type_id') data['type_uri'] = sn.get('type_uri') if data == {}: # Nothing retrieved logging.warning("No such concept in ConceptAuthority for " +\ " namespace {0}".format(authority.namespace)) raise ValueError("No such concept in ConceptAuthority for " +\ " namespace {0}".format(authority.namespace)) concept = Concept(uri=uri, name=data['lemma'], type=data['type'], equalto=data['equal_to'], similarto=data['similar_to']) concept.save() logging.debug("Concept saved.") # Check for geonames URI in similar_to field, and get the corresponding # Location. if data['similar_to'] is not None: logging.debug("similar_to field is not empty.") location = retrieve_location(data['similar_to']) if location is not None: logging.debug("Found a Location based on similar_to field") concept.location_id = location.id else: logging.debug("No Location found.") return concept
class ConceptVersionStaticMethodsTest(ConceptBaseTest): def setUp(self): super(ConceptVersionStaticMethodsTest, self).setUp() self.concept1 = Concept( mnemonic='concept1', concept_class='First', public_access=ACCESS_TYPE_EDIT) display_name = LocalizedText(name='concept1', locale='en') self.concept1.names.append(display_name) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept1, self.user1, **kwargs) initial_version = ConceptVersion.get_latest_version_of(self.concept1) self.concept2 = Concept(mnemonic='concept2', concept_class='Second', names=[self.name]) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept2, self.user1, **kwargs) self.concept_version = ConceptVersion( mnemonic='version1', versioned_object=self.concept1, concept_class='First', names=self.concept1.names, previous_version=initial_version, created_by=self.user1.username, updated_by=self.user1.username, version_created_by=self.user1.username, ) self.concept_version.full_clean() self.concept_version.save() def test_for_concept_positive(self): self.concept1.datatype = 'Boolean' self.concept1.save() label = 'version1' version = ConceptVersion.for_concept(self.concept1, label) self.assertEquals(label, version.mnemonic) self.assertEquals(self.concept1, version.versioned_object) self.assertEquals(self.concept1.concept_class, version.concept_class) self.assertEquals(self.concept1.datatype, version.datatype) self.assertEquals(self.concept1.names, version.names) self.assertEquals(self.concept1.descriptions, version.descriptions) self.assertEquals(self.concept1.retired, version.retired) self.assertEquals(self.concept1.public_access, version.public_access) self.assertEquals(self.concept1.external_id, version.external_id) self.assertFalse(version.released) def test_persist_clone_positive(self): self.assertEquals(2, self.concept1.num_versions) self.assertEquals( self.concept_version, ConceptVersion.get_latest_version_of(self.concept1)) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.update_concept_version(self.concept_version) self.assertEquals(1, len(source_version.concepts)) self.assertEquals(self.concept_version.id, source_version.concepts[0]) version2 = self.concept_version.clone() errors = ConceptVersion.persist_clone(version2, self.user1) self.assertEquals(0, len(errors)) self.assertEquals(3, self.concept1.num_versions) self.assertEquals(version2, ConceptVersion.get_latest_version_of(self.concept1)) self.assertEquals(self.concept_version.public_access, version2.public_access) self.assertEquals(self.concept_version, version2.previous_version) self.assertEquals(self.concept_version.root_version, version2.root_version) self.assertEquals(self.concept_version.external_id, version2.external_id) self.assertEquals(self.user1.username, version2.version_created_by) source_version.update_concept_version(version2) self.assertEquals(1, len(source_version.concepts)) self.assertEquals(version2.id, source_version.concepts[0]) def test_persist_clone_negative__no_user(self): self.assertEquals(2, self.concept1.num_versions) self.assertEquals( self.concept_version, ConceptVersion.get_latest_version_of(self.concept1)) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.update_concept_version(self.concept_version) self.assertEquals(1, len(source_version.concepts)) self.assertEquals(self.concept_version.id, source_version.concepts[0]) version2 = self.concept_version.clone() errors = ConceptVersion.persist_clone(version2) self.assertEquals(1, len(errors)) self.assertTrue('version_created_by' in errors) self.assertEquals(2, self.concept1.num_versions) self.assertEquals( self.concept_version, ConceptVersion.get_latest_version_of(self.concept1))
def setUp(self): self.user1 = User.objects.create_user( username='******', email='*****@*****.**', password='******', last_name='One', first_name='User' ) self.user2 = User.objects.create_user( username='******', email='*****@*****.**', password='******', last_name='Two', first_name='User' ) self.userprofile1 = UserProfile.objects.create(user=self.user1, mnemonic='user1') self.userprofile2 = UserProfile.objects.create(user=self.user2, mnemonic='user2') self.org1 = Organization.objects.create(name='org1', mnemonic='org1') self.org2 = Organization.objects.create(name='org2', mnemonic='org2') add_user_to_org(self.userprofile2, self.org2) self.source1 = Source( name='source1', mnemonic='source1', full_name='Source One', source_type='Dictionary', public_access=ACCESS_TYPE_EDIT, default_locale='en', supported_locales=['en'], website='www.source1.com', description='This is the first test source', ) kwargs = { 'parent_resource': self.userprofile1 } Source.persist_new(self.source1, self.user1, **kwargs) self.source1 = Source.objects.get(id=self.source1.id) self.source2 = Source( name='source2', mnemonic='source2', full_name='Source Two', source_type='Reference', public_access=ACCESS_TYPE_VIEW, default_locale='fr', supported_locales=['fr'], website='www.source2.com', description='This is the second test source', ) kwargs = { 'parent_resource': self.org2, } Source.persist_new(self.source2, self.user1, **kwargs) self.source2 = Source.objects.get(id=self.source2.id) self.name = LocalizedText.objects.create(name='Fred', locale='en', type='FULLY_SPECIFIED') self.concept1 = Concept( mnemonic='concept1', updated_by=self.user1, parent=self.source1, concept_class='First', names=[self.name], ) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept1, self.user1, **kwargs) self.concept2 = Concept( mnemonic='concept2', updated_by=self.user1, parent=self.source1, concept_class='Second', names=[self.name], ) kwargs = { 'parent_resource': self.source1, } Concept.persist_new(self.concept2, self.user1, **kwargs) self.concept3 = Concept( mnemonic='concept3', updated_by=self.user1, parent=self.source2, concept_class='Third', names=[self.name], ) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept3, self.user1, **kwargs) self.concept4 = Concept( mnemonic='concept4', updated_by=self.user2, parent=self.source2, concept_class='Fourth', names=[self.name], ) kwargs = { 'parent_resource': self.source2, } Concept.persist_new(self.concept4, self.user1, **kwargs)
def test_index_all_method_with_no_concepts(self, db): Concept.index_all()
def test_collections_version_ids(self): kwargs = { 'parent_resource': self.userprofile1 } collection = Collection( name='collection2', mnemonic='collection2', full_name='Collection Two', collection_type='Dictionary', public_access=ACCESS_TYPE_EDIT, default_locale='en', supported_locales=['en'], website='www.collection2.com', description='This is the second test collection' ) Collection.persist_new(collection, self.user1, **kwargs) source = Source( name='source', mnemonic='source', full_name='Source One', source_type='Dictionary', public_access=ACCESS_TYPE_EDIT, default_locale='en', supported_locales=['en'], website='www.source1.com', description='This is the first test source' ) kwargs = { 'parent_resource': self.org1 } Source.persist_new(source, self.user1, **kwargs) concept1 = Concept( mnemonic='concept12', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es', type='FULLY_SPECIFIED')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(concept1, self.user1, **kwargs) fromConcept = Concept( mnemonic='fromConcept', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es', type='FULLY_SPECIFIED')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(fromConcept, self.user1, **kwargs) toConcept = Concept( mnemonic='toConcept', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es', type='FULLY_SPECIFIED')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(toConcept, self.user1, **kwargs) mapping = Mapping( map_type='Same As', from_concept=fromConcept, to_concept=toConcept, external_id='mapping', ) kwargs = { 'parent_resource': source, } Mapping.persist_new(mapping, self.user1, **kwargs) mapping = Mapping.objects.filter()[1] mapping_reference = '/orgs/org1/sources/source/mappings/' + mapping.id + '/' references = [mapping_reference] collection.expressions = references collection.full_clean() collection.save() mapping_version = MappingVersion.objects.filter()[0] collection_version = CollectionVersion( name='version1', mnemonic='version1', versioned_object=collection, released=True, created_by=self.user1, updated_by=self.user1, mappings=[mapping_version.id] ) collection_version.full_clean() collection_version.save() self.assertEquals(mapping_version.collection_version_ids, [collection_version.id])
def test_collections_version_ids(self): kwargs = {'parent_resource': self.userprofile1} collection = Collection( name='collection2', mnemonic='collection2', full_name='Collection Two', collection_type='Dictionary', public_access=ACCESS_TYPE_EDIT, default_locale='en', supported_locales=['en'], website='www.collection2.com', description='This is the second test collection') Collection.persist_new(collection, self.user1, **kwargs) source = Source(name='source', mnemonic='source', full_name='Source One', source_type='Dictionary', public_access=ACCESS_TYPE_EDIT, default_locale='en', supported_locales=['en'], website='www.source1.com', description='This is the first test source') kwargs = {'parent_resource': self.org1} Source.persist_new(source, self.user1, **kwargs) concept1 = Concept( mnemonic='concept12', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(concept1, self.user1, **kwargs) another_concept = Concept( mnemonic='anotherConcept', created_by=self.user1, updated_by=self.user1, parent=source, concept_class='First', names=[LocalizedText.objects.create(name='User', locale='es')], ) kwargs = { 'parent_resource': source, } Concept.persist_new(another_concept, self.user1, **kwargs) another_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get( mnemonic=another_concept.mnemonic).mnemonic + '/' concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get( mnemonic=concept1.mnemonic).mnemonic + '/' references = [concept1_reference, another_concept_reference] collection.expressions = references collection.full_clean() collection.save() concept_version = ConceptVersion.objects.get( versioned_object_id=Concept.objects.get( mnemonic=another_concept.mnemonic).id) version = CollectionVersion.for_base_object(collection, 'version1') kwargs = {} CollectionVersion.persist_new(version, **kwargs) self.assertEquals( concept_version.collection_version_ids, [CollectionVersion.objects.get(mnemonic='version1').id])
def create_concept(): concept = Concept( name = 'namestring', uri = 'uristring', type = 'E21 Person' ) concept.save() return concept