def to_python(self, value):
if isinstance(value, str):
try:
value = json.loads(value)
if isinstance(value, list):
raise ValidationError("JSON must be an object.")
except json.JSONLoadError:
raise ValidationError("Enter valid JSON.")
return value
def _loads(self, data_json):
if not data_json:
return {}
data = json.loads(data_json)
if (self.content_type_id
and self.content_type.model_class() is Component
and 'settings' in data):
try:
environment_data = data['settings']
environment = list(environment_data.keys())[0]
if isinstance(environment_data[environment], str):
settings_data = json.loads(
decrypt_data(environment_data[environment]))
else:
settings_data = environment_data[environment] or {}
data['settings'][environment] = settings_data
except (KeyError, IndexError):
return {}
return dictutil.flatten(data)
def _process(value: Any, path: iterutil.IterPath) -> Any:
if is_encrypted(value):
path = _str_path(path)
if hidden_re.search(path):
encrypted_data = value.split(settings.ENCRYPT_PREFIX,
maxsplit=1)[-1]
obj = decrypt_data(encrypted_data)
return json.loads(obj)['value']
return value
def load_backup(backup: Backup, user: User = None):
with backup.data_file.open() as fp:
data = json.loads(fp.read())
environments = data.get('environments', [])
for item in environments:
environment_id = item['id']
alias = item['alias']
try:
environment = Environment.objects.get(pk=environment_id)
except Environment.DoesNotExist:
environment = Environment(pk=environment_id)
if environment.alias != alias:
Environment.objects.filter(alias=alias).delete()
environment.alias = alias
environment.name = item['name']
environment.order = item.get('order', 0)
environment.is_active = item.get('is_active', True)
environment.created_at = item['created_at']
environment.updated_at = item['updated_at']
environment.save()
for item in environments:
environment_id = item['id']
environment = Environment.objects.get(pk=environment_id)
fallback_alias = item['fallback']
if not fallback_alias:
continue
try:
fallback = Environment.objects.get(alias=fallback_alias)
except Environment.DoesNotExist:
continue
environment.fallback = fallback
environment.save(update_fields=['fallback'])
components = data.get('components', [])
for item in components:
component_id = item['id']
alias = item['alias']
try:
component = Component.objects.get(pk=component_id)
except Component.DoesNotExist:
component = Component(pk=component_id)
if component.alias != alias:
Component.objects.filter(alias=alias).delete()
component.alias = alias
component.name = item['name']
component.schema_json = item['schema_json']
component.is_global = item['is_global']
component.require_schema = item['require_schema']
component.strict_keys = item['strict_keys']
component.is_active = item['is_active']
component.created_at = item['created_at']
component.updated_at = item['updated_at']
component.save()
for environment, component_data in data.get('configs', {}).items():
for component, data in component_data.items():
configstore.update_data(
environment=environment,
component=component,
data=data,
)
# Notify about loaded backup
backup_loaded.send(sender=Backup, backup=backup, user=user)
def schema(self):
return json.loads(self.schema_json)
def get_all_data() -> Dict[str, Dict[str, dict]]:
if hasattr(_cached_data, _cached_data_key):
return getattr(_cached_data, _cached_data_key)
data = _store.all()
return iterutil.traverse(data, lambda value, path: json.loads(value))