async def _validate(self, schema_name, data, id=None):
verrors = ValidationErrors()
await self._ensure_unique(verrors, schema_name, "name", data["name"],
id)
if data["type"] not in TYPES:
verrors.add(f"{schema_name}.type", "Invalid type")
raise verrors
else:
type = TYPES[data["type"]]
attributes_verrors = validate_schema(type.credentials_schema,
data["attributes"])
verrors.add_child(f"{schema_name}.attributes", attributes_verrors)
if verrors:
raise verrors
await type.validate_and_pre_save(self.middleware, verrors,
f"{schema_name}.attributes",
data["attributes"])
if verrors:
raise verrors
def construct_schema(
item_version_details: dict, new_values: dict, update: bool, old_values: Union[dict, object] = NOT_PROVIDED
) -> dict:
schema_name = f'chart_release_{"update" if update else "create"}'
attrs = list(itertools.chain.from_iterable(
get_schema(q, update, old_values) for q in item_version_details['schema']['questions']
))
dict_obj = update_conditional_defaults(
Dict(schema_name, *attrs, update=update, additional_attrs=True), {
'schema': {'attrs': item_version_details['schema']['questions']}
}
)
verrors = ValidationErrors()
verrors.add_child('values', validate_schema(
attrs, new_values, True, dict_kwargs={
'conditional_defaults': dict_obj.conditional_defaults, 'update': update,
}
))
return {
'verrors': verrors,
'new_values': new_values,
'dict_obj': dict_obj,
'schema_name': schema_name,
}
async def do_update(self, data):
"""
Update default Alert settings.
.. examples(rest)::
Set ClassName's level to LEVEL and policy to POLICY. Reset settings for other alert classes.
{
"classes": {
"ClassName": {
"level": "LEVEL",
"policy": "POLICY",
}
}
}
"""
old = await self.config()
new = old.copy()
new.update(data)
verrors = ValidationErrors()
for k, v in new["classes"].items():
if k not in AlertClass.class_by_name:
verrors.add(f"alert_class_update.classes.{k}",
"This alert class does not exist")
verrors.add_child(
f"alert_class_update.classes.{k}",
validate_schema([
Str("level", enum=list(AlertLevel.__members__)),
Str("policy", enum=POLICIES),
Bool("proactive_support"),
], v),
)
if "proactive_support" in v and not AlertClass.class_by_name[
k].proactive_support:
verrors.add(
f"alert_class_update.classes.{k}.proactive_support",
"Proactive support is not supported by this alert class",
)
if verrors:
raise verrors
await self.middleware.call("datastore.update", self._config.datastore,
old["id"], new)
return await self.config()
async def _validate(self, schema_name, data, id=None):
verrors = ValidationErrors()
await self._ensure_unique(verrors, schema_name, "name", data["name"], id)
if data["provider"] not in REMOTES:
verrors.add(f"{schema_name}.provider", "Invalid provider")
else:
provider = REMOTES[data["provider"]]
attributes_verrors = validate_schema(provider.credentials_schema, data["attributes"])
verrors.add_child(f"{schema_name}.attributes", attributes_verrors)
if verrors:
raise verrors
async def _validate(self, service, schema_name):
verrors = ValidationErrors()
factory = ALERT_SERVICES_FACTORIES.get(service["type"])
if factory is None:
verrors.add(f"{schema_name}.type", "This field has invalid value")
raise verrors
verrors.add_child(
f"{schema_name}.attributes",
validate_schema(list(factory.schema.attrs.values()),
service["attributes"]))
if verrors:
raise verrors
async def _basic_validate(self, verrors, name, data):
if data["encryption"]:
if not data["encryption_password"]:
verrors.add(f"{name}.encryption_password", "This field is required when encryption is enabled")
credentials = await self._get_credentials(data["credentials"])
if not credentials:
verrors.add(f"{name}.credentials", "Invalid credentials")
try:
shlex.split(data["args"])
except ValueError as e:
verrors.add(f"{name}.args", f"Parse error: {e.args[0]}")
if verrors:
raise verrors
provider = REMOTES[credentials["provider"]]
schema = []
if provider.buckets:
schema.append(Str("bucket", required=True, empty=False))
schema.append(Str("folder", required=True))
schema.extend(provider.task_schema)
schema.extend(self.common_task_schema(provider))
attributes_verrors = validate_schema(schema, data["attributes"])
if not attributes_verrors:
await provider.pre_save_task(data, credentials, verrors)
verrors.add_child(f"{name}.attributes", attributes_verrors)
def test__validate_schema(schema, data, result):
verrors = validate_schema(schema, data)
if isinstance(result, set):
assert result == {e.attribute for e in verrors.errors}
else:
assert data == result