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})