diff --git a/services/resourcemanager/api_default.go b/services/resourcemanager/api_default.go index 67e29a57b..59bd9b21e 100644 --- a/services/resourcemanager/api_default.go +++ b/services/resourcemanager/api_default.go @@ -27,6 +27,158 @@ import ( // DefaultApiService DefaultApi service type DefaultApiService service +type ApiCreateFolderRequest struct { + ctx context.Context + apiService *DefaultApiService + createFolderPayload *CreateFolderPayload +} + +func (r ApiCreateFolderRequest) CreateFolderPayload(createFolderPayload CreateFolderPayload) ApiCreateFolderRequest { + r.createFolderPayload = &createFolderPayload + return r +} + +func (r ApiCreateFolderRequest) Execute() (*FolderResponse, error) { + var ( + localVarHTTPMethod = http.MethodPost + localVarPostBody interface{} + formFiles []formFile + localVarReturnValue *FolderResponse + ) + a := r.apiService + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.CreateFolder") + if err != nil { + return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()} + } + + localVarPath := localBasePath + "/v2/folders" + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + + // to determine the Content-Type header + localVarHTTPContentTypes := []string{"application/json"} + + // set Content-Type header + localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) + if localVarHTTPContentType != "" { + localVarHeaderParams["Content-Type"] = localVarHTTPContentType + } + + // to determine the Accept header + localVarHTTPHeaderAccepts := []string{"application/json"} + + // set Accept header + localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts) + if localVarHTTPHeaderAccept != "" { + localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept + } + // body params + localVarPostBody = r.createFolderPayload + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return localVarReturnValue, err + } + + contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request) + if ok { + *contextHTTPRequest = req + } + + localVarHTTPResponse, err := a.client.callAPI(req) + contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response) + if ok { + *contextHTTPResponse = localVarHTTPResponse + } + if err != nil || localVarHTTPResponse == nil { + return localVarReturnValue, err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return localVarReturnValue, err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 400 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 403 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 409 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + } + return localVarReturnValue, newErr + } + + err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: err.Error(), + } + return localVarReturnValue, newErr + } + + return localVarReturnValue, nil +} + +/* +CreateFolder: Create Folder + +Create a new folder. + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @return ApiCreateFolderRequest +*/ +func (a *APIClient) CreateFolder(ctx context.Context) ApiCreateFolderRequest { + return ApiCreateFolderRequest{ + apiService: a.defaultApi, + ctx: ctx, + } +} + +func (a *APIClient) CreateFolderExecute(ctx context.Context) (*FolderResponse, error) { + r := ApiCreateFolderRequest{ + apiService: a.defaultApi, + ctx: ctx, + } + return r.Execute() +} + type ApiCreateProjectRequest struct { ctx context.Context apiService *DefaultApiService @@ -181,6 +333,283 @@ func (a *APIClient) CreateProjectExecute(ctx context.Context) (*Project, error) return r.Execute() } +type ApiDeleteFolderRequest struct { + ctx context.Context + apiService *DefaultApiService + containerId string + force *bool +} + +// If true, all nested, empty folders are deleted recursively - if no project is attached! + +func (r ApiDeleteFolderRequest) Force(force bool) ApiDeleteFolderRequest { + r.force = &force + return r +} + +func (r ApiDeleteFolderRequest) Execute() error { + var ( + localVarHTTPMethod = http.MethodDelete + localVarPostBody interface{} + formFiles []formFile + ) + a := r.apiService + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.DeleteFolder") + if err != nil { + return &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()} + } + + localVarPath := localBasePath + "/v2/folders/{containerId}" + localVarPath = strings.Replace(localVarPath, "{"+"containerId"+"}", url.PathEscape(ParameterValueToString(r.containerId, "containerId")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + + if r.force != nil { + parameterAddToHeaderOrQuery(localVarQueryParams, "force", r.force, "") + } + // to determine the Content-Type header + localVarHTTPContentTypes := []string{} + + // set Content-Type header + localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) + if localVarHTTPContentType != "" { + localVarHeaderParams["Content-Type"] = localVarHTTPContentType + } + + // to determine the Accept header + localVarHTTPHeaderAccepts := []string{"application/json"} + + // set Accept header + localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts) + if localVarHTTPHeaderAccept != "" { + localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept + } + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return err + } + + contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request) + if ok { + *contextHTTPRequest = req + } + + localVarHTTPResponse, err := a.client.callAPI(req) + contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response) + if ok { + *contextHTTPResponse = localVarHTTPResponse + } + if err != nil || localVarHTTPResponse == nil { + return err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 404 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return newErr + } + if localVarHTTPResponse.StatusCode == 409 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + } + return newErr + } + + return nil +} + +/* +DeleteFolder: Delete Folder + +Delete a folder and its metadata. +- Folder must not be parent of any other container +- A force flag may be set, deleting all underlying folders recursively - if no project is attached! + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param containerId Folder identifier - containerId as well as UUID identifier is supported. + @return ApiDeleteFolderRequest +*/ +func (a *APIClient) DeleteFolder(ctx context.Context, containerId string) ApiDeleteFolderRequest { + return ApiDeleteFolderRequest{ + apiService: a.defaultApi, + ctx: ctx, + containerId: containerId, + } +} + +func (a *APIClient) DeleteFolderExecute(ctx context.Context, containerId string) error { + r := ApiDeleteFolderRequest{ + apiService: a.defaultApi, + ctx: ctx, + containerId: containerId, + } + return r.Execute() +} + +type ApiDeleteFolderLabelsRequest struct { + ctx context.Context + apiService *DefaultApiService + containerId string + keys *[]string +} + +// Label name. + +func (r ApiDeleteFolderLabelsRequest) Keys(keys []string) ApiDeleteFolderLabelsRequest { + r.keys = &keys + return r +} + +func (r ApiDeleteFolderLabelsRequest) Execute() error { + var ( + localVarHTTPMethod = http.MethodDelete + localVarPostBody interface{} + formFiles []formFile + ) + a := r.apiService + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.DeleteFolderLabels") + if err != nil { + return &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()} + } + + localVarPath := localBasePath + "/v2/folders/{containerId}/labels" + localVarPath = strings.Replace(localVarPath, "{"+"containerId"+"}", url.PathEscape(ParameterValueToString(r.containerId, "containerId")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + + if r.keys != nil { + t := *r.keys + if reflect.TypeOf(t).Kind() == reflect.Slice { + s := reflect.ValueOf(t) + for i := 0; i < s.Len(); i++ { + parameterAddToHeaderOrQuery(localVarQueryParams, "keys", s.Index(i).Interface(), "multi") + } + } else { + parameterAddToHeaderOrQuery(localVarQueryParams, "keys", t, "multi") + } + } + // to determine the Content-Type header + localVarHTTPContentTypes := []string{} + + // set Content-Type header + localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) + if localVarHTTPContentType != "" { + localVarHeaderParams["Content-Type"] = localVarHTTPContentType + } + + // to determine the Accept header + localVarHTTPHeaderAccepts := []string{"application/json"} + + // set Accept header + localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts) + if localVarHTTPHeaderAccept != "" { + localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept + } + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return err + } + + contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request) + if ok { + *contextHTTPRequest = req + } + + localVarHTTPResponse, err := a.client.callAPI(req) + contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response) + if ok { + *contextHTTPResponse = localVarHTTPResponse + } + if err != nil || localVarHTTPResponse == nil { + return err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 409 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + } + return newErr + } + + return nil +} + +/* +DeleteFolderLabels: Delete Folder Labels + +Deletes all folder labels by given keys. +- Specific labels may be deleted by key(s) +- If no key is specified, all labels will be deleted! + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param containerId Folder identifier - containerId as well as UUID identifier is supported. + @return ApiDeleteFolderLabelsRequest +*/ +func (a *APIClient) DeleteFolderLabels(ctx context.Context, containerId string) ApiDeleteFolderLabelsRequest { + return ApiDeleteFolderLabelsRequest{ + apiService: a.defaultApi, + ctx: ctx, + containerId: containerId, + } +} + +func (a *APIClient) DeleteFolderLabelsExecute(ctx context.Context, containerId string) error { + r := ApiDeleteFolderLabelsRequest{ + apiService: a.defaultApi, + ctx: ctx, + containerId: containerId, + } + return r.Execute() +} + type ApiDeleteProjectRequest struct { ctx context.Context apiService *DefaultApiService @@ -299,6 +728,153 @@ func (a *APIClient) DeleteProjectExecute(ctx context.Context, id string) error { return r.Execute() } +type ApiGetFolderDetailsRequest struct { + ctx context.Context + apiService *DefaultApiService + containerId string + includeParents *bool +} + +func (r ApiGetFolderDetailsRequest) IncludeParents(includeParents bool) ApiGetFolderDetailsRequest { + r.includeParents = &includeParents + return r +} + +func (r ApiGetFolderDetailsRequest) Execute() (*GetFolderDetailsResponse, error) { + var ( + localVarHTTPMethod = http.MethodGet + localVarPostBody interface{} + formFiles []formFile + localVarReturnValue *GetFolderDetailsResponse + ) + a := r.apiService + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.GetFolderDetails") + if err != nil { + return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()} + } + + localVarPath := localBasePath + "/v2/folders/{containerId}" + localVarPath = strings.Replace(localVarPath, "{"+"containerId"+"}", url.PathEscape(ParameterValueToString(r.containerId, "containerId")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + + if r.includeParents != nil { + parameterAddToHeaderOrQuery(localVarQueryParams, "includeParents", r.includeParents, "") + } + // to determine the Content-Type header + localVarHTTPContentTypes := []string{} + + // set Content-Type header + localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) + if localVarHTTPContentType != "" { + localVarHeaderParams["Content-Type"] = localVarHTTPContentType + } + + // to determine the Accept header + localVarHTTPHeaderAccepts := []string{"application/json"} + + // set Accept header + localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts) + if localVarHTTPHeaderAccept != "" { + localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept + } + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return localVarReturnValue, err + } + + contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request) + if ok { + *contextHTTPRequest = req + } + + localVarHTTPResponse, err := a.client.callAPI(req) + contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response) + if ok { + *contextHTTPResponse = localVarHTTPResponse + } + if err != nil || localVarHTTPResponse == nil { + return localVarReturnValue, err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return localVarReturnValue, err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 403 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 404 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + } + return localVarReturnValue, newErr + } + + err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: err.Error(), + } + return localVarReturnValue, newErr + } + + return localVarReturnValue, nil +} + +/* +GetFolderDetails: Get Folder Details + +Returns all metadata for a specific folder. + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param containerId Folder identifier - containerId as well as UUID identifier is supported. + @return ApiGetFolderDetailsRequest +*/ +func (a *APIClient) GetFolderDetails(ctx context.Context, containerId string) ApiGetFolderDetailsRequest { + return ApiGetFolderDetailsRequest{ + apiService: a.defaultApi, + ctx: ctx, + containerId: containerId, + } +} + +func (a *APIClient) GetFolderDetailsExecute(ctx context.Context, containerId string) (*GetFolderDetailsResponse, error) { + r := ApiGetFolderDetailsRequest{ + apiService: a.defaultApi, + ctx: ctx, + containerId: containerId, + } + return r.Execute() +} + type ApiGetOrganizationRequest struct { ctx context.Context apiService *DefaultApiService @@ -989,6 +1565,166 @@ func (a *APIClient) ListProjectsExecute(ctx context.Context) (*ListProjectsRespo return r.Execute() } +type ApiPartialUpdateFolderRequest struct { + ctx context.Context + apiService *DefaultApiService + containerId string + partialUpdateFolderPayload *PartialUpdateFolderPayload +} + +func (r ApiPartialUpdateFolderRequest) PartialUpdateFolderPayload(partialUpdateFolderPayload PartialUpdateFolderPayload) ApiPartialUpdateFolderRequest { + r.partialUpdateFolderPayload = &partialUpdateFolderPayload + return r +} + +func (r ApiPartialUpdateFolderRequest) Execute() (*FolderResponse, error) { + var ( + localVarHTTPMethod = http.MethodPatch + localVarPostBody interface{} + formFiles []formFile + localVarReturnValue *FolderResponse + ) + a := r.apiService + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.PartialUpdateFolder") + if err != nil { + return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()} + } + + localVarPath := localBasePath + "/v2/folders/{containerId}" + localVarPath = strings.Replace(localVarPath, "{"+"containerId"+"}", url.PathEscape(ParameterValueToString(r.containerId, "containerId")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + + // to determine the Content-Type header + localVarHTTPContentTypes := []string{"application/json"} + + // set Content-Type header + localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) + if localVarHTTPContentType != "" { + localVarHeaderParams["Content-Type"] = localVarHTTPContentType + } + + // to determine the Accept header + localVarHTTPHeaderAccepts := []string{"application/json"} + + // set Accept header + localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts) + if localVarHTTPHeaderAccept != "" { + localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept + } + // body params + localVarPostBody = r.partialUpdateFolderPayload + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return localVarReturnValue, err + } + + contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request) + if ok { + *contextHTTPRequest = req + } + + localVarHTTPResponse, err := a.client.callAPI(req) + contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response) + if ok { + *contextHTTPResponse = localVarHTTPResponse + } + if err != nil || localVarHTTPResponse == nil { + return localVarReturnValue, err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return localVarReturnValue, err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 403 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 404 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 409 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + } + return localVarReturnValue, newErr + } + + err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: err.Error(), + } + return localVarReturnValue, newErr + } + + return localVarReturnValue, nil +} + +/* +PartialUpdateFolder: Update Folder + +Update the folder and its metadata. +- Update folder name +- Update folder labels +- Update folder parent (folder or organization) + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param containerId Folder identifier - containerId as well as UUID identifier is supported. + @return ApiPartialUpdateFolderRequest +*/ +func (a *APIClient) PartialUpdateFolder(ctx context.Context, containerId string) ApiPartialUpdateFolderRequest { + return ApiPartialUpdateFolderRequest{ + apiService: a.defaultApi, + ctx: ctx, + containerId: containerId, + } +} + +func (a *APIClient) PartialUpdateFolderExecute(ctx context.Context, containerId string) (*FolderResponse, error) { + r := ApiPartialUpdateFolderRequest{ + apiService: a.defaultApi, + ctx: ctx, + containerId: containerId, + } + return r.Execute() +} + type ApiPartialUpdateProjectRequest struct { ctx context.Context apiService *DefaultApiService diff --git a/services/resourcemanager/api_default_test.go b/services/resourcemanager/api_default_test.go index 6a5257794..af94f8f94 100644 --- a/services/resourcemanager/api_default_test.go +++ b/services/resourcemanager/api_default_test.go @@ -23,6 +23,54 @@ import ( func Test_resourcemanager_DefaultApiService(t *testing.T) { + t.Run("Test DefaultApiService CreateFolder", func(t *testing.T) { + _apiUrlPath := "/v2/folders" + + testDefaultApiServeMux := http.NewServeMux() + testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) { + data := FolderResponse{} + w.Header().Add("Content-Type", "application/json") + json.NewEncoder(w).Encode(data) + }) + testServer := httptest.NewServer(testDefaultApiServeMux) + defer testServer.Close() + + configuration := &config.Configuration{ + DefaultHeader: make(map[string]string), + UserAgent: "OpenAPI-Generator/1.0.0/go", + Debug: false, + Region: "test_region", + Servers: config.ServerConfigurations{ + { + URL: testServer.URL, + Description: "Localhost for resourcemanager_DefaultApi", + Variables: map[string]config.ServerVariable{ + "region": { + DefaultValue: "test_region.", + EnumValues: []string{ + "test_region.", + }, + }, + }, + }, + }, + OperationServers: map[string]config.ServerConfigurations{}, + } + apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication()) + if err != nil { + t.Fatalf("creating API client: %v", err) + } + + resp, reqErr := apiClient.CreateFolder(context.Background()).Execute() + + if reqErr != nil { + t.Fatalf("error in call: %v", reqErr) + } + if IsNil(resp) { + t.Fatalf("response not present") + } + }) + t.Run("Test DefaultApiService CreateProject", func(t *testing.T) { _apiUrlPath := "/v2/projects" @@ -71,6 +119,98 @@ func Test_resourcemanager_DefaultApiService(t *testing.T) { } }) + t.Run("Test DefaultApiService DeleteFolder", func(t *testing.T) { + _apiUrlPath := "/v2/folders/{containerId}" + containerIdValue := "containerId" + _apiUrlPath = strings.Replace(_apiUrlPath, "{"+"containerId"+"}", url.PathEscape(ParameterValueToString(containerIdValue, "containerId")), -1) + + testDefaultApiServeMux := http.NewServeMux() + testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) { + }) + testServer := httptest.NewServer(testDefaultApiServeMux) + defer testServer.Close() + + configuration := &config.Configuration{ + DefaultHeader: make(map[string]string), + UserAgent: "OpenAPI-Generator/1.0.0/go", + Debug: false, + Region: "test_region", + Servers: config.ServerConfigurations{ + { + URL: testServer.URL, + Description: "Localhost for resourcemanager_DefaultApi", + Variables: map[string]config.ServerVariable{ + "region": { + DefaultValue: "test_region.", + EnumValues: []string{ + "test_region.", + }, + }, + }, + }, + }, + OperationServers: map[string]config.ServerConfigurations{}, + } + apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication()) + if err != nil { + t.Fatalf("creating API client: %v", err) + } + + containerId := containerIdValue + + reqErr := apiClient.DeleteFolder(context.Background(), containerId).Execute() + + if reqErr != nil { + t.Fatalf("error in call: %v", reqErr) + } + }) + + t.Run("Test DefaultApiService DeleteFolderLabels", func(t *testing.T) { + _apiUrlPath := "/v2/folders/{containerId}/labels" + containerIdValue := "containerId" + _apiUrlPath = strings.Replace(_apiUrlPath, "{"+"containerId"+"}", url.PathEscape(ParameterValueToString(containerIdValue, "containerId")), -1) + + testDefaultApiServeMux := http.NewServeMux() + testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) { + }) + testServer := httptest.NewServer(testDefaultApiServeMux) + defer testServer.Close() + + configuration := &config.Configuration{ + DefaultHeader: make(map[string]string), + UserAgent: "OpenAPI-Generator/1.0.0/go", + Debug: false, + Region: "test_region", + Servers: config.ServerConfigurations{ + { + URL: testServer.URL, + Description: "Localhost for resourcemanager_DefaultApi", + Variables: map[string]config.ServerVariable{ + "region": { + DefaultValue: "test_region.", + EnumValues: []string{ + "test_region.", + }, + }, + }, + }, + }, + OperationServers: map[string]config.ServerConfigurations{}, + } + apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication()) + if err != nil { + t.Fatalf("creating API client: %v", err) + } + + containerId := containerIdValue + + reqErr := apiClient.DeleteFolderLabels(context.Background(), containerId).Execute() + + if reqErr != nil { + t.Fatalf("error in call: %v", reqErr) + } + }) + t.Run("Test DefaultApiService DeleteProject", func(t *testing.T) { _apiUrlPath := "/v2/projects/{id}" idValue := "id" @@ -117,6 +257,58 @@ func Test_resourcemanager_DefaultApiService(t *testing.T) { } }) + t.Run("Test DefaultApiService GetFolderDetails", func(t *testing.T) { + _apiUrlPath := "/v2/folders/{containerId}" + containerIdValue := "containerId" + _apiUrlPath = strings.Replace(_apiUrlPath, "{"+"containerId"+"}", url.PathEscape(ParameterValueToString(containerIdValue, "containerId")), -1) + + testDefaultApiServeMux := http.NewServeMux() + testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) { + data := GetFolderDetailsResponse{} + w.Header().Add("Content-Type", "application/json") + json.NewEncoder(w).Encode(data) + }) + testServer := httptest.NewServer(testDefaultApiServeMux) + defer testServer.Close() + + configuration := &config.Configuration{ + DefaultHeader: make(map[string]string), + UserAgent: "OpenAPI-Generator/1.0.0/go", + Debug: false, + Region: "test_region", + Servers: config.ServerConfigurations{ + { + URL: testServer.URL, + Description: "Localhost for resourcemanager_DefaultApi", + Variables: map[string]config.ServerVariable{ + "region": { + DefaultValue: "test_region.", + EnumValues: []string{ + "test_region.", + }, + }, + }, + }, + }, + OperationServers: map[string]config.ServerConfigurations{}, + } + apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication()) + if err != nil { + t.Fatalf("creating API client: %v", err) + } + + containerId := containerIdValue + + resp, reqErr := apiClient.GetFolderDetails(context.Background(), containerId).Execute() + + if reqErr != nil { + t.Fatalf("error in call: %v", reqErr) + } + if IsNil(resp) { + t.Fatalf("response not present") + } + }) + t.Run("Test DefaultApiService GetOrganization", func(t *testing.T) { _apiUrlPath := "/v2/organizations/{id}" idValue := "id" @@ -317,6 +509,58 @@ func Test_resourcemanager_DefaultApiService(t *testing.T) { } }) + t.Run("Test DefaultApiService PartialUpdateFolder", func(t *testing.T) { + _apiUrlPath := "/v2/folders/{containerId}" + containerIdValue := "containerId" + _apiUrlPath = strings.Replace(_apiUrlPath, "{"+"containerId"+"}", url.PathEscape(ParameterValueToString(containerIdValue, "containerId")), -1) + + testDefaultApiServeMux := http.NewServeMux() + testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) { + data := FolderResponse{} + w.Header().Add("Content-Type", "application/json") + json.NewEncoder(w).Encode(data) + }) + testServer := httptest.NewServer(testDefaultApiServeMux) + defer testServer.Close() + + configuration := &config.Configuration{ + DefaultHeader: make(map[string]string), + UserAgent: "OpenAPI-Generator/1.0.0/go", + Debug: false, + Region: "test_region", + Servers: config.ServerConfigurations{ + { + URL: testServer.URL, + Description: "Localhost for resourcemanager_DefaultApi", + Variables: map[string]config.ServerVariable{ + "region": { + DefaultValue: "test_region.", + EnumValues: []string{ + "test_region.", + }, + }, + }, + }, + }, + OperationServers: map[string]config.ServerConfigurations{}, + } + apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication()) + if err != nil { + t.Fatalf("creating API client: %v", err) + } + + containerId := containerIdValue + + resp, reqErr := apiClient.PartialUpdateFolder(context.Background(), containerId).Execute() + + if reqErr != nil { + t.Fatalf("error in call: %v", reqErr) + } + if IsNil(resp) { + t.Fatalf("response not present") + } + }) + t.Run("Test DefaultApiService PartialUpdateProject", func(t *testing.T) { _apiUrlPath := "/v2/projects/{id}" idValue := "id" diff --git a/services/resourcemanager/model_create_folder_payload.go b/services/resourcemanager/model_create_folder_payload.go new file mode 100644 index 000000000..efcaacfdb --- /dev/null +++ b/services/resourcemanager/model_create_folder_payload.go @@ -0,0 +1,268 @@ +/* +Resource Manager API + +API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists + +API version: 2.0 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package resourcemanager + +import ( + "encoding/json" +) + +// checks if the CreateFolderPayload type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &CreateFolderPayload{} + +/* + types and functions for containerParentId +*/ + +// isNotNullableString +type CreateFolderPayloadGetContainerParentIdAttributeType = *string + +func getCreateFolderPayloadGetContainerParentIdAttributeTypeOk(arg CreateFolderPayloadGetContainerParentIdAttributeType) (ret CreateFolderPayloadGetContainerParentIdRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setCreateFolderPayloadGetContainerParentIdAttributeType(arg *CreateFolderPayloadGetContainerParentIdAttributeType, val CreateFolderPayloadGetContainerParentIdRetType) { + *arg = &val +} + +type CreateFolderPayloadGetContainerParentIdArgType = string +type CreateFolderPayloadGetContainerParentIdRetType = string + +/* + types and functions for labels +*/ + +// isContainer +type CreateFolderPayloadGetLabelsAttributeType = *map[string]string +type CreateFolderPayloadGetLabelsArgType = map[string]string +type CreateFolderPayloadGetLabelsRetType = map[string]string + +func getCreateFolderPayloadGetLabelsAttributeTypeOk(arg CreateFolderPayloadGetLabelsAttributeType) (ret CreateFolderPayloadGetLabelsRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setCreateFolderPayloadGetLabelsAttributeType(arg *CreateFolderPayloadGetLabelsAttributeType, val CreateFolderPayloadGetLabelsRetType) { + *arg = &val +} + +/* + types and functions for members +*/ + +// isArray +type CreateFolderPayloadGetMembersAttributeType = *[]Member +type CreateFolderPayloadGetMembersArgType = []Member +type CreateFolderPayloadGetMembersRetType = []Member + +func getCreateFolderPayloadGetMembersAttributeTypeOk(arg CreateFolderPayloadGetMembersAttributeType) (ret CreateFolderPayloadGetMembersRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setCreateFolderPayloadGetMembersAttributeType(arg *CreateFolderPayloadGetMembersAttributeType, val CreateFolderPayloadGetMembersRetType) { + *arg = &val +} + +/* + types and functions for name +*/ + +// isNotNullableString +type CreateFolderPayloadGetNameAttributeType = *string + +func getCreateFolderPayloadGetNameAttributeTypeOk(arg CreateFolderPayloadGetNameAttributeType) (ret CreateFolderPayloadGetNameRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setCreateFolderPayloadGetNameAttributeType(arg *CreateFolderPayloadGetNameAttributeType, val CreateFolderPayloadGetNameRetType) { + *arg = &val +} + +type CreateFolderPayloadGetNameArgType = string +type CreateFolderPayloadGetNameRetType = string + +// CreateFolderPayload struct for CreateFolderPayload +type CreateFolderPayload struct { + // Identifier of the parent resource container - containerId as well as UUID identifier is supported. + // REQUIRED + ContainerParentId CreateFolderPayloadGetContainerParentIdAttributeType `json:"containerParentId"` + // Labels are key-value string pairs that can be attached to a resource container. Some labels may be enforced via policies. - A label key must match the regex `[A-ZÄÜÖa-zäüöß0-9_-]{1,64}`. - A label value must match the regex `^$|[A-ZÄÜÖa-zäüöß0-9_-]{1,64}`. + Labels CreateFolderPayloadGetLabelsAttributeType `json:"labels,omitempty"` + // The initial members assigned to the project. At least one subject needs to be a user, and not a client or service account. + Members CreateFolderPayloadGetMembersAttributeType `json:"members,omitempty"` + // The name of the folder matching the regex `^[a-zA-ZäüöÄÜÖ0-9]( ?[a-zA-ZäüöÄÜÖß0-9_+&-]){0,39}$`. + // REQUIRED + Name CreateFolderPayloadGetNameAttributeType `json:"name"` +} + +type _CreateFolderPayload CreateFolderPayload + +// NewCreateFolderPayload instantiates a new CreateFolderPayload 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 NewCreateFolderPayload(containerParentId CreateFolderPayloadGetContainerParentIdArgType, name CreateFolderPayloadGetNameArgType) *CreateFolderPayload { + this := CreateFolderPayload{} + setCreateFolderPayloadGetContainerParentIdAttributeType(&this.ContainerParentId, containerParentId) + setCreateFolderPayloadGetNameAttributeType(&this.Name, name) + return &this +} + +// NewCreateFolderPayloadWithDefaults instantiates a new CreateFolderPayload 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 NewCreateFolderPayloadWithDefaults() *CreateFolderPayload { + this := CreateFolderPayload{} + return &this +} + +// GetContainerParentId returns the ContainerParentId field value +func (o *CreateFolderPayload) GetContainerParentId() (ret CreateFolderPayloadGetContainerParentIdRetType) { + ret, _ = o.GetContainerParentIdOk() + return ret +} + +// GetContainerParentIdOk returns a tuple with the ContainerParentId field value +// and a boolean to check if the value has been set. +func (o *CreateFolderPayload) GetContainerParentIdOk() (ret CreateFolderPayloadGetContainerParentIdRetType, ok bool) { + return getCreateFolderPayloadGetContainerParentIdAttributeTypeOk(o.ContainerParentId) +} + +// SetContainerParentId sets field value +func (o *CreateFolderPayload) SetContainerParentId(v CreateFolderPayloadGetContainerParentIdRetType) { + setCreateFolderPayloadGetContainerParentIdAttributeType(&o.ContainerParentId, v) +} + +// GetLabels returns the Labels field value if set, zero value otherwise. +func (o *CreateFolderPayload) GetLabels() (res CreateFolderPayloadGetLabelsRetType) { + res, _ = o.GetLabelsOk() + return +} + +// GetLabelsOk returns a tuple with the Labels field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CreateFolderPayload) GetLabelsOk() (ret CreateFolderPayloadGetLabelsRetType, ok bool) { + return getCreateFolderPayloadGetLabelsAttributeTypeOk(o.Labels) +} + +// HasLabels returns a boolean if a field has been set. +func (o *CreateFolderPayload) HasLabels() bool { + _, ok := o.GetLabelsOk() + return ok +} + +// SetLabels gets a reference to the given map[string]string and assigns it to the Labels field. +func (o *CreateFolderPayload) SetLabels(v CreateFolderPayloadGetLabelsRetType) { + setCreateFolderPayloadGetLabelsAttributeType(&o.Labels, v) +} + +// GetMembers returns the Members field value if set, zero value otherwise. +func (o *CreateFolderPayload) GetMembers() (res CreateFolderPayloadGetMembersRetType) { + res, _ = o.GetMembersOk() + return +} + +// GetMembersOk returns a tuple with the Members field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CreateFolderPayload) GetMembersOk() (ret CreateFolderPayloadGetMembersRetType, ok bool) { + return getCreateFolderPayloadGetMembersAttributeTypeOk(o.Members) +} + +// HasMembers returns a boolean if a field has been set. +func (o *CreateFolderPayload) HasMembers() bool { + _, ok := o.GetMembersOk() + return ok +} + +// SetMembers gets a reference to the given []Member and assigns it to the Members field. +func (o *CreateFolderPayload) SetMembers(v CreateFolderPayloadGetMembersRetType) { + setCreateFolderPayloadGetMembersAttributeType(&o.Members, v) +} + +// GetName returns the Name field value +func (o *CreateFolderPayload) GetName() (ret CreateFolderPayloadGetNameRetType) { + ret, _ = o.GetNameOk() + return ret +} + +// GetNameOk returns a tuple with the Name field value +// and a boolean to check if the value has been set. +func (o *CreateFolderPayload) GetNameOk() (ret CreateFolderPayloadGetNameRetType, ok bool) { + return getCreateFolderPayloadGetNameAttributeTypeOk(o.Name) +} + +// SetName sets field value +func (o *CreateFolderPayload) SetName(v CreateFolderPayloadGetNameRetType) { + setCreateFolderPayloadGetNameAttributeType(&o.Name, v) +} + +func (o CreateFolderPayload) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + if val, ok := getCreateFolderPayloadGetContainerParentIdAttributeTypeOk(o.ContainerParentId); ok { + toSerialize["ContainerParentId"] = val + } + if val, ok := getCreateFolderPayloadGetLabelsAttributeTypeOk(o.Labels); ok { + toSerialize["Labels"] = val + } + if val, ok := getCreateFolderPayloadGetMembersAttributeTypeOk(o.Members); ok { + toSerialize["Members"] = val + } + if val, ok := getCreateFolderPayloadGetNameAttributeTypeOk(o.Name); ok { + toSerialize["Name"] = val + } + return toSerialize, nil +} + +type NullableCreateFolderPayload struct { + value *CreateFolderPayload + isSet bool +} + +func (v NullableCreateFolderPayload) Get() *CreateFolderPayload { + return v.value +} + +func (v *NullableCreateFolderPayload) Set(val *CreateFolderPayload) { + v.value = val + v.isSet = true +} + +func (v NullableCreateFolderPayload) IsSet() bool { + return v.isSet +} + +func (v *NullableCreateFolderPayload) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableCreateFolderPayload(val *CreateFolderPayload) *NullableCreateFolderPayload { + return &NullableCreateFolderPayload{value: val, isSet: true} +} + +func (v NullableCreateFolderPayload) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableCreateFolderPayload) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/resourcemanager/model_folder_response.go b/services/resourcemanager/model_folder_response.go new file mode 100644 index 000000000..7ddadd046 --- /dev/null +++ b/services/resourcemanager/model_folder_response.go @@ -0,0 +1,397 @@ +/* +Resource Manager API + +API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists + +API version: 2.0 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package resourcemanager + +import ( + "encoding/json" + "time" +) + +// checks if the FolderResponse type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &FolderResponse{} + +/* + types and functions for containerId +*/ + +// isNotNullableString +type FolderResponseGetContainerIdAttributeType = *string + +func getFolderResponseGetContainerIdAttributeTypeOk(arg FolderResponseGetContainerIdAttributeType) (ret FolderResponseGetContainerIdRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setFolderResponseGetContainerIdAttributeType(arg *FolderResponseGetContainerIdAttributeType, val FolderResponseGetContainerIdRetType) { + *arg = &val +} + +type FolderResponseGetContainerIdArgType = string +type FolderResponseGetContainerIdRetType = string + +/* + types and functions for creationTime +*/ + +// isDateTime +type FolderResponseGetCreationTimeAttributeType = *time.Time +type FolderResponseGetCreationTimeArgType = time.Time +type FolderResponseGetCreationTimeRetType = time.Time + +func getFolderResponseGetCreationTimeAttributeTypeOk(arg FolderResponseGetCreationTimeAttributeType) (ret FolderResponseGetCreationTimeRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setFolderResponseGetCreationTimeAttributeType(arg *FolderResponseGetCreationTimeAttributeType, val FolderResponseGetCreationTimeRetType) { + *arg = &val +} + +/* + types and functions for folderId +*/ + +// isNotNullableString +type FolderResponseGetFolderIdAttributeType = *string + +func getFolderResponseGetFolderIdAttributeTypeOk(arg FolderResponseGetFolderIdAttributeType) (ret FolderResponseGetFolderIdRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setFolderResponseGetFolderIdAttributeType(arg *FolderResponseGetFolderIdAttributeType, val FolderResponseGetFolderIdRetType) { + *arg = &val +} + +type FolderResponseGetFolderIdArgType = string +type FolderResponseGetFolderIdRetType = string + +/* + types and functions for labels +*/ + +// isContainer +type FolderResponseGetLabelsAttributeType = *map[string]string +type FolderResponseGetLabelsArgType = map[string]string +type FolderResponseGetLabelsRetType = map[string]string + +func getFolderResponseGetLabelsAttributeTypeOk(arg FolderResponseGetLabelsAttributeType) (ret FolderResponseGetLabelsRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setFolderResponseGetLabelsAttributeType(arg *FolderResponseGetLabelsAttributeType, val FolderResponseGetLabelsRetType) { + *arg = &val +} + +/* + types and functions for name +*/ + +// isNotNullableString +type FolderResponseGetNameAttributeType = *string + +func getFolderResponseGetNameAttributeTypeOk(arg FolderResponseGetNameAttributeType) (ret FolderResponseGetNameRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setFolderResponseGetNameAttributeType(arg *FolderResponseGetNameAttributeType, val FolderResponseGetNameRetType) { + *arg = &val +} + +type FolderResponseGetNameArgType = string +type FolderResponseGetNameRetType = string + +/* + types and functions for parent +*/ + +// isModel +type FolderResponseGetParentAttributeType = *Parent +type FolderResponseGetParentArgType = Parent +type FolderResponseGetParentRetType = Parent + +func getFolderResponseGetParentAttributeTypeOk(arg FolderResponseGetParentAttributeType) (ret FolderResponseGetParentRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setFolderResponseGetParentAttributeType(arg *FolderResponseGetParentAttributeType, val FolderResponseGetParentRetType) { + *arg = &val +} + +/* + types and functions for updateTime +*/ + +// isDateTime +type FolderResponseGetUpdateTimeAttributeType = *time.Time +type FolderResponseGetUpdateTimeArgType = time.Time +type FolderResponseGetUpdateTimeRetType = time.Time + +func getFolderResponseGetUpdateTimeAttributeTypeOk(arg FolderResponseGetUpdateTimeAttributeType) (ret FolderResponseGetUpdateTimeRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setFolderResponseGetUpdateTimeAttributeType(arg *FolderResponseGetUpdateTimeAttributeType, val FolderResponseGetUpdateTimeRetType) { + *arg = &val +} + +// FolderResponse struct for FolderResponse +type FolderResponse struct { + // Globally unique, user-friendly identifier. + // REQUIRED + ContainerId FolderResponseGetContainerIdAttributeType `json:"containerId"` + // Timestamp at which the folder was created. + // REQUIRED + CreationTime FolderResponseGetCreationTimeAttributeType `json:"creationTime"` + // Globally unique folder identifier. + // REQUIRED + FolderId FolderResponseGetFolderIdAttributeType `json:"folderId"` + // Labels are key-value string pairs that can be attached to a resource container. Some labels may be enforced via policies. - A label key must match the regex `[A-ZÄÜÖa-zäüöß0-9_-]{1,64}`. - A label value must match the regex `^$|[A-ZÄÜÖa-zäüöß0-9_-]{1,64}`. + Labels FolderResponseGetLabelsAttributeType `json:"labels,omitempty"` + // Folder name. + // REQUIRED + Name FolderResponseGetNameAttributeType `json:"name"` + // REQUIRED + Parent FolderResponseGetParentAttributeType `json:"parent"` + // Timestamp at which the folder was last modified. + // REQUIRED + UpdateTime FolderResponseGetUpdateTimeAttributeType `json:"updateTime"` +} + +type _FolderResponse FolderResponse + +// NewFolderResponse instantiates a new FolderResponse 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 NewFolderResponse(containerId FolderResponseGetContainerIdArgType, creationTime FolderResponseGetCreationTimeArgType, folderId FolderResponseGetFolderIdArgType, name FolderResponseGetNameArgType, parent FolderResponseGetParentArgType, updateTime FolderResponseGetUpdateTimeArgType) *FolderResponse { + this := FolderResponse{} + setFolderResponseGetContainerIdAttributeType(&this.ContainerId, containerId) + setFolderResponseGetCreationTimeAttributeType(&this.CreationTime, creationTime) + setFolderResponseGetFolderIdAttributeType(&this.FolderId, folderId) + setFolderResponseGetNameAttributeType(&this.Name, name) + setFolderResponseGetParentAttributeType(&this.Parent, parent) + setFolderResponseGetUpdateTimeAttributeType(&this.UpdateTime, updateTime) + return &this +} + +// NewFolderResponseWithDefaults instantiates a new FolderResponse 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 NewFolderResponseWithDefaults() *FolderResponse { + this := FolderResponse{} + return &this +} + +// GetContainerId returns the ContainerId field value +func (o *FolderResponse) GetContainerId() (ret FolderResponseGetContainerIdRetType) { + ret, _ = o.GetContainerIdOk() + return ret +} + +// GetContainerIdOk returns a tuple with the ContainerId field value +// and a boolean to check if the value has been set. +func (o *FolderResponse) GetContainerIdOk() (ret FolderResponseGetContainerIdRetType, ok bool) { + return getFolderResponseGetContainerIdAttributeTypeOk(o.ContainerId) +} + +// SetContainerId sets field value +func (o *FolderResponse) SetContainerId(v FolderResponseGetContainerIdRetType) { + setFolderResponseGetContainerIdAttributeType(&o.ContainerId, v) +} + +// GetCreationTime returns the CreationTime field value +func (o *FolderResponse) GetCreationTime() (ret FolderResponseGetCreationTimeRetType) { + ret, _ = o.GetCreationTimeOk() + return ret +} + +// GetCreationTimeOk returns a tuple with the CreationTime field value +// and a boolean to check if the value has been set. +func (o *FolderResponse) GetCreationTimeOk() (ret FolderResponseGetCreationTimeRetType, ok bool) { + return getFolderResponseGetCreationTimeAttributeTypeOk(o.CreationTime) +} + +// SetCreationTime sets field value +func (o *FolderResponse) SetCreationTime(v FolderResponseGetCreationTimeRetType) { + setFolderResponseGetCreationTimeAttributeType(&o.CreationTime, v) +} + +// GetFolderId returns the FolderId field value +func (o *FolderResponse) GetFolderId() (ret FolderResponseGetFolderIdRetType) { + ret, _ = o.GetFolderIdOk() + return ret +} + +// GetFolderIdOk returns a tuple with the FolderId field value +// and a boolean to check if the value has been set. +func (o *FolderResponse) GetFolderIdOk() (ret FolderResponseGetFolderIdRetType, ok bool) { + return getFolderResponseGetFolderIdAttributeTypeOk(o.FolderId) +} + +// SetFolderId sets field value +func (o *FolderResponse) SetFolderId(v FolderResponseGetFolderIdRetType) { + setFolderResponseGetFolderIdAttributeType(&o.FolderId, v) +} + +// GetLabels returns the Labels field value if set, zero value otherwise. +func (o *FolderResponse) GetLabels() (res FolderResponseGetLabelsRetType) { + res, _ = o.GetLabelsOk() + return +} + +// GetLabelsOk returns a tuple with the Labels field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *FolderResponse) GetLabelsOk() (ret FolderResponseGetLabelsRetType, ok bool) { + return getFolderResponseGetLabelsAttributeTypeOk(o.Labels) +} + +// HasLabels returns a boolean if a field has been set. +func (o *FolderResponse) HasLabels() bool { + _, ok := o.GetLabelsOk() + return ok +} + +// SetLabels gets a reference to the given map[string]string and assigns it to the Labels field. +func (o *FolderResponse) SetLabels(v FolderResponseGetLabelsRetType) { + setFolderResponseGetLabelsAttributeType(&o.Labels, v) +} + +// GetName returns the Name field value +func (o *FolderResponse) GetName() (ret FolderResponseGetNameRetType) { + ret, _ = o.GetNameOk() + return ret +} + +// GetNameOk returns a tuple with the Name field value +// and a boolean to check if the value has been set. +func (o *FolderResponse) GetNameOk() (ret FolderResponseGetNameRetType, ok bool) { + return getFolderResponseGetNameAttributeTypeOk(o.Name) +} + +// SetName sets field value +func (o *FolderResponse) SetName(v FolderResponseGetNameRetType) { + setFolderResponseGetNameAttributeType(&o.Name, v) +} + +// GetParent returns the Parent field value +func (o *FolderResponse) GetParent() (ret FolderResponseGetParentRetType) { + ret, _ = o.GetParentOk() + return ret +} + +// GetParentOk returns a tuple with the Parent field value +// and a boolean to check if the value has been set. +func (o *FolderResponse) GetParentOk() (ret FolderResponseGetParentRetType, ok bool) { + return getFolderResponseGetParentAttributeTypeOk(o.Parent) +} + +// SetParent sets field value +func (o *FolderResponse) SetParent(v FolderResponseGetParentRetType) { + setFolderResponseGetParentAttributeType(&o.Parent, v) +} + +// GetUpdateTime returns the UpdateTime field value +func (o *FolderResponse) GetUpdateTime() (ret FolderResponseGetUpdateTimeRetType) { + ret, _ = o.GetUpdateTimeOk() + return ret +} + +// GetUpdateTimeOk returns a tuple with the UpdateTime field value +// and a boolean to check if the value has been set. +func (o *FolderResponse) GetUpdateTimeOk() (ret FolderResponseGetUpdateTimeRetType, ok bool) { + return getFolderResponseGetUpdateTimeAttributeTypeOk(o.UpdateTime) +} + +// SetUpdateTime sets field value +func (o *FolderResponse) SetUpdateTime(v FolderResponseGetUpdateTimeRetType) { + setFolderResponseGetUpdateTimeAttributeType(&o.UpdateTime, v) +} + +func (o FolderResponse) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + if val, ok := getFolderResponseGetContainerIdAttributeTypeOk(o.ContainerId); ok { + toSerialize["ContainerId"] = val + } + if val, ok := getFolderResponseGetCreationTimeAttributeTypeOk(o.CreationTime); ok { + toSerialize["CreationTime"] = val + } + if val, ok := getFolderResponseGetFolderIdAttributeTypeOk(o.FolderId); ok { + toSerialize["FolderId"] = val + } + if val, ok := getFolderResponseGetLabelsAttributeTypeOk(o.Labels); ok { + toSerialize["Labels"] = val + } + if val, ok := getFolderResponseGetNameAttributeTypeOk(o.Name); ok { + toSerialize["Name"] = val + } + if val, ok := getFolderResponseGetParentAttributeTypeOk(o.Parent); ok { + toSerialize["Parent"] = val + } + if val, ok := getFolderResponseGetUpdateTimeAttributeTypeOk(o.UpdateTime); ok { + toSerialize["UpdateTime"] = val + } + return toSerialize, nil +} + +type NullableFolderResponse struct { + value *FolderResponse + isSet bool +} + +func (v NullableFolderResponse) Get() *FolderResponse { + return v.value +} + +func (v *NullableFolderResponse) Set(val *FolderResponse) { + v.value = val + v.isSet = true +} + +func (v NullableFolderResponse) IsSet() bool { + return v.isSet +} + +func (v *NullableFolderResponse) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableFolderResponse(val *FolderResponse) *NullableFolderResponse { + return &NullableFolderResponse{value: val, isSet: true} +} + +func (v NullableFolderResponse) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableFolderResponse) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/resourcemanager/model_get_folder_details_response.go b/services/resourcemanager/model_get_folder_details_response.go new file mode 100644 index 000000000..5d4e35b04 --- /dev/null +++ b/services/resourcemanager/model_get_folder_details_response.go @@ -0,0 +1,444 @@ +/* +Resource Manager API + +API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists + +API version: 2.0 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package resourcemanager + +import ( + "encoding/json" + "time" +) + +// checks if the GetFolderDetailsResponse type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &GetFolderDetailsResponse{} + +/* + types and functions for containerId +*/ + +// isNotNullableString +type GetFolderDetailsResponseGetContainerIdAttributeType = *string + +func getGetFolderDetailsResponseGetContainerIdAttributeTypeOk(arg GetFolderDetailsResponseGetContainerIdAttributeType) (ret GetFolderDetailsResponseGetContainerIdRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setGetFolderDetailsResponseGetContainerIdAttributeType(arg *GetFolderDetailsResponseGetContainerIdAttributeType, val GetFolderDetailsResponseGetContainerIdRetType) { + *arg = &val +} + +type GetFolderDetailsResponseGetContainerIdArgType = string +type GetFolderDetailsResponseGetContainerIdRetType = string + +/* + types and functions for creationTime +*/ + +// isDateTime +type GetFolderDetailsResponseGetCreationTimeAttributeType = *time.Time +type GetFolderDetailsResponseGetCreationTimeArgType = time.Time +type GetFolderDetailsResponseGetCreationTimeRetType = time.Time + +func getGetFolderDetailsResponseGetCreationTimeAttributeTypeOk(arg GetFolderDetailsResponseGetCreationTimeAttributeType) (ret GetFolderDetailsResponseGetCreationTimeRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setGetFolderDetailsResponseGetCreationTimeAttributeType(arg *GetFolderDetailsResponseGetCreationTimeAttributeType, val GetFolderDetailsResponseGetCreationTimeRetType) { + *arg = &val +} + +/* + types and functions for folderId +*/ + +// isNotNullableString +type GetFolderDetailsResponseGetFolderIdAttributeType = *string + +func getGetFolderDetailsResponseGetFolderIdAttributeTypeOk(arg GetFolderDetailsResponseGetFolderIdAttributeType) (ret GetFolderDetailsResponseGetFolderIdRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setGetFolderDetailsResponseGetFolderIdAttributeType(arg *GetFolderDetailsResponseGetFolderIdAttributeType, val GetFolderDetailsResponseGetFolderIdRetType) { + *arg = &val +} + +type GetFolderDetailsResponseGetFolderIdArgType = string +type GetFolderDetailsResponseGetFolderIdRetType = string + +/* + types and functions for labels +*/ + +// isContainer +type GetFolderDetailsResponseGetLabelsAttributeType = *map[string]string +type GetFolderDetailsResponseGetLabelsArgType = map[string]string +type GetFolderDetailsResponseGetLabelsRetType = map[string]string + +func getGetFolderDetailsResponseGetLabelsAttributeTypeOk(arg GetFolderDetailsResponseGetLabelsAttributeType) (ret GetFolderDetailsResponseGetLabelsRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setGetFolderDetailsResponseGetLabelsAttributeType(arg *GetFolderDetailsResponseGetLabelsAttributeType, val GetFolderDetailsResponseGetLabelsRetType) { + *arg = &val +} + +/* + types and functions for name +*/ + +// isNotNullableString +type GetFolderDetailsResponseGetNameAttributeType = *string + +func getGetFolderDetailsResponseGetNameAttributeTypeOk(arg GetFolderDetailsResponseGetNameAttributeType) (ret GetFolderDetailsResponseGetNameRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setGetFolderDetailsResponseGetNameAttributeType(arg *GetFolderDetailsResponseGetNameAttributeType, val GetFolderDetailsResponseGetNameRetType) { + *arg = &val +} + +type GetFolderDetailsResponseGetNameArgType = string +type GetFolderDetailsResponseGetNameRetType = string + +/* + types and functions for parent +*/ + +// isModel +type GetFolderDetailsResponseGetParentAttributeType = *Parent +type GetFolderDetailsResponseGetParentArgType = Parent +type GetFolderDetailsResponseGetParentRetType = Parent + +func getGetFolderDetailsResponseGetParentAttributeTypeOk(arg GetFolderDetailsResponseGetParentAttributeType) (ret GetFolderDetailsResponseGetParentRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setGetFolderDetailsResponseGetParentAttributeType(arg *GetFolderDetailsResponseGetParentAttributeType, val GetFolderDetailsResponseGetParentRetType) { + *arg = &val +} + +/* + types and functions for parents +*/ + +// isArray +type GetFolderDetailsResponseGetParentsAttributeType = *[]ParentListInner +type GetFolderDetailsResponseGetParentsArgType = []ParentListInner +type GetFolderDetailsResponseGetParentsRetType = []ParentListInner + +func getGetFolderDetailsResponseGetParentsAttributeTypeOk(arg GetFolderDetailsResponseGetParentsAttributeType) (ret GetFolderDetailsResponseGetParentsRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setGetFolderDetailsResponseGetParentsAttributeType(arg *GetFolderDetailsResponseGetParentsAttributeType, val GetFolderDetailsResponseGetParentsRetType) { + *arg = &val +} + +/* + types and functions for updateTime +*/ + +// isDateTime +type GetFolderDetailsResponseGetUpdateTimeAttributeType = *time.Time +type GetFolderDetailsResponseGetUpdateTimeArgType = time.Time +type GetFolderDetailsResponseGetUpdateTimeRetType = time.Time + +func getGetFolderDetailsResponseGetUpdateTimeAttributeTypeOk(arg GetFolderDetailsResponseGetUpdateTimeAttributeType) (ret GetFolderDetailsResponseGetUpdateTimeRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setGetFolderDetailsResponseGetUpdateTimeAttributeType(arg *GetFolderDetailsResponseGetUpdateTimeAttributeType, val GetFolderDetailsResponseGetUpdateTimeRetType) { + *arg = &val +} + +// GetFolderDetailsResponse struct for GetFolderDetailsResponse +type GetFolderDetailsResponse struct { + // Globally unique user-friendly identifier. + // REQUIRED + ContainerId GetFolderDetailsResponseGetContainerIdAttributeType `json:"containerId"` + // Timestamp at which the folder was created. + // REQUIRED + CreationTime GetFolderDetailsResponseGetCreationTimeAttributeType `json:"creationTime"` + // Globally unique folder identifier. + // REQUIRED + FolderId GetFolderDetailsResponseGetFolderIdAttributeType `json:"folderId"` + // Labels are key-value string pairs that can be attached to a resource container. Some labels may be enforced via policies. - A label key must match the regex `[A-ZÄÜÖa-zäüöß0-9_-]{1,64}`. - A label value must match the regex `^$|[A-ZÄÜÖa-zäüöß0-9_-]{1,64}`. + Labels GetFolderDetailsResponseGetLabelsAttributeType `json:"labels,omitempty"` + // Folder name. + // REQUIRED + Name GetFolderDetailsResponseGetNameAttributeType `json:"name"` + // REQUIRED + Parent GetFolderDetailsResponseGetParentAttributeType `json:"parent"` + Parents GetFolderDetailsResponseGetParentsAttributeType `json:"parents,omitempty"` + // Timestamp at which the folder was last modified. + // REQUIRED + UpdateTime GetFolderDetailsResponseGetUpdateTimeAttributeType `json:"updateTime"` +} + +type _GetFolderDetailsResponse GetFolderDetailsResponse + +// NewGetFolderDetailsResponse instantiates a new GetFolderDetailsResponse 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 NewGetFolderDetailsResponse(containerId GetFolderDetailsResponseGetContainerIdArgType, creationTime GetFolderDetailsResponseGetCreationTimeArgType, folderId GetFolderDetailsResponseGetFolderIdArgType, name GetFolderDetailsResponseGetNameArgType, parent GetFolderDetailsResponseGetParentArgType, updateTime GetFolderDetailsResponseGetUpdateTimeArgType) *GetFolderDetailsResponse { + this := GetFolderDetailsResponse{} + setGetFolderDetailsResponseGetContainerIdAttributeType(&this.ContainerId, containerId) + setGetFolderDetailsResponseGetCreationTimeAttributeType(&this.CreationTime, creationTime) + setGetFolderDetailsResponseGetFolderIdAttributeType(&this.FolderId, folderId) + setGetFolderDetailsResponseGetNameAttributeType(&this.Name, name) + setGetFolderDetailsResponseGetParentAttributeType(&this.Parent, parent) + setGetFolderDetailsResponseGetUpdateTimeAttributeType(&this.UpdateTime, updateTime) + return &this +} + +// NewGetFolderDetailsResponseWithDefaults instantiates a new GetFolderDetailsResponse 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 NewGetFolderDetailsResponseWithDefaults() *GetFolderDetailsResponse { + this := GetFolderDetailsResponse{} + return &this +} + +// GetContainerId returns the ContainerId field value +func (o *GetFolderDetailsResponse) GetContainerId() (ret GetFolderDetailsResponseGetContainerIdRetType) { + ret, _ = o.GetContainerIdOk() + return ret +} + +// GetContainerIdOk returns a tuple with the ContainerId field value +// and a boolean to check if the value has been set. +func (o *GetFolderDetailsResponse) GetContainerIdOk() (ret GetFolderDetailsResponseGetContainerIdRetType, ok bool) { + return getGetFolderDetailsResponseGetContainerIdAttributeTypeOk(o.ContainerId) +} + +// SetContainerId sets field value +func (o *GetFolderDetailsResponse) SetContainerId(v GetFolderDetailsResponseGetContainerIdRetType) { + setGetFolderDetailsResponseGetContainerIdAttributeType(&o.ContainerId, v) +} + +// GetCreationTime returns the CreationTime field value +func (o *GetFolderDetailsResponse) GetCreationTime() (ret GetFolderDetailsResponseGetCreationTimeRetType) { + ret, _ = o.GetCreationTimeOk() + return ret +} + +// GetCreationTimeOk returns a tuple with the CreationTime field value +// and a boolean to check if the value has been set. +func (o *GetFolderDetailsResponse) GetCreationTimeOk() (ret GetFolderDetailsResponseGetCreationTimeRetType, ok bool) { + return getGetFolderDetailsResponseGetCreationTimeAttributeTypeOk(o.CreationTime) +} + +// SetCreationTime sets field value +func (o *GetFolderDetailsResponse) SetCreationTime(v GetFolderDetailsResponseGetCreationTimeRetType) { + setGetFolderDetailsResponseGetCreationTimeAttributeType(&o.CreationTime, v) +} + +// GetFolderId returns the FolderId field value +func (o *GetFolderDetailsResponse) GetFolderId() (ret GetFolderDetailsResponseGetFolderIdRetType) { + ret, _ = o.GetFolderIdOk() + return ret +} + +// GetFolderIdOk returns a tuple with the FolderId field value +// and a boolean to check if the value has been set. +func (o *GetFolderDetailsResponse) GetFolderIdOk() (ret GetFolderDetailsResponseGetFolderIdRetType, ok bool) { + return getGetFolderDetailsResponseGetFolderIdAttributeTypeOk(o.FolderId) +} + +// SetFolderId sets field value +func (o *GetFolderDetailsResponse) SetFolderId(v GetFolderDetailsResponseGetFolderIdRetType) { + setGetFolderDetailsResponseGetFolderIdAttributeType(&o.FolderId, v) +} + +// GetLabels returns the Labels field value if set, zero value otherwise. +func (o *GetFolderDetailsResponse) GetLabels() (res GetFolderDetailsResponseGetLabelsRetType) { + res, _ = o.GetLabelsOk() + return +} + +// GetLabelsOk returns a tuple with the Labels field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *GetFolderDetailsResponse) GetLabelsOk() (ret GetFolderDetailsResponseGetLabelsRetType, ok bool) { + return getGetFolderDetailsResponseGetLabelsAttributeTypeOk(o.Labels) +} + +// HasLabels returns a boolean if a field has been set. +func (o *GetFolderDetailsResponse) HasLabels() bool { + _, ok := o.GetLabelsOk() + return ok +} + +// SetLabels gets a reference to the given map[string]string and assigns it to the Labels field. +func (o *GetFolderDetailsResponse) SetLabels(v GetFolderDetailsResponseGetLabelsRetType) { + setGetFolderDetailsResponseGetLabelsAttributeType(&o.Labels, v) +} + +// GetName returns the Name field value +func (o *GetFolderDetailsResponse) GetName() (ret GetFolderDetailsResponseGetNameRetType) { + ret, _ = o.GetNameOk() + return ret +} + +// GetNameOk returns a tuple with the Name field value +// and a boolean to check if the value has been set. +func (o *GetFolderDetailsResponse) GetNameOk() (ret GetFolderDetailsResponseGetNameRetType, ok bool) { + return getGetFolderDetailsResponseGetNameAttributeTypeOk(o.Name) +} + +// SetName sets field value +func (o *GetFolderDetailsResponse) SetName(v GetFolderDetailsResponseGetNameRetType) { + setGetFolderDetailsResponseGetNameAttributeType(&o.Name, v) +} + +// GetParent returns the Parent field value +func (o *GetFolderDetailsResponse) GetParent() (ret GetFolderDetailsResponseGetParentRetType) { + ret, _ = o.GetParentOk() + return ret +} + +// GetParentOk returns a tuple with the Parent field value +// and a boolean to check if the value has been set. +func (o *GetFolderDetailsResponse) GetParentOk() (ret GetFolderDetailsResponseGetParentRetType, ok bool) { + return getGetFolderDetailsResponseGetParentAttributeTypeOk(o.Parent) +} + +// SetParent sets field value +func (o *GetFolderDetailsResponse) SetParent(v GetFolderDetailsResponseGetParentRetType) { + setGetFolderDetailsResponseGetParentAttributeType(&o.Parent, v) +} + +// GetParents returns the Parents field value if set, zero value otherwise. +func (o *GetFolderDetailsResponse) GetParents() (res GetFolderDetailsResponseGetParentsRetType) { + res, _ = o.GetParentsOk() + return +} + +// GetParentsOk returns a tuple with the Parents field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *GetFolderDetailsResponse) GetParentsOk() (ret GetFolderDetailsResponseGetParentsRetType, ok bool) { + return getGetFolderDetailsResponseGetParentsAttributeTypeOk(o.Parents) +} + +// HasParents returns a boolean if a field has been set. +func (o *GetFolderDetailsResponse) HasParents() bool { + _, ok := o.GetParentsOk() + return ok +} + +// SetParents gets a reference to the given []ParentListInner and assigns it to the Parents field. +func (o *GetFolderDetailsResponse) SetParents(v GetFolderDetailsResponseGetParentsRetType) { + setGetFolderDetailsResponseGetParentsAttributeType(&o.Parents, v) +} + +// GetUpdateTime returns the UpdateTime field value +func (o *GetFolderDetailsResponse) GetUpdateTime() (ret GetFolderDetailsResponseGetUpdateTimeRetType) { + ret, _ = o.GetUpdateTimeOk() + return ret +} + +// GetUpdateTimeOk returns a tuple with the UpdateTime field value +// and a boolean to check if the value has been set. +func (o *GetFolderDetailsResponse) GetUpdateTimeOk() (ret GetFolderDetailsResponseGetUpdateTimeRetType, ok bool) { + return getGetFolderDetailsResponseGetUpdateTimeAttributeTypeOk(o.UpdateTime) +} + +// SetUpdateTime sets field value +func (o *GetFolderDetailsResponse) SetUpdateTime(v GetFolderDetailsResponseGetUpdateTimeRetType) { + setGetFolderDetailsResponseGetUpdateTimeAttributeType(&o.UpdateTime, v) +} + +func (o GetFolderDetailsResponse) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + if val, ok := getGetFolderDetailsResponseGetContainerIdAttributeTypeOk(o.ContainerId); ok { + toSerialize["ContainerId"] = val + } + if val, ok := getGetFolderDetailsResponseGetCreationTimeAttributeTypeOk(o.CreationTime); ok { + toSerialize["CreationTime"] = val + } + if val, ok := getGetFolderDetailsResponseGetFolderIdAttributeTypeOk(o.FolderId); ok { + toSerialize["FolderId"] = val + } + if val, ok := getGetFolderDetailsResponseGetLabelsAttributeTypeOk(o.Labels); ok { + toSerialize["Labels"] = val + } + if val, ok := getGetFolderDetailsResponseGetNameAttributeTypeOk(o.Name); ok { + toSerialize["Name"] = val + } + if val, ok := getGetFolderDetailsResponseGetParentAttributeTypeOk(o.Parent); ok { + toSerialize["Parent"] = val + } + if val, ok := getGetFolderDetailsResponseGetParentsAttributeTypeOk(o.Parents); ok { + toSerialize["Parents"] = val + } + if val, ok := getGetFolderDetailsResponseGetUpdateTimeAttributeTypeOk(o.UpdateTime); ok { + toSerialize["UpdateTime"] = val + } + return toSerialize, nil +} + +type NullableGetFolderDetailsResponse struct { + value *GetFolderDetailsResponse + isSet bool +} + +func (v NullableGetFolderDetailsResponse) Get() *GetFolderDetailsResponse { + return v.value +} + +func (v *NullableGetFolderDetailsResponse) Set(val *GetFolderDetailsResponse) { + v.value = val + v.isSet = true +} + +func (v NullableGetFolderDetailsResponse) IsSet() bool { + return v.isSet +} + +func (v *NullableGetFolderDetailsResponse) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableGetFolderDetailsResponse(val *GetFolderDetailsResponse) *NullableGetFolderDetailsResponse { + return &NullableGetFolderDetailsResponse{value: val, isSet: true} +} + +func (v NullableGetFolderDetailsResponse) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableGetFolderDetailsResponse) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/resourcemanager/model_partial_update_folder_payload.go b/services/resourcemanager/model_partial_update_folder_payload.go new file mode 100644 index 000000000..e63cf1972 --- /dev/null +++ b/services/resourcemanager/model_partial_update_folder_payload.go @@ -0,0 +1,226 @@ +/* +Resource Manager API + +API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists + +API version: 2.0 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package resourcemanager + +import ( + "encoding/json" +) + +// checks if the PartialUpdateFolderPayload type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &PartialUpdateFolderPayload{} + +/* + types and functions for containerParentId +*/ + +// isNotNullableString +type PartialUpdateFolderPayloadGetContainerParentIdAttributeType = *string + +func getPartialUpdateFolderPayloadGetContainerParentIdAttributeTypeOk(arg PartialUpdateFolderPayloadGetContainerParentIdAttributeType) (ret PartialUpdateFolderPayloadGetContainerParentIdRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setPartialUpdateFolderPayloadGetContainerParentIdAttributeType(arg *PartialUpdateFolderPayloadGetContainerParentIdAttributeType, val PartialUpdateFolderPayloadGetContainerParentIdRetType) { + *arg = &val +} + +type PartialUpdateFolderPayloadGetContainerParentIdArgType = string +type PartialUpdateFolderPayloadGetContainerParentIdRetType = string + +/* + types and functions for labels +*/ + +// isContainer +type PartialUpdateFolderPayloadGetLabelsAttributeType = *map[string]string +type PartialUpdateFolderPayloadGetLabelsArgType = map[string]string +type PartialUpdateFolderPayloadGetLabelsRetType = map[string]string + +func getPartialUpdateFolderPayloadGetLabelsAttributeTypeOk(arg PartialUpdateFolderPayloadGetLabelsAttributeType) (ret PartialUpdateFolderPayloadGetLabelsRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setPartialUpdateFolderPayloadGetLabelsAttributeType(arg *PartialUpdateFolderPayloadGetLabelsAttributeType, val PartialUpdateFolderPayloadGetLabelsRetType) { + *arg = &val +} + +/* + types and functions for name +*/ + +// isNotNullableString +type PartialUpdateFolderPayloadGetNameAttributeType = *string + +func getPartialUpdateFolderPayloadGetNameAttributeTypeOk(arg PartialUpdateFolderPayloadGetNameAttributeType) (ret PartialUpdateFolderPayloadGetNameRetType, ok bool) { + if arg == nil { + return ret, false + } + return *arg, true +} + +func setPartialUpdateFolderPayloadGetNameAttributeType(arg *PartialUpdateFolderPayloadGetNameAttributeType, val PartialUpdateFolderPayloadGetNameRetType) { + *arg = &val +} + +type PartialUpdateFolderPayloadGetNameArgType = string +type PartialUpdateFolderPayloadGetNameRetType = string + +// PartialUpdateFolderPayload struct for PartialUpdateFolderPayload +type PartialUpdateFolderPayload struct { + // New parent identifier for the resource container - containerId as well as UUID identifier is supported. + ContainerParentId PartialUpdateFolderPayloadGetContainerParentIdAttributeType `json:"containerParentId,omitempty"` + // Labels are key-value string pairs that can be attached to a resource container. Some labels may be enforced via policies. - A label key must match the regex `[A-ZÄÜÖa-zäüöß0-9_-]{1,64}`. - A label value must match the regex `^$|[A-ZÄÜÖa-zäüöß0-9_-]{1,64}`. + Labels PartialUpdateFolderPayloadGetLabelsAttributeType `json:"labels,omitempty"` + // New name for the resource container matching the regex `^[a-zA-ZäüöÄÜÖ0-9]( ?[a-zA-ZäüöÄÜÖß0-9_+&-]){0,39}$`. + Name PartialUpdateFolderPayloadGetNameAttributeType `json:"name,omitempty"` +} + +// NewPartialUpdateFolderPayload instantiates a new PartialUpdateFolderPayload 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 NewPartialUpdateFolderPayload() *PartialUpdateFolderPayload { + this := PartialUpdateFolderPayload{} + return &this +} + +// NewPartialUpdateFolderPayloadWithDefaults instantiates a new PartialUpdateFolderPayload 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 NewPartialUpdateFolderPayloadWithDefaults() *PartialUpdateFolderPayload { + this := PartialUpdateFolderPayload{} + return &this +} + +// GetContainerParentId returns the ContainerParentId field value if set, zero value otherwise. +func (o *PartialUpdateFolderPayload) GetContainerParentId() (res PartialUpdateFolderPayloadGetContainerParentIdRetType) { + res, _ = o.GetContainerParentIdOk() + return +} + +// GetContainerParentIdOk returns a tuple with the ContainerParentId field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *PartialUpdateFolderPayload) GetContainerParentIdOk() (ret PartialUpdateFolderPayloadGetContainerParentIdRetType, ok bool) { + return getPartialUpdateFolderPayloadGetContainerParentIdAttributeTypeOk(o.ContainerParentId) +} + +// HasContainerParentId returns a boolean if a field has been set. +func (o *PartialUpdateFolderPayload) HasContainerParentId() bool { + _, ok := o.GetContainerParentIdOk() + return ok +} + +// SetContainerParentId gets a reference to the given string and assigns it to the ContainerParentId field. +func (o *PartialUpdateFolderPayload) SetContainerParentId(v PartialUpdateFolderPayloadGetContainerParentIdRetType) { + setPartialUpdateFolderPayloadGetContainerParentIdAttributeType(&o.ContainerParentId, v) +} + +// GetLabels returns the Labels field value if set, zero value otherwise. +func (o *PartialUpdateFolderPayload) GetLabels() (res PartialUpdateFolderPayloadGetLabelsRetType) { + res, _ = o.GetLabelsOk() + return +} + +// GetLabelsOk returns a tuple with the Labels field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *PartialUpdateFolderPayload) GetLabelsOk() (ret PartialUpdateFolderPayloadGetLabelsRetType, ok bool) { + return getPartialUpdateFolderPayloadGetLabelsAttributeTypeOk(o.Labels) +} + +// HasLabels returns a boolean if a field has been set. +func (o *PartialUpdateFolderPayload) HasLabels() bool { + _, ok := o.GetLabelsOk() + return ok +} + +// SetLabels gets a reference to the given map[string]string and assigns it to the Labels field. +func (o *PartialUpdateFolderPayload) SetLabels(v PartialUpdateFolderPayloadGetLabelsRetType) { + setPartialUpdateFolderPayloadGetLabelsAttributeType(&o.Labels, v) +} + +// GetName returns the Name field value if set, zero value otherwise. +func (o *PartialUpdateFolderPayload) GetName() (res PartialUpdateFolderPayloadGetNameRetType) { + res, _ = o.GetNameOk() + return +} + +// GetNameOk returns a tuple with the Name field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *PartialUpdateFolderPayload) GetNameOk() (ret PartialUpdateFolderPayloadGetNameRetType, ok bool) { + return getPartialUpdateFolderPayloadGetNameAttributeTypeOk(o.Name) +} + +// HasName returns a boolean if a field has been set. +func (o *PartialUpdateFolderPayload) HasName() bool { + _, ok := o.GetNameOk() + return ok +} + +// SetName gets a reference to the given string and assigns it to the Name field. +func (o *PartialUpdateFolderPayload) SetName(v PartialUpdateFolderPayloadGetNameRetType) { + setPartialUpdateFolderPayloadGetNameAttributeType(&o.Name, v) +} + +func (o PartialUpdateFolderPayload) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + if val, ok := getPartialUpdateFolderPayloadGetContainerParentIdAttributeTypeOk(o.ContainerParentId); ok { + toSerialize["ContainerParentId"] = val + } + if val, ok := getPartialUpdateFolderPayloadGetLabelsAttributeTypeOk(o.Labels); ok { + toSerialize["Labels"] = val + } + if val, ok := getPartialUpdateFolderPayloadGetNameAttributeTypeOk(o.Name); ok { + toSerialize["Name"] = val + } + return toSerialize, nil +} + +type NullablePartialUpdateFolderPayload struct { + value *PartialUpdateFolderPayload + isSet bool +} + +func (v NullablePartialUpdateFolderPayload) Get() *PartialUpdateFolderPayload { + return v.value +} + +func (v *NullablePartialUpdateFolderPayload) Set(val *PartialUpdateFolderPayload) { + v.value = val + v.isSet = true +} + +func (v NullablePartialUpdateFolderPayload) IsSet() bool { + return v.isSet +} + +func (v *NullablePartialUpdateFolderPayload) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullablePartialUpdateFolderPayload(val *PartialUpdateFolderPayload) *NullablePartialUpdateFolderPayload { + return &NullablePartialUpdateFolderPayload{value: val, isSet: true} +} + +func (v NullablePartialUpdateFolderPayload) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullablePartialUpdateFolderPayload) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +}