def __validate_inputs(self, kwargs):
for param in self.params_map["enum"]:
if param in kwargs:
check_allowed_values(self.allowed_values, (param, ),
kwargs[param])
for param in self.params_map["validation"]:
if param in kwargs:
check_validations(self.validations, (param, ),
kwargs[param],
configuration=self.api_client.configuration)
if kwargs["_check_input_type"] is False:
return
for key, value in kwargs.items():
fixed_val = validate_and_convert_types(
value,
self.openapi_types[key],
[key],
False,
kwargs["_check_input_type"],
configuration=self.api_client.configuration,
)
kwargs[key] = fixed_val
def create_handler(
session: Optional[SessionProxy],
request: ResourceHandlerRequest,
callback_context: MutableMapping[str, Any],
) -> ProgressEvent:
LOG.info("Starting %s Create Handler", TYPE_NAME)
model = request.desiredResourceState
try:
json_payload = json.loads(model.DashboardDefinition)
except json.JSONDecodeError as e:
LOG.error("Exception when loading the Dashboard JSON definition: %s\n",
e)
return ProgressEvent(
status=OperationStatus.FAILED,
resourceModel=model,
message=f"Error loading Dashboard JSON definition: {e}")
with v1_client(
model.DatadogCredentials.ApiKey,
model.DatadogCredentials.ApplicationKey,
model.DatadogCredentials.ApiURL,
TELEMETRY_TYPE_NAME,
__version__,
) as api_client:
api_instance = DashboardsApi(api_client)
try:
# Call the deserialization function of the python client.
# It expects the loaded JSON payload, the python client type of the model,
# some path to the data (not sure what this one does),
# whether or not the payload is a server payload, so true in our case,
# whether or not to do type conversion, true in our case too
# and importantly the api_client configuration, needed to perform the type conversions
dashboard = validate_and_convert_types(
json_payload, (Dashboard, ), ["resource_data"],
True,
True,
configuration=api_client.configuration)
res = api_instance.create_dashboard(dashboard)
model.Id = res.id
except TypeError as e:
LOG.error(
"Exception when deserializing the Dashboard payload definition: %s\n",
e)
return ProgressEvent(status=OperationStatus.FAILED,
resourceModel=model,
message=f"Error deserializing dashboard: {e}")
except ApiException as e:
LOG.error(
"Exception when calling DashboardsApi->create_dashboard: %s\n",
e)
return ProgressEvent(status=OperationStatus.FAILED,
resourceModel=model,
message=f"Error creating dashboard: {e}")
return read_handler(session, request, callback_context)
def deserialize(self, response, response_type, _check_type):
"""Deserializes response into an object.
:param response: RESTResponse object to be deserialized.
:param response_type: For the response, a tuple containing:
valid classes
a list containing valid classes (for list schemas)
a dict containing a tuple of valid classes as the value
Example values:
(str,)
(Pet,)
(float, none_type)
([int, none_type],)
({str: (bool, str, int, float, date, datetime, str, none_type)},)
:param _check_type: boolean, whether to check the types of the data
received from the server
:type _check_type: bool
:return: deserialized object.
"""
# handle file downloading
# save response body into a tmp file and return the instance
if response_type == (file_type, ):
content_disposition = response.getheader("Content-Disposition")
return deserialize_file(response.data,
self.configuration,
content_disposition=content_disposition)
# fetch data from response object
try:
received_data = json.loads(response.data)
except ValueError:
received_data = response.data
# store our data under the key of 'received_data' so users have some
# context if they are deserializing a string and the data type is wrong
deserialized_data = validate_and_convert_types(
received_data,
response_type, ['received_data'],
True,
_check_type,
configuration=self.configuration)
return deserialized_data