def persist_clone(cls, obj, user=None, create_parent_version=True, parent_concept_uris=None, **kwargs): # pylint: disable=too-many-statements errors = dict() if not user: errors['version_created_by'] = PERSIST_CLONE_SPECIFY_USER_ERROR return errors obj.created_by = user obj.updated_by = user obj.version = obj.version or generate_temp_version() parent = obj.parent parent_head = parent.head persisted = False versioned_object = obj.versioned_object prev_latest_version = versioned_object.versions.exclude(id=obj.id).filter(is_latest_version=True).first() try: with transaction.atomic(): cls.pause_indexing() obj.is_latest_version = True obj.save(**kwargs) if obj.id: obj.version = str(obj.id) obj.save() obj.set_locales() obj.clean() # clean here to validate locales that can only be saved after obj is saved obj.update_versioned_object() if prev_latest_version: prev_latest_version.is_latest_version = False prev_latest_version.save() obj.sources.set(compact([parent, parent_head])) persisted = True cls.resume_indexing() if get(settings, 'TEST_MODE', False): process_hierarchy_for_concept_version( obj.id, get(prev_latest_version, 'id'), parent_concept_uris, create_parent_version) else: process_hierarchy_for_concept_version.delay( obj.id, get(prev_latest_version, 'id'), parent_concept_uris, create_parent_version) def index_all(): if prev_latest_version: prev_latest_version.index() obj.index() transaction.on_commit(index_all) except ValidationError as err: errors.update(err.message_dict) finally: cls.resume_indexing() if not persisted: if prev_latest_version: prev_latest_version.is_latest_version = True prev_latest_version.save() if obj.id: obj.remove_locales() obj.sources.remove(parent_head) obj.delete() errors['non_field_errors'] = [PERSIST_CLONE_ERROR] return errors
def clone(self, user=None): mapping = Mapping( version=generate_temp_version(), mnemonic=self.mnemonic, parent_id=self.parent_id, map_type=self.map_type, retired=self.retired, released=self.released, is_latest_version=self.is_latest_version, extras=self.extras, public_access=self.public_access, external_id=self.external_id, versioned_object_id=self.versioned_object_id, to_concept_id=self.to_concept_id, to_concept_code=self.to_concept_code, to_concept_name=self.to_concept_name, to_source_id=self.to_source_id, to_source_url=self.to_source_url, to_source_version=self.to_source_version, from_concept_id=self.from_concept_id, from_concept_code=self.from_concept_code, from_concept_name=self.from_concept_name, from_source_id=self.from_source_id, from_source_url=self.from_source_url, from_source_version=self.from_source_version, ) if user: mapping.created_by = mapping.updated_by = user return mapping
def process_line(self, line): # pylint: disable=too-many-locals data = json.loads(line) original_data = data.copy() self.processed += 1 data.pop('parent_type_id', None) 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 = data.pop('parent_id') descriptions_data = data.pop('descriptions', []) names_data = data.pop('names', []) mnemonic = data.get('mnemonic') 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 Concept.objects.filter(uri=data['uri']).exists(): self.existed.append(original_data) else: try: if parent_id in self.sources: source = self.sources[parent_id] else: source = self.get_source(parent_id) self.sources[parent_id] = source names = self.get_locales(names_data) descriptions = self.get_locales(descriptions_data) concept = Concept.objects.create( **data, version=generate_temp_version(), is_latest_version=False, parent=source) concept.version = concept.id concept.versioned_object_id = concept.id concept.parent = source concept.names.set(names) concept.sources.add(source) concept.descriptions.set(descriptions) concept.update_mappings() concept.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.failed.append({**original_data, 'errors': args})
def create_initial_version(cls, concept, **kwargs): initial_version = cls.version_for_concept(concept, generate_temp_version()) initial_version.save(**kwargs) initial_version.version = initial_version.id initial_version.released = True initial_version.is_latest_version = True initial_version.save() return initial_version
def persist_new(cls, data, user=None, create_initial_version=True): names = [ name if isinstance(name, LocalizedText) else LocalizedText.build( name ) for name in data.pop('names', []) or [] ] descriptions = [ desc if isinstance(desc, LocalizedText) else LocalizedText.build( desc, 'description' ) for desc in data.pop('descriptions', []) or [] ] parent_concept_uris = data.pop('parent_concept_urls', None) concept = Concept(**data) concept.version = generate_temp_version() if user: concept.created_by = concept.updated_by = user concept.errors = dict() if concept.is_existing_in_parent(): concept.errors = dict(__all__=[ALREADY_EXISTS]) return concept try: concept.cloned_names = names concept.cloned_descriptions = descriptions concept.full_clean() concept.save() concept.versioned_object_id = concept.id concept.version = str(concept.id) concept.is_latest_version = not create_initial_version parent_resource = concept.parent parent_resource_head = parent_resource.head concept.public_access = parent_resource.public_access concept.save() concept.set_locales() initial_version = None if create_initial_version: initial_version = cls.create_initial_version(concept) initial_version.set_locales() initial_version.sources.set([parent_resource, parent_resource_head]) concept.sources.set([parent_resource, parent_resource_head]) concept.update_mappings() if parent_concept_uris: if get(settings, 'TEST_MODE', False): process_hierarchy_for_new_concept(concept.id, get(initial_version, 'id'), parent_concept_uris) else: process_hierarchy_for_new_concept.delay(concept.id, get(initial_version, 'id'), parent_concept_uris) except ValidationError as ex: concept.errors.update(ex.message_dict) except IntegrityError as ex: concept.errors.update(dict(__all__=ex.args)) return concept
def persist_clone(cls, obj, user=None, **kwargs): errors = dict() if not user: errors['version_created_by'] = PERSIST_CLONE_SPECIFY_USER_ERROR return errors obj.version = obj.version or generate_temp_version() obj.created_by = user obj.updated_by = user parent = obj.parent parent_head = parent.head persisted = False prev_latest_version = None try: with transaction.atomic(): cls.pause_indexing() obj.is_latest_version = True obj.save(**kwargs) if obj.id: obj.version = str(obj.id) obj.save() obj.update_versioned_object() versioned_object = obj.versioned_object prev_latest_version = versioned_object.versions.exclude(id=obj.id).filter( is_latest_version=True).first() if prev_latest_version: prev_latest_version.is_latest_version = False prev_latest_version.save() obj.sources.set(compact([parent, parent_head])) persisted = True cls.resume_indexing() def index_all(): if prev_latest_version: prev_latest_version.index() obj.index() transaction.on_commit(index_all) except ValidationError as err: errors.update(err.message_dict) finally: cls.resume_indexing() if not persisted: if obj.id: obj.sources.remove(parent_head) if prev_latest_version: prev_latest_version.is_latest_version = True prev_latest_version.save() obj.delete() errors['non_field_errors'] = [PERSIST_CLONE_ERROR] return errors
def clone(self): concept_version = Concept( mnemonic=self.mnemonic, version=generate_temp_version(), public_access=self.public_access, external_id=self.external_id, concept_class=self.concept_class, datatype=self.datatype, retired=self.retired, released=self.released, extras=self.extras or dict(), parent=self.parent, is_latest_version=self.is_latest_version, parent_id=self.parent_id, versioned_object_id=self.versioned_object_id, ) concept_version.cloned_names = self.__clone_name_locales() concept_version.cloned_descriptions = self.__clone_description_locales( ) return concept_version
def persist_new(cls, data, user): related_fields = [ 'from_concept_url', 'to_concept_url', 'to_source_url', 'from_source_url' ] field_data = {k: v for k, v in data.items() if k not in related_fields} url_params = {k: v for k, v in data.items() if k in related_fields} mapping = Mapping(**field_data, created_by=user, updated_by=user) temp_version = generate_temp_version() mapping.mnemonic = data.get('mnemonic', temp_version) mapping.version = temp_version mapping.errors = dict() if mapping.is_existing_in_parent(): mapping.errors = dict(__all__=[ALREADY_EXISTS]) return mapping mapping.populate_fields_from_relations(url_params) try: mapping.full_clean() mapping.save() mapping.versioned_object_id = mapping.id mapping.version = str(mapping.id) mapping.is_latest_version = False if mapping.mnemonic == temp_version: mapping.mnemonic = str(mapping.id) parent = mapping.parent parent_head = parent.head mapping.public_access = parent.public_access mapping.save() initial_version = cls.create_initial_version(mapping) initial_version.sources.set([parent, parent_head]) mapping.sources.set([parent, parent_head]) except ValidationError as ex: mapping.errors.update(ex.message_dict) except IntegrityError as ex: mapping.errors.update(dict(__all__=ex.args)) return mapping