def test_import_job_for_change_in_data(self):
stdout_stub = TestStream()
stderr_stub = TestStream()
mapping = Mapping(
parent=self.source1,
map_type="SAME-AS",
from_concept=self.concept3,
to_source=self.source1,
to_concept_code="413532003",
external_id="junk",
)
kwargs = {"parent_resource": self.source1}
Mapping.persist_new(mapping, self.user1, **kwargs)
source_version = SourceVersion.get_latest_version_of(self.source1)
source_version.mappings = [mapping.id]
source_version.save()
importer = MappingsImporter(self.source1, self.testfile, stdout_stub, stderr_stub, "test")
importer.import_mappings(total=1)
self.assertTrue("**** Processed 1 out of 1 mappings - 1 updated, ****" in stdout_stub.getvalue())
self.assertTrue(("Updated mapping with ID " + mapping.id) in stdout_stub.getvalue())
updated_mapping = Mapping.objects.get(to_concept_code="413532003")
self.assertTrue(updated_mapping.retired)
self.assertEquals(updated_mapping.external_id, "70279ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBB")
def test_persist_persist_changes_negative__no_updated_by(self):
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.mappings))
kwargs = {
'parent_resource': self.source1,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
mapping = Mapping.objects.get(external_id='mapping1')
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.mappings))
self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
mapping.to_concept = self.concept3
errors = Mapping.persist_changes(mapping, None)
self.assertEquals(1, len(errors))
self.assertTrue('updated_by' in errors)
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.mappings))
self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
def test_persist_persist_changes_positive(self):
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.mappings))
kwargs = {
'parent_resource': self.source1,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
mapping = Mapping.objects.get(external_id='mapping1')
to_concept = mapping.to_concept
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.mappings))
self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
mapping.to_concept = self.concept3
errors = Mapping.persist_changes(mapping, self.user1)
self.assertEquals(0, len(errors))
mapping = Mapping.objects.get(external_id='mapping1')
self.assertEquals(self.concept3, mapping.to_concept)
self.assertNotEquals(to_concept, mapping.to_concept)
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.mappings))
mv = MappingVersion.objects.filter(versioned_object_id=mapping.id)
self.assertTrue(mv[1].id in source_version.mappings)
def test_import_job_for_change_in_data(self):
stdout_stub = TestStream()
stderr_stub = TestStream()
mapping = Mapping(
parent=self.source1,
map_type='SAME-AS',
from_concept=self.concept3,
to_source=self.source1,
to_concept_code='413532003',
external_id='junk'
)
kwargs = {
'parent_resource': self.source1,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
source_version = SourceVersion.get_latest_version_of(self.source1)
source_version.mappings = [mapping.id]
source_version.save()
importer = MappingsImporter(self.source1, self.testfile, stdout_stub, stderr_stub, 'test')
importer.import_mappings(total=1)
self.assertTrue('mappings of 1 1 - 1 updated' in stdout_stub.getvalue())
self.assertTrue(('Updated mapping with ID ' + mapping.id) in stdout_stub.getvalue())
updated_mapping = Mapping.objects.get(to_concept_code='413532003')
self.assertTrue(updated_mapping.retired)
self.assertEquals(updated_mapping.external_id, '70279ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBB')
def test_edit_mapping_make_new_version_positive(self):
mapping1 = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.mappings))
kwargs = {
'parent_resource': self.source1,
}
errors = Mapping.persist_new(mapping1, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertEquals(1,len(MappingVersion.objects.filter(versioned_object_id=mapping1.id)))
mapping1.map_type='BROADER_THAN'
Mapping.persist_changes(mapping1, self.user1)
self.assertEquals(2, len(MappingVersion.objects.filter(versioned_object_id=mapping1.id)))
old_version = MappingVersion.objects.get(versioned_object_id=mapping1.id, is_latest_version=False)
new_version= MappingVersion.objects.get(versioned_object_id=mapping1.id, is_latest_version=True)
self.assertFalse(old_version.is_latest_version)
self.assertTrue(new_version.is_latest_version)
self.assertEquals(new_version.map_type,'BROADER_THAN')
self.assertEquals(old_version.map_type,'Same As')
def save_object(self, obj, **kwargs):
request_user = self.context['request'].user
if 'update_comment' in kwargs:
errors = Mapping.persist_changes(obj, request_user, update_comment = kwargs.get('update_comment'))
else :
errors = Mapping.persist_changes(obj, request_user)
self._errors.update(errors)
def test_persist_new_positive__earlier_source_version(self):
version1 = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(version1.mappings))
version2 = SourceVersion.for_base_object(self.source1, label='version2')
version2.save()
self.assertEquals(0, len(version2.mappings))
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.mappings))
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
kwargs = {
'parent_resource': self.source1,
'parent_resource_version': version1,
}
errors = Mapping.persist_new(mapping, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Mapping.objects.filter(external_id='mapping1').exists())
mapping = Mapping.objects.get(external_id='mapping1')
version1 = SourceVersion.objects.get(id=version1.id)
self.assertEquals(1, len(version1.mappings))
self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in version1.mappings)
version2 = SourceVersion.objects.get(id=version2.id)
self.assertEquals(0, len(version2.mappings))
latest_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(latest_version.mappings))
def create_mapping(user, source, from_concept, to_concept, map_type="Same As"):
mapping = Mapping(
created_by=user,
updated_by=user,
parent=source,
map_type=map_type,
from_concept=from_concept,
to_concept=to_concept,
public_access=ACCESS_TYPE_VIEW,
)
kwargs = {"parent_resource": source}
Mapping.persist_new(mapping, user, **kwargs)
return Mapping.objects.get(id=mapping.id)
def update_mapping(self, mapping, data):
""" Update an existing mapping """
# Generate the diff
diffs = {}
if 'retired' in data and mapping.retired != data['retired']:
diffs['retired'] = {'was': mapping.retired, 'is': data['retired']}
original = mapping.clone(self.user)
serializer = MappingUpdateSerializer(
mapping, data=data, context={'request': MockRequest(self.user)})
if not serializer.is_valid():
raise IllegalInputException(
'Could not parse mapping to update mapping %s due to %s.' %
(mapping.id, serializer.errors))
mapping = serializer.object
if 'retired' in diffs:
mapping.retired = data['retired']
diffs.update(Mapping.diff(original, mapping))
# Update concept if different
if diffs:
if not self.test_mode:
serializer.save()
if not serializer.is_valid():
raise IllegalInputException(
'Could not persist update to mapping %s due to %s' %
(mapping.id, serializer.errors))
return ImportActionHelper.IMPORT_ACTION_UPDATE
# No diff, so do nothing
return ImportActionHelper.IMPORT_ACTION_NONE
def test_persist_new_positive(self):
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.mappings))
kwargs = {
'parent_resource': self.source1,
}
errors = Mapping.persist_new(mapping, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Mapping.objects.filter(external_id='mapping1').exists())
mapping = Mapping.objects.get(external_id='mapping1')
self.assertEquals(self.source1.public_access, mapping.public_access)
self.assertEquals('user1', mapping.created_by)
self.assertEquals('user1', mapping.updated_by)
self.assertEquals(self.source1, mapping.parent)
self.assertEquals('Same As', mapping.map_type)
self.assertEquals(self.concept1, mapping.from_concept)
self.assertEquals(self.concept2, mapping.to_concept)
self.assertEquals(self.source1, mapping.from_source)
self.assertEquals(self.source1.owner_name, mapping.from_source_owner)
self.assertEquals(self.source1.mnemonic, mapping.from_source_name)
self.assertEquals(self.source1, mapping.get_to_source())
self.assertEquals(self.source1.owner_name, mapping.to_source_owner)
self.assertEquals(self.concept2.mnemonic, mapping.get_to_concept_code())
self.assertEquals(self.concept2.display_name, mapping.get_to_concept_name())
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.mappings))
self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
def test_update_mapping_with_invalid_record(self):
mapping = Mapping(parent=self.source1, map_type="SAME-AS", from_concept=self.concept3, to_concept=self.concept1)
kwargs = {"parent_resource": self.source1}
Mapping.persist_new(mapping, self.user1, **kwargs)
source_version = SourceVersion.get_latest_version_of(self.source1)
source_version.mappings = [mapping.id]
source_version.save()
stderr_stub = TestStream()
invalid_json_file = open("./integration_tests/fixtures/one_internal_invalid_mapping.json", "rb")
importer = MappingsImporter(self.source1, invalid_json_file, TestStream(), stderr_stub, "test")
importer.import_mappings(total=1)
self.assertTrue(
"Must specify either 'to_concept' or 'to_source' & 'to_concept_code'. Cannot specify both."
in stderr_stub.getvalue()
)
def test_persist_new_positive__same_mapping_different_source(self):
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.mappings))
kwargs = {
'parent_resource': self.source1,
}
errors = Mapping.persist_new(mapping, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Mapping.objects.filter(external_id='mapping1').exists())
mapping = Mapping.objects.get(external_id='mapping1')
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.mappings))
self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
# Repeat with same concepts
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping2',
)
kwargs = {
'parent_resource': self.source2,
}
source_version = SourceVersion.get_latest_version_of(self.source2)
self.assertEquals(0, len(source_version.mappings))
errors = Mapping.persist_new(mapping, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Mapping.objects.filter(external_id='mapping2').exists())
mapping = Mapping.objects.get(external_id='mapping2')
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.mappings))
self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
def test_retire_negative(self):
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
retired=True,
)
kwargs = {
'parent_resource': self.source1,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
mapping = Mapping.objects.get(external_id='mapping1')
self.assertTrue(mapping.retired)
result=Mapping.retire(mapping, self.user1)
self.assertFalse(result)
mapping = Mapping.objects.get(external_id='mapping1')
self.assertTrue(mapping.retired)
def test_retire_positive(self):
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
kwargs = {
'parent_resource': self.source1,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
mapping = Mapping.objects.get(external_id='mapping1')
self.assertFalse(mapping.retired)
Mapping.retire(mapping, self.user1)
self.assertTrue(mapping.retired)
mapping = Mapping.objects.get(external_id='mapping1')
self.assertTrue(mapping.retired)
mappingVersion=MappingVersion.objects.get(versioned_object_id=mapping.mnemonic, mnemonic=2)
self.assertTrue(mappingVersion.retired)
def test_persist_new_negative__same_mapping(self):
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.mappings))
kwargs = {
'parent_resource': self.source1,
}
errors = Mapping.persist_new(mapping, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Mapping.objects.filter(external_id='mapping1').exists())
mapping = Mapping.objects.get(external_id='mapping1')
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.mappings))
mv = MappingVersion.objects.get(versioned_object_id=mapping.id)
self.assertTrue(mv.id in source_version.mappings)
# Repeat with same concepts
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping2',
)
kwargs = {
'parent_resource': self.source1,
}
errors = Mapping.persist_new(mapping, self.user1, **kwargs)
self.assertEquals(1, len(errors))
self.assertEquals(1, len(errors))
self.assertTrue('__all__' in errors)
non_field_errors = errors['__all__']
self.assertEquals(1, len(non_field_errors))
self.assertTrue('already exists' in non_field_errors[0])
self.assertEquals(1, len(source_version.mappings))
def add_mapping(self, data):
""" Create a new mapping """
# Create the new mapping
mapping = Mapping(**data)
kwargs = {'parent_resource': self.source}
if self.test_mode:
mapping.save=lambda x: None
errors = Mapping.persist_new(mapping, self.user, **kwargs)
if errors:
raise IllegalInputException(
'Could not persist new mapping due to %s' % errors)
return ImportActionHelper.IMPORT_ACTION_ADD
def destroy(self, request, *args, **kwargs):
self.permission_classes = (CanEditParentDictionary,)
mapping = self.get_object_or_none()
if mapping is None:
return Response(
{'non_field_errors': 'Could not find mapping to retire'},
status=status.HTTP_404_NOT_FOUND)
update_comment = None
if 'update_comment' in request.DATA:
update_comment = request.DATA.get('update_comment')
errors = Mapping.retire(mapping, request.user, update_comment=update_comment)
if errors:
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_204_NO_CONTENT)
def test_should_not_add_related_mapping_if_another_version_is_present_in_collection(self):
source, user = self.create_source_and_user_fixture(custom_validation_schema=None)
collection = create_collection(user)
(from_concept, errors) = create_concept(user=user, source=source, names=[
create_localized_text(name='Non Unique Name', locale_preferred=True, locale='en', type='None'),
create_localized_text(name='Any Name', locale='en', type='Fully Specified')
])
(to_concept, errors) = create_concept(user=user, source=source, names=[
create_localized_text(name='Any Name 2', locale='en', type='Fully Specified')
])
mapping = create_mapping(user, source, from_concept, to_concept)
mapping_first_version = MappingVersion.get_latest_version_of(mapping)
mapping.map_type = "new type"
errors = Mapping.persist_changes(mapping, updated_by=user, update_comment="--")
mapping_head_version = MappingVersion.get_latest_version_of(mapping)
data = json.dumps({
'data': {
'expressions': [mapping_first_version.url]
}
})
kwargs = {'user': user.username, 'collection': collection.name}
response = self.client.put(reverse('collection-references', kwargs=kwargs), data,
content_type='application/json')
data = json.dumps({
'data': {
'expressions': [from_concept.url]
}
})
kwargs = {'user': user.username, 'collection': collection.name}
response = self.client.put(reverse('collection-references', kwargs=kwargs), data,
content_type='application/json')
self.assertEquals(response.content, json.dumps([{
"message": HEAD_OF_CONCEPT_ADDED_TO_COLLECTION,
"added": True,
"expression": from_concept.get_latest_version.url}]))
def test_persist_new_negative__no_parent(self):
mapping = Mapping(
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.mappings))
kwargs = {}
errors = Mapping.persist_new(mapping, self.user1, **kwargs)
self.assertEquals(1, len(errors))
self.assertTrue('non_field_errors' in errors)
non_field_errors = errors['non_field_errors']
self.assertEquals(1, len(non_field_errors))
self.assertTrue('parent' in non_field_errors[0])
self.assertFalse(Mapping.objects.filter(external_id='mapping1').exists())
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(0, len(source_version.mappings))
def test_update_different_from_and_to_pairs_to_same_from_and_to_pairs_should_throw_validation_error(self):
user = create_user()
source1 = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
source2 = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
(concept1, _) = create_concept(user, source1)
(concept2, _) = create_concept(user, source2)
(concept3, _) = create_concept(user, source2)
create_mapping(user, source1, concept1, concept2, "Same As")
mapping = create_mapping(user, source1, concept2, concept3, "Same As")
mapping.from_concept = concept1
mapping.to_concept = concept2
mapping.map_type = "Different"
errors = Mapping.persist_changes(mapping, user)
self.assertTrue(
OPENMRS_SINGLE_MAPPING_BETWEEN_TWO_CONCEPTS in errors["__all__"])
def test_mapping_access_changes_with_source(self):
public_access = self.source1.public_access
mapping = Mapping(
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
public_access=public_access,
external_id='mapping1',
)
mapping.full_clean()
mapping.save()
self.assertEquals(self.source1.public_access, mapping.public_access)
self.source1.public_access = ACCESS_TYPE_VIEW
self.source1.save()
mapping = Mapping.objects.get(id=mapping.id)
self.assertNotEquals(public_access, self.source1.public_access)
self.assertEquals(self.source1.public_access, mapping.public_access)
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, errors) = create_concept(mnemonic='concept12', user=self.user1, source=source)
(from_concept, errors) = create_concept(mnemonic='fromConcept', user=self.user1, source=source)
(to_concept, errors) = create_concept(mnemonic='toConcept', user=self.user1, source=source)
mapping = Mapping(
map_type='Same As',
from_concept=from_concept,
to_concept=to_concept,
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_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, errors) = create_concept(mnemonic='concept12', user=self.user1, source=source)
(from_concept, errors) = create_concept(mnemonic='fromConcept', user=self.user1, source=source)
(to_concept, errors) = create_concept(mnemonic='toConcept', user=self.user1, source=source)
mapping = Mapping(
map_type='Same As',
from_concept=from_concept,
to_concept=to_concept,
external_id='mapping',
)
kwargs = {
'parent_resource': source,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
initial_mapping_version = MappingVersion.objects.get(versioned_object_id=mapping.id)
new_mapping_version = MappingVersion.for_mapping(mapping)
new_mapping_version.mnemonic = 98
new_mapping_version.save()
from_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(mnemonic=from_concept.mnemonic).mnemonic + '/'
concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(mnemonic=concept1.mnemonic).mnemonic + '/'
mapping = Mapping.objects.filter()[1]
references = [concept1_reference, from_concept_reference, mapping.uri, initial_mapping_version.uri]
collection.expressions = references
collection.full_clean()
collection.save()
self.assertEquals(initial_mapping_version.collection_ids, [collection.id])
self.assertEquals(new_mapping_version.collection_ids, [collection.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)
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_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 save_object(self, obj, **kwargs):
request_user = self.context['request'].user
errors = Mapping.persist_new(obj, request_user, **kwargs)
self._errors.update(errors)
def destroy(self, request, *args, **kwargs):
self.permission_classes = (CanEditParentDictionary,)
obj = self.get_object()
Mapping.retire(obj, self.user)
return Response(status=status.HTTP_204_NO_CONTENT)
def destroy(self, request, *args, **kwargs):
self.permission_classes = (CanEditParentDictionary, )
obj = self.get_object()
Mapping.retire(obj, self.user)
return Response(status=status.HTTP_204_NO_CONTENT)
