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 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_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 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_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_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 test_source(self):
self.assertIsNone(Mapping().source)
self.assertEqual(Mapping(parent=Source(mnemonic='source')).source, 'source')
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 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 test_parent_source(self):
source = Source(mnemonic='source')
self.assertEqual(Mapping(parent=source).parent_source, source)
def test_mapping(self):
self.assertEqual(Mapping(mnemonic='foobar').mapping, 'foobar')