Add backfilled degradation and maintenance endpoints to Status Pages

api/datadogV2/api_status_pages.go

@@ -16,6 +16,224 @@ import (
 // StatusPagesApi service type
 type StatusPagesApi datadog.Service
 
+// CreateBackfilledDegradationOptionalParameters holds optional parameters for CreateBackfilledDegradation.
+type CreateBackfilledDegradationOptionalParameters struct {
+	Include *string
+}
+
+// NewCreateBackfilledDegradationOptionalParameters creates an empty struct for parameters.
+func NewCreateBackfilledDegradationOptionalParameters() *CreateBackfilledDegradationOptionalParameters {
+	this := CreateBackfilledDegradationOptionalParameters{}
+	return &this
+}
+
+// WithInclude sets the corresponding parameter name and returns the struct.
+func (r *CreateBackfilledDegradationOptionalParameters) WithInclude(include string) *CreateBackfilledDegradationOptionalParameters {
+	r.Include = &include
+	return r
+}
+
+// CreateBackfilledDegradation Create backfilled degradation.
+// Creates a backfilled degradation with predefined updates.
+func (a *StatusPagesApi) CreateBackfilledDegradation(ctx _context.Context, pageId uuid.UUID, body CreateBackfilledDegradationRequest, o ...CreateBackfilledDegradationOptionalParameters) (Degradation, *_nethttp.Response, error) {
+	var (
+		localVarHTTPMethod  = _nethttp.MethodPost
+		localVarPostBody    interface{}
+		localVarReturnValue Degradation
+		optionalParams      CreateBackfilledDegradationOptionalParameters
+	)
+
+	if len(o) > 1 {
+		return localVarReturnValue, nil, datadog.ReportError("only one argument of type CreateBackfilledDegradationOptionalParameters is allowed")
+	}
+	if len(o) == 1 {
+		optionalParams = o[0]
+	}
+
+	localBasePath, err := a.Client.Cfg.ServerURLWithContext(ctx, "v2.StatusPagesApi.CreateBackfilledDegradation")
+	if err != nil {
+		return localVarReturnValue, nil, datadog.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/api/v2/statuspages/{page_id}/degradations/backfill"
+	localVarPath = datadog.ReplacePathParameter(localVarPath, "{page_id}", _neturl.PathEscape(datadog.ParameterToString(pageId, "")))
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := _neturl.Values{}
+	localVarFormParams := _neturl.Values{}
+	if optionalParams.Include != nil {
+		localVarQueryParams.Add("include", datadog.ParameterToString(*optionalParams.Include, ""))
+	}
+	localVarHeaderParams["Content-Type"] = "application/json"
+	localVarHeaderParams["Accept"] = "application/json"
+
+	// body params
+	localVarPostBody = &body
+	if a.Client.Cfg.DelegatedTokenConfig != nil {
+		err = datadog.UseDelegatedTokenAuth(ctx, &localVarHeaderParams, a.Client.Cfg.DelegatedTokenConfig)
+		if err != nil {
+			return localVarReturnValue, nil, err
+		}
+	} else {
+		datadog.SetAuthKeys(
+			ctx,
+			&localVarHeaderParams,
+			[2]string{"apiKeyAuth", "DD-API-KEY"},
+			[2]string{"appKeyAuth", "DD-APPLICATION-KEY"},
+		)
+	}
+	req, err := a.Client.PrepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, nil)
+	if err != nil {
+		return localVarReturnValue, nil, err
+	}
+
+	localVarHTTPResponse, err := a.Client.CallAPI(req)
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	localVarBody, err := datadog.ReadBody(localVarHTTPResponse)
+	if err != nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := datadog.GenericOpenAPIError{
+			ErrorBody:    localVarBody,
+			ErrorMessage: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 429 {
+			var v APIErrorResponse
+			err = a.Client.Decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.ErrorModel = v
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	err = a.Client.Decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := datadog.GenericOpenAPIError{
+			ErrorBody:    localVarBody,
+			ErrorMessage: err.Error(),
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	return localVarReturnValue, localVarHTTPResponse, nil
+}
+
+// CreateBackfilledMaintenanceOptionalParameters holds optional parameters for CreateBackfilledMaintenance.
+type CreateBackfilledMaintenanceOptionalParameters struct {
+	Include *string
+}
+
+// NewCreateBackfilledMaintenanceOptionalParameters creates an empty struct for parameters.
+func NewCreateBackfilledMaintenanceOptionalParameters() *CreateBackfilledMaintenanceOptionalParameters {
+	this := CreateBackfilledMaintenanceOptionalParameters{}
+	return &this
+}
+
+// WithInclude sets the corresponding parameter name and returns the struct.
+func (r *CreateBackfilledMaintenanceOptionalParameters) WithInclude(include string) *CreateBackfilledMaintenanceOptionalParameters {
+	r.Include = &include
+	return r
+}
+
+// CreateBackfilledMaintenance Create backfilled maintenance.
+// Creates a backfilled maintenance with predefined updates.
+func (a *StatusPagesApi) CreateBackfilledMaintenance(ctx _context.Context, pageId uuid.UUID, body CreateBackfilledMaintenanceRequest, o ...CreateBackfilledMaintenanceOptionalParameters) (Maintenance, *_nethttp.Response, error) {
+	var (
+		localVarHTTPMethod  = _nethttp.MethodPost
+		localVarPostBody    interface{}
+		localVarReturnValue Maintenance
+		optionalParams      CreateBackfilledMaintenanceOptionalParameters
+	)
+
+	if len(o) > 1 {
+		return localVarReturnValue, nil, datadog.ReportError("only one argument of type CreateBackfilledMaintenanceOptionalParameters is allowed")
+	}
+	if len(o) == 1 {
+		optionalParams = o[0]
+	}
+
+	localBasePath, err := a.Client.Cfg.ServerURLWithContext(ctx, "v2.StatusPagesApi.CreateBackfilledMaintenance")
+	if err != nil {
+		return localVarReturnValue, nil, datadog.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/api/v2/statuspages/{page_id}/maintenances/backfill"
+	localVarPath = datadog.ReplacePathParameter(localVarPath, "{page_id}", _neturl.PathEscape(datadog.ParameterToString(pageId, "")))
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := _neturl.Values{}
+	localVarFormParams := _neturl.Values{}
+	if optionalParams.Include != nil {
+		localVarQueryParams.Add("include", datadog.ParameterToString(*optionalParams.Include, ""))
+	}
+	localVarHeaderParams["Content-Type"] = "application/json"
+	localVarHeaderParams["Accept"] = "application/json"
+
+	// body params
+	localVarPostBody = &body
+	if a.Client.Cfg.DelegatedTokenConfig != nil {
+		err = datadog.UseDelegatedTokenAuth(ctx, &localVarHeaderParams, a.Client.Cfg.DelegatedTokenConfig)
+		if err != nil {
+			return localVarReturnValue, nil, err
+		}
+	} else {
+		datadog.SetAuthKeys(
+			ctx,
+			&localVarHeaderParams,
+			[2]string{"apiKeyAuth", "DD-API-KEY"},
+			[2]string{"appKeyAuth", "DD-APPLICATION-KEY"},
+		)
+	}
+	req, err := a.Client.PrepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, nil)
+	if err != nil {
+		return localVarReturnValue, nil, err
+	}
+
+	localVarHTTPResponse, err := a.Client.CallAPI(req)
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	localVarBody, err := datadog.ReadBody(localVarHTTPResponse)
+	if err != nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := datadog.GenericOpenAPIError{
+			ErrorBody:    localVarBody,
+			ErrorMessage: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 429 {
+			var v APIErrorResponse
+			err = a.Client.Decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.ErrorModel = v
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	err = a.Client.Decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := datadog.GenericOpenAPIError{
+			ErrorBody:    localVarBody,
+			ErrorMessage: err.Error(),
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	return localVarReturnValue, localVarHTTPResponse, nil
+}
+
 // CreateComponentOptionalParameters holds optional parameters for CreateComponent.
 type CreateComponentOptionalParameters struct {
 	Include *string

api/datadogV2/doc.go

@@ -900,6 +900,8 @@
 //   - [StaticAnalysisApi.ListCustomRuleRevisions]
 //   - [StaticAnalysisApi.RevertCustomRuleRevision]
 //   - [StaticAnalysisApi.UpdateCustomRuleset]
+//   - [StatusPagesApi.CreateBackfilledDegradation]
+//   - [StatusPagesApi.CreateBackfilledMaintenance]
 //   - [StatusPagesApi.CreateComponent]
 //   - [StatusPagesApi.CreateDegradation]
 //   - [StatusPagesApi.CreateMaintenance]

api/datadogV2/model_create_backfilled_degradation_request.go

@@ -0,0 +1,111 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+package datadogV2
+
+import (
+	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
+)
+
+// CreateBackfilledDegradationRequest Request object for creating a backfilled degradation.
+type CreateBackfilledDegradationRequest struct {
+	// The data object for creating a backfilled degradation.
+	Data *CreateBackfilledDegradationRequestData `json:"data,omitempty"`
+	// UnparsedObject contains the raw value of the object if there was an error when deserializing into the struct
+	UnparsedObject       map[string]interface{} `json:"-"`
+	AdditionalProperties map[string]interface{} `json:"-"`
+}
+
+// NewCreateBackfilledDegradationRequest instantiates a new CreateBackfilledDegradationRequest object.
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed.
+func NewCreateBackfilledDegradationRequest() *CreateBackfilledDegradationRequest {
+	this := CreateBackfilledDegradationRequest{}
+	return &this
+}
+
+// NewCreateBackfilledDegradationRequestWithDefaults instantiates a new CreateBackfilledDegradationRequest object.
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set.
+func NewCreateBackfilledDegradationRequestWithDefaults() *CreateBackfilledDegradationRequest {
+	this := CreateBackfilledDegradationRequest{}
+	return &this
+}
+
+// GetData returns the Data field value if set, zero value otherwise.
+func (o *CreateBackfilledDegradationRequest) GetData() CreateBackfilledDegradationRequestData {
+	if o == nil || o.Data == nil {
+		var ret CreateBackfilledDegradationRequestData
+		return ret
+	}
+	return *o.Data
+}
+
+// GetDataOk returns a tuple with the Data field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateBackfilledDegradationRequest) GetDataOk() (*CreateBackfilledDegradationRequestData, bool) {
+	if o == nil || o.Data == nil {
+		return nil, false
+	}
+	return o.Data, true
+}
+
+// HasData returns a boolean if a field has been set.
+func (o *CreateBackfilledDegradationRequest) HasData() bool {
+	return o != nil && o.Data != nil
+}
+
+// SetData gets a reference to the given CreateBackfilledDegradationRequestData and assigns it to the Data field.
+func (o *CreateBackfilledDegradationRequest) SetData(v CreateBackfilledDegradationRequestData) {
+	o.Data = &v
+}
+
+// MarshalJSON serializes the struct using spec logic.
+func (o CreateBackfilledDegradationRequest) MarshalJSON() ([]byte, error) {
+	toSerialize := map[string]interface{}{}
+	if o.UnparsedObject != nil {
+		return datadog.Marshal(o.UnparsedObject)
+	}
+	if o.Data != nil {
+		toSerialize["data"] = o.Data
+	}
+
+	for key, value := range o.AdditionalProperties {
+		toSerialize[key] = value
+	}
+	return datadog.Marshal(toSerialize)
+}
+
+// UnmarshalJSON deserializes the given payload.
+func (o *CreateBackfilledDegradationRequest) UnmarshalJSON(bytes []byte) (err error) {
+	all := struct {
+		Data *CreateBackfilledDegradationRequestData `json:"data,omitempty"`
+	}{}
+	if err = datadog.Unmarshal(bytes, &all); err != nil {
+		return datadog.Unmarshal(bytes, &o.UnparsedObject)
+	}
+	additionalProperties := make(map[string]interface{})
+	if err = datadog.Unmarshal(bytes, &additionalProperties); err == nil {
+		datadog.DeleteKeys(additionalProperties, &[]string{"data"})
+	} else {
+		return err
+	}
+
+	hasInvalidField := false
+	if all.Data != nil && all.Data.UnparsedObject != nil && o.UnparsedObject == nil {
+		hasInvalidField = true
+	}
+	o.Data = all.Data
+
+	if len(additionalProperties) > 0 {
+		o.AdditionalProperties = additionalProperties
+	}
+
+	if hasInvalidField {
+		return datadog.Unmarshal(bytes, &o.UnparsedObject)
+	}
+
+	return nil
+}