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)