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
