def test_owner(self):
org = Organization(id=123)
user = UserProfile(id=123)
self.assertIsNone(Mapping().owner)
self.assertEqual(Mapping(parent=Source(organization=org)).owner, org)
self.assertEqual(Mapping(parent=Source(user=user)).owner, user)
def test_owner_type(self):
org = Organization(id=123, mnemonic='org')
user = UserProfile(id=123, username='******')
self.assertIsNone(Mapping().owner_type)
self.assertEqual(Mapping(parent=Source(organization=org)).owner_type, 'Organization')
self.assertEqual(Mapping(parent=Source(user=user)).owner_type, 'User')
def process(self):
if self.version:
instance = self.get_queryset().first().clone()
errors = Mapping.create_new_version_for(instance, self.data,
self.user)
return errors or UPDATED
instance = Mapping.persist_new(self.data, self.user)
if instance.id:
return CREATED
return instance.errors or FAILED
def test_get_to_source(self):
mapping = Mapping()
self.assertIsNone(mapping.get_to_source())
source = Source(id=123)
mapping = Mapping(to_source=source)
self.assertEqual(mapping.get_to_source(), source)
concept = ConceptFactory()
mapping = Mapping(to_concept=concept)
self.assertEqual(mapping.get_to_source(), concept.parent)
def test_get_to_concept_name(self):
mapping = Mapping()
self.assertIsNone(mapping.get_to_concept_name())
mapping = Mapping(to_concept_name='to-concept-name')
self.assertEqual(mapping.get_to_concept_name(), 'to-concept-name')
concept = ConceptFactory(names=[LocalizedTextFactory()])
self.assertIsNotNone(concept.display_name)
mapping = Mapping(to_concept=concept)
self.assertEqual(mapping.get_to_concept_name(), concept.display_name)
def update(self, instance, validated_data):
errors = Mapping.create_new_version_for(
instance, validated_data,
self.context.get('request').user)
if errors:
self._errors.update(errors)
return instance
def update(self, instance, validated_data):
from core.concepts.models import Concept
from core.sources.models import Source
instance.extras = validated_data.get('extras', instance.extras)
instance.external_id = validated_data.get('external_id',
instance.external_id)
instance.comment = validated_data.get(
'update_comment') or validated_data.get('comment')
instance.retired = validated_data.get('retired', instance.retired)
from_concept_url = validated_data.get('from_concept_url', None)
to_concept_url = validated_data.get('to_concept_url', None)
to_source_url = validated_data.get('to_source_url', None)
if from_concept_url:
instance.from_concept = Concept.from_uri_queryset(
from_concept_url).first()
if to_concept_url:
instance.to_concept = Concept.from_uri_queryset(
to_concept_url).first()
if to_source_url:
instance.to_source = Source.head_from_uri(to_source_url).first()
instance.mnemonic = validated_data.get('mnemonic', instance.mnemonic)
instance.map_type = validated_data.get('map_type', instance.map_type)
instance.to_concept_code = validated_data.get('to_concept_code',
instance.to_concept_code)
instance.to_concept_name = validated_data.get('to_concept_name',
instance.to_concept_name)
errors = Mapping.persist_clone(instance,
self.context.get('request').user)
if errors:
self._errors.update(errors)
return instance
def test_from_source_owner_mnemonic(self):
from_concept = ConceptFactory(
parent=OrganizationSourceFactory(mnemonic='foobar',
organization=OrganizationFactory(
mnemonic='org-foo')))
mapping = Mapping(from_concept=from_concept)
self.assertEqual(mapping.from_source_owner_mnemonic, 'org-foo')
def test_to_source_shorthand(self):
to_concept = ConceptFactory(
parent=OrganizationSourceFactory(mnemonic='foobar',
organization=OrganizationFactory(
mnemonic='org-foo')))
mapping = Mapping(to_concept=to_concept)
self.assertEqual(mapping.to_source_shorthand, 'org-foo:foobar')
def test_from_concept_shorthand(self):
from_concept = ConceptFactory(
mnemonic='concept-foo',
parent=OrganizationSourceFactory(
mnemonic='source-foo',
organization=OrganizationFactory(mnemonic='org-foo')))
mapping = Mapping(from_concept=from_concept)
self.assertEqual(mapping.from_concept_shorthand,
'org-foo:source-foo:concept-foo')
def __get_children_from_expressions(expressions):
concepts = Concept.objects.none()
mappings = Mapping.objects.none()
for expression in expressions:
if is_concept(expression):
concepts |= Concept.from_uri_queryset(expression)
if is_mapping(expression):
mappings |= Mapping.from_uri_queryset(expression)
return concepts, mappings
def test_persist_clone(self):
source_head = OrganizationSourceFactory(version=HEAD)
source_version0 = OrganizationSourceFactory(
version='v0',
mnemonic=source_head.mnemonic,
organization=source_head.organization)
self.assertEqual(source_head.versions.count(), 2)
mapping = MappingFactory(parent=source_version0)
cloned_mapping = mapping.clone(mapping.created_by)
self.assertEqual(
Mapping.persist_clone(cloned_mapping),
dict(
version_created_by=
'Must specify which user is attempting to create a new mapping version.'
))
self.assertEqual(
Mapping.persist_clone(cloned_mapping, mapping.created_by), {})
persisted_mapping = Mapping.objects.filter(
id=cloned_mapping.id, version=cloned_mapping.version).first()
self.assertEqual(mapping.versions.count(), 2)
self.assertNotEqual(mapping.id, persisted_mapping.id)
self.assertEqual(persisted_mapping.from_concept_id,
mapping.from_concept_id)
self.assertEqual(persisted_mapping.to_concept_id,
mapping.to_concept_id)
self.assertEqual(persisted_mapping.parent, source_version0)
self.assertEqual(persisted_mapping.sources.count(), 2)
self.assertEqual(source_head.mappings.first().id, persisted_mapping.id)
self.assertEqual(
persisted_mapping.uri,
'/orgs/{}/sources/{}/{}/mappings/{}/{}/'.format(
source_version0.organization.mnemonic,
source_version0.mnemonic, source_version0.version,
persisted_mapping.mnemonic, persisted_mapping.version))
self.assertEqual(persisted_mapping.version_url, persisted_mapping.uri)
def get_object(self, queryset=None):
queryset = self.get_queryset(None)
filters = dict(id=F('versioned_object_id'))
if 'collection' in self.kwargs:
filters = dict(is_latest_version=True)
uri_param = self.request.query_params.dict().get('uri')
if uri_param:
filters.update(
Mapping.get_parent_and_owner_filters_from_uri(uri_param))
if queryset.count() > 1 and not uri_param:
raise Http409()
instance = queryset.filter(**filters).first()
if not instance:
raise Http404()
return instance
def test_persist_new(self):
source = SourceFactory(version=HEAD)
concept1 = ConceptFactory(parent=source)
concept2 = ConceptFactory(parent=source)
mapping = Mapping.persist_new({
**factory.build(dict, FACTORY_CLASS=MappingFactory), 'from_concept': concept1, 'to_concept': concept2,
'parent_id': source.id
}, source.created_by)
self.assertEqual(mapping.errors, {})
self.assertIsNotNone(mapping.id)
self.assertEqual(mapping.version, str(mapping.id))
self.assertEqual(source.mappings_set.count(), 1)
self.assertEqual(source.mappings.count(), 1)
self.assertEqual(
mapping.uri,
'/orgs/{}/sources/{}/mappings/{}/{}/'.format(
source.organization.mnemonic, source.mnemonic, mapping.mnemonic, mapping.id
)
)
def get_object(self, queryset=None):
queryset = self.get_queryset()
filters = dict(id=F('versioned_object_id'))
if 'collection' in self.kwargs:
filters = dict()
queryset = queryset.order_by('id').distinct('id')
uri_param = self.request.query_params.dict().get('uri')
if uri_param:
filters.update(
Mapping.get_parent_and_owner_filters_from_uri(uri_param))
if queryset.count() > 1 and not uri_param:
raise Http409()
instance = queryset.filter(**filters).first()
if not instance:
raise Http404()
self.check_object_permissions(self.request, instance)
return instance
def test_source(self):
self.assertIsNone(Mapping().source)
self.assertEqual(Mapping(parent=Source(mnemonic='source')).source, 'source')
def get_mappings(self):
return Mapping.from_uri_queryset(self.expression)
def get_queryset(self):
return Mapping.get_base_queryset(self.params)
def get_queryset(self):
return Mapping.global_listing_queryset(
self.get_filter_params(), self.request.user).select_related(
'parent__organization',
'parent__user',
)
def process_line(self, line): # pylint: disable=too-many-locals,too-many-statements
data = json.loads(line)
original_data = data.copy()
self.processed += 1
created_at = data.pop('created_at')
updated_at = data.pop('updated_at')
created_by = data.get('created_by')
updated_by = data.get('updated_by')
_id = data.pop('_id')
parent_id = get(data.pop('parent_id'), '$oid')
mnemonic = data.get('mnemonic')
to_source_id = get(data.pop('to_source_id'), '$oid')
to_concept_id = get(data.pop('to_concept_id'), '$oid')
from_concept_id = get(data.pop('from_concept_id'), '$oid')
from_concept = self.get_concept(from_concept_id)
if from_concept:
data['from_concept'] = from_concept
data['from_concept_code'] = get(
data, 'from_concept_code') or from_concept.mnemonic
data['from_source'] = from_concept.parent
if to_concept_id:
to_concept = self.get_concept(to_concept_id)
if to_concept:
data['to_concept'] = to_concept
data['to_concept_code'] = get(
data, 'to_concept_code') or to_concept.mnemonic
data['to_source'] = to_concept.parent
elif to_source_id:
to_source = self.get_source(to_source_id)
if to_source:
data['to_source'] = to_source
if get(data, 'from_concept', None) is None:
self.failed.append({
**original_data, 'errors': ['From concept not found']
})
data['internal_reference_id'] = get(_id, '$oid')
data['created_at'] = get(created_at, '$date')
data['updated_at'] = get(updated_at, '$date')
creator = self.get_user(created_by)
updater = self.get_user(updated_by)
if creator:
data['created_by'] = creator
if updater:
data['updated_by'] = updater
self.log("Processing: {} ({}/{})".format(mnemonic, self.processed,
self.total))
if Mapping.objects.filter(uri=data['uri']).exists():
self.existed.append(original_data)
else:
try:
source = self.get_source(parent_id)
mapping = Mapping(**data,
version=mnemonic,
is_latest_version=False,
parent=source)
mapping.full_clean()
mapping.save()
mapping.versioned_object_id = mapping.id
mapping.sources.add(source)
mapping.save()
self.created.append(original_data)
except Exception as ex:
self.log("Failed: {}".format(data['uri']))
args = get(ex, 'message_dict') or str(ex)
self.log(args)
self.log(str(data))
self.failed.append({**original_data, 'errors': args})
def create(self, validated_data):
mapping = Mapping.persist_new(data=validated_data,
user=self.context.get('request').user)
if mapping.errors:
self._errors.update(mapping.errors)
return mapping
def process_line(self, line): # pylint: disable=too-many-locals,too-many-statements
data = json.loads(line)
original_data = data.copy()
self.processed += 1
created_at = data.pop('created_at')
updated_at = data.pop('updated_at')
created_by = data.get('created_by', None) or data.pop(
'version_created_by', None) or 'ocladmin'
updated_by = data.get('updated_by') or created_by
source_version_ids = data.pop('source_version_ids', None) or None
for attr in [
'root_version_id', 'parent_version_id', 'previous_version_id',
'root_version_id', 'version_created_by',
'versioned_object_type_id'
]:
data.pop(attr, None)
data['comment'] = data.pop('update_comment', None)
_id = data.pop('_id')
versioned_object_id = data.pop('versioned_object_id')
versioned_object = self.get_mapping(versioned_object_id)
if not versioned_object:
self.failed.append({
**original_data, 'errors': ['versioned_object not found']
})
return
mnemonic = versioned_object.mnemonic
data['version'] = data.pop('mnemonic')
data['internal_reference_id'] = get(_id, '$oid')
data['created_at'] = get(created_at, '$date')
data['updated_at'] = get(updated_at, '$date')
from_concept_id = get(data.pop('from_concept_id'), '$oid')
to_concept_id = get(data.pop('to_concept_id'), '$oid')
to_source_id = get(data.pop('to_source_id'), '$oid')
from_concept = self.get_concept(from_concept_id)
to_concept = None
to_source = None
if to_concept_id:
to_concept = self.get_concept(to_concept_id)
if to_source_id:
to_source = self.get_source(to_source_id)
creator = self.get_user(created_by)
updater = self.get_user(updated_by)
if creator:
data['created_by'] = creator
if updater:
data['updated_by'] = updater
self.log("Processing: {} ({}/{})".format(mnemonic, self.processed,
self.total))
if Mapping.objects.filter(uri=data['uri']).exists():
self.existed.append(original_data)
else:
try:
source = versioned_object.parent
data.pop('parent_id', None)
mapping = Mapping(
**data,
mnemonic=mnemonic,
parent=source,
versioned_object_id=versioned_object.id,
)
mapping.to_concept_id = get(
to_concept, 'id') or versioned_object.to_concept_id
mapping.to_concept_code = data.get(
'to_concept_code') or versioned_object.to_concept_code
mapping.to_concept_name = data.get(
'to_concept_name') or versioned_object.to_concept_name
mapping.to_source_id = get(to_source, 'id') or get(
to_concept, 'parent_id') or versioned_object.to_source_id
mapping.from_concept_id = get(
from_concept, 'id') or versioned_object.from_concept_id
mapping.from_concept_code = get(
from_concept,
'mnemonic') or versioned_object.from_concept_code
mapping.from_source_id = get(
from_concept,
'parent_id') or versioned_object.from_source_id
mapping.save()
source_versions = [source]
if source_version_ids:
source_versions += list(
Source.objects.filter(
internal_reference_id__in=source_version_ids))
mapping.sources.set(source_versions)
mapping.save()
# other_versions = versioned_object.versions.exclude(id=mapping.id)
# if other_versions.exists():
# other_versions.update(is_latest_version=False)
self.created.append(original_data)
except Exception as ex:
self.log("Failed: {}".format(data['uri']))
args = get(ex, 'message_dict') or str(ex)
self.log(args)
self.failed.append({**original_data, 'errors': args})
def get_queryset(self, distinct_by='updated_at'): # pylint: disable=arguments-differ
return Mapping.get_base_queryset(self.params, distinct_by)
def test_mapping(self):
self.assertEqual(Mapping(mnemonic='foobar').mapping, 'foobar')
def test_parent_source(self):
source = Source(mnemonic='source')
self.assertEqual(Mapping(parent=source).parent_source, source)
