def get_queryset(self):
if self.queryset:
return self.queryset
from_concept_url = self.get('from_concept_url')
to_concept_url = self.get('to_concept_url')
to_concept_code = self.get('to_concept_code')
to_source_url = self.get('to_source_url')
filters = {
'parent__' + self.get_owner_type_filter(): self.get('owner'),
'parent__mnemonic': self.get('source'),
'id': F('versioned_object_id'),
'map_type': self.get('map_type'),
'from_concept__uri__icontains': drop_version(from_concept_url),
}
if to_concept_url:
filters['to_concept__uri__icontains'] = drop_version(
to_concept_url)
if to_concept_code and to_source_url:
filters['to_concept_code'] = to_concept_code
filters['to_source__uri__icontains'] = drop_version(to_source_url)
self.queryset = Mapping.objects.filter(**filters)
return self.queryset
def test_get_concepts(self):
reference = CollectionReference()
reference.expression = '/unknown/uri/'
unknown_expression_concepts = reference.get_concepts()
self.assertTrue(isinstance(unknown_expression_concepts, QuerySet))
self.assertFalse(unknown_expression_concepts.exists())
concept = ConceptFactory()
reference.expression = concept.uri
concepts = reference.get_concepts()
self.assertTrue(isinstance(concepts, QuerySet))
self.assertEqual(concepts.count(), 1)
self.assertEqual(concepts.first(), concept.get_latest_version())
ConceptFactory(parent=concept.parent,
version='v1',
mnemonic=concept.mnemonic,
versioned_object=concept)
reference.expression = drop_version(concept.uri) + 'versions/'
concepts = reference.get_concepts().order_by('created_at')
self.assertTrue(isinstance(concepts, QuerySet))
self.assertEqual(concepts.count(), 2)
self.assertListEqual(list(concepts.all()),
list(concept.versions.all()))
def process(self, collection_uri, expressions):
self.processed += 1
self.log("Processing: {} ({}/{})".format(collection_uri,
self.processed, self.total))
collection = Collection.objects.filter(uri=collection_uri).first()
saved_references = []
concepts = []
mappings = []
if collection:
for expression in expressions:
self.log("Processing Expression: {} ".format(expression))
__is_concept = is_concept(expression)
if __is_concept:
model = Concept
_instances = concepts
else:
model = Mapping
_instances = mappings
instance = model.objects.filter(uri=expression).first()
if self.drop_version_if_version_missing and not instance:
instance = model.objects.filter(
uri=drop_version(expression)).first()
if not instance:
self.not_found_references.append(expression)
continue
latest_version = instance.get_latest_version()
if not latest_version:
latest_version = model.create_initial_version(instance)
if __is_concept:
latest_version.cloned_names = [
name.clone() for name in instance.names.all()
]
latest_version.cloned_descriptions = [
desc.clone()
for desc in instance.descriptions.all()
]
latest_version.set_locales()
parent = instance.parent
latest_version.sources.set([parent, parent.head])
reference = CollectionReference(expression=latest_version.uri)
reference.save()
saved_references.append(reference)
_instances.append(latest_version)
self.created.append(expression)
collection.references.add(*saved_references)
if concepts:
collection.concepts.add(*concepts)
collection.batch_index(collection.concepts, ConceptDocument)
if mappings:
collection.mappings.add(*mappings)
collection.batch_index(collection.mappings, MappingDocument)
else:
self.not_found.append(collection_uri)
def get_cascaded_mapping_uris_from_concept_expressions(self, expressions):
mapping_uris = []
for expression in expressions:
if is_concept(expression):
mapping_uris += list(
self.mappings.filter(
from_concept__uri__icontains=drop_version(
expression)).values_list('uri', flat=True))
return mapping_uris
def get_all_related_mappings(self, expressions):
all_related_mappings = []
unversioned_mappings = concept_expressions = []
for expression in expressions:
if is_mapping(expression):
unversioned_mappings.append(drop_version(expression))
elif is_concept(expression):
concept_expressions.append(expression)
for concept_expression in concept_expressions:
ref = CollectionReference(expression=concept_expression)
try:
self.validate(ref)
all_related_mappings += ref.get_related_mappings(
unversioned_mappings)
except: # pylint: disable=bare-except
continue
return all_related_mappings
def create_new_versions_for_removed_parents(self, uris):
if uris:
concepts = Concept.objects.filter(uri__in=uris)
child_versioned_object_uri = drop_version(self.uri)
for concept in concepts:
current_latest_version = concept.get_latest_version()
Concept.create_new_version_for(
concept.clone(),
dict(
names=[name.to_dict() for name in concept.names.all()],
descriptions=[desc.to_dict() for desc in concept.descriptions.all()],
parent_concept_urls=concept.parent_concept_urls
),
concept.created_by,
create_parent_version=False
)
new_latest_version = concept.get_latest_version()
for uri in current_latest_version.child_concept_urls:
if uri != child_versioned_object_uri:
child = Concept.objects.filter(uri__contains=uri, is_latest_version=True).first()
child.parent_concepts.add(new_latest_version)
def without_version(self):
return drop_version(self.expression)
def add_references_in_bulk(self, expressions, user=None): # pylint: disable=too-many-locals # Fixme: Sny
errors = {}
collection_version = self.head
new_expressions = set(expressions)
new_versionless_expressions = {
drop_version(expression): expression
for expression in new_expressions
}
for reference in collection_version.references.all():
existing_versionless_expression = reference.without_version
if existing_versionless_expression in new_versionless_expressions:
existing_expression = new_versionless_expressions[
existing_versionless_expression]
new_expressions.discard(existing_expression)
errors[existing_expression] = [REFERENCE_ALREADY_EXISTS]
added_references = list()
for expression in new_expressions:
ref = CollectionReference(expression=expression)
try:
ref.clean()
ref.save()
except Exception as ex:
errors[expression] = ex.messages if hasattr(ex,
'messages') else ex
continue
added = False
if ref.concepts:
for concept in ref.concepts:
if self.custom_validation_schema == CUSTOM_VALIDATION_SCHEMA_OPENMRS:
try:
self.check_concept_uniqueness_in_collection_and_locale_by_name_attribute(
concept,
attribute='type__in',
value=LOCALES_FULLY_SPECIFIED,
error_message=
CONCEPT_FULLY_SPECIFIED_NAME_UNIQUE_PER_COLLECTION_AND_LOCALE
)
self.check_concept_uniqueness_in_collection_and_locale_by_name_attribute(
concept,
attribute='locale_preferred',
value=True,
error_message=
CONCEPT_PREFERRED_NAME_UNIQUE_PER_COLLECTION_AND_LOCALE
)
except Exception as ex:
errors[expression] = ex.messages if hasattr(
ex, 'messages') else ex
continue
collection_version.add_concept(concept)
added = True
if ref.mappings:
for mapping in ref.mappings:
collection_version.add_mapping(mapping)
added = True
if added:
collection_version.references.add(ref)
self.references.add(ref)
added_references.append(ref)
if user and user.is_authenticated:
collection_version.updated_by = user
self.updated_by = user
collection_version.save()
self.save()
return added_references, errors
def versioned_object_url(self):
return drop_version(self.uri)
def test_drop_version(self):
self.assertEqual(drop_version(None), None)
self.assertEqual(drop_version(''), '')
self.assertEqual(drop_version('/foo/bar'), '/foo/bar')
self.assertEqual(drop_version('/users/username/'), '/users/username/')
# user-source-concept
self.assertEqual(
drop_version("/users/user/sources/source/concepts/concept/"),
"/users/user/sources/source/concepts/concept/")
self.assertEqual(
drop_version(
"/users/user/sources/source/concepts/concept/version/"),
"/users/user/sources/source/concepts/concept/")
self.assertEqual(
drop_version("/users/user/sources/source/concepts/concept/1.23/"),
"/users/user/sources/source/concepts/concept/")
self.assertEqual(
drop_version(
"/users/user/sources/source/source-version/concepts/concept/1.23/"
), "/users/user/sources/source/source-version/concepts/concept/")
# org-source-concept
self.assertEqual(
drop_version("/orgs/org/sources/source/concepts/concept/"),
"/orgs/org/sources/source/concepts/concept/")
self.assertEqual(
drop_version("/orgs/org/sources/source/concepts/concept/version/"),
"/orgs/org/sources/source/concepts/concept/")
self.assertEqual(
drop_version("/orgs/org/sources/source/concepts/concept/1.24/"),
"/orgs/org/sources/source/concepts/concept/")
self.assertEqual(
drop_version(
"/orgs/org/sources/source/source-version/concepts/concept/1.24/"
), "/orgs/org/sources/source/source-version/concepts/concept/")
# user-collection-concept
self.assertEqual(
drop_version("/users/user/collections/coll/concepts/concept/"),
"/users/user/collections/coll/concepts/concept/")
self.assertEqual(
drop_version(
"/users/user/collections/coll/concepts/concept/version/"),
"/users/user/collections/coll/concepts/concept/")
self.assertEqual(
drop_version(
"/users/user/collections/coll/concepts/concept/1.23/"),
"/users/user/collections/coll/concepts/concept/")
self.assertEqual(
drop_version(
"/users/user/collections/coll/coll-version/concepts/concept/1.23/"
), "/users/user/collections/coll/coll-version/concepts/concept/")
# org-collection-concept
self.assertEqual(
drop_version("/orgs/org/collections/coll/concepts/concept/"),
"/orgs/org/collections/coll/concepts/concept/")
self.assertEqual(
drop_version(
"/orgs/org/collections/coll/concepts/concept/version/"),
"/orgs/org/collections/coll/concepts/concept/")
self.assertEqual(
drop_version("/orgs/org/collections/coll/concepts/concept/1.24/"),
"/orgs/org/collections/coll/concepts/concept/")
self.assertEqual(
drop_version(
"/orgs/org/collections/coll/coll-version/concepts/concept/1.24/"
), "/orgs/org/collections/coll/coll-version/concepts/concept/")
# user-source
self.assertEqual(drop_version("/users/user/sources/source/"),
"/users/user/sources/source/")
self.assertEqual(drop_version("/users/user/sources/source/1.2/"),
"/users/user/sources/source/")
# org-source
self.assertEqual(drop_version("/orgs/org/sources/source/"),
"/orgs/org/sources/source/")
self.assertEqual(drop_version("/orgs/org/sources/source/version/"),
"/orgs/org/sources/source/")
def __format_hierarchy_uris(uris):
return list({drop_version(uri) for uri in uris})
