func()

in internal/provider/resource_gitlab_group_epic_board.go [234:342]
94 lines of code
11 McCabe index (conditional complexity)

func (r *gitlabGroupEpicBoardResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
	var data *gitlabGroupEpicBoardResourceModel

	// Read Terraform plan data into the model
	resp.Diagnostics.Append(req.Plan.Get(ctx, &data)...)

	if resp.Diagnostics.HasError() {
		return
	}

	groupID, boardID, err := utils.ParseTwoPartID(data.Id.ValueString())
	if err != nil {
		resp.Diagnostics.AddError(
			"Invalid resource ID format",
			fmt.Sprintf("The resource ID '%s' has an invalid format in Read. It should be '<group-id>:<board-id>'. Error: %s", data.Id.ValueString(), err.Error()),
		)
		return
	}
	boardId, err := strconv.Atoi(boardID)
	if err != nil {
		resp.Diagnostics.AddError(
			"Internal provider error",
			fmt.Sprintf("Unable to convert board id to int: %s", err.Error()),
		)
		return
	}

	boardName := data.Name.ValueString()

	labels := make([]string, len(data.Lists))
	for i, v := range data.Lists {
		labels[i] = fmt.Sprintf("gid://gitlab/GroupLabel/%s", v.LabelId.String())
	}
	labels_str := fmt.Sprintf(`["%s"]`, strings.Join(labels, `","`))

	query := gitlab.GraphQLQuery{
		Query: fmt.Sprintf(`
			mutation {
				epicBoardUpdate(
					input: {
						id: "gid://gitlab/Boards::EpicBoard/%d",
						name: "%s",
						labels: %s
					}
				) {
					epicBoard {
						id,
						name,
						labels {
							nodes {
								id
							}
						}
					}
				}
			}`, boardId, boardName, labels_str),
	}
	tflog.Debug(ctx, "executing GraphQL Query to create epic board", map[string]any{
		"query": query.Query,
	})

	var response EpicBoardUpdateResponse
	if _, err = r.client.GraphQL.Do(ctx, query, &response); err != nil {
		resp.Diagnostics.AddError("GitLab GraphQL error occurred", fmt.Sprintf("Unable to update epic board: %s from query %s", err.Error(), query.Query))
		return
	}
	if len(response.Errors) > 0 {
		allerr := fmt.Sprintf("From update response %v\n", response)
		for i, err := range response.Errors {
			allerr += fmt.Sprintf("Error %d Code: %s\n", i, err)
		}
		resp.Diagnostics.AddError("GitLab GraphQL error occurred", allerr)
		return
	}

	parts := strings.Split(response.Data.EpicBoardUpdate.EpicBoard.Id, "/")
	epicBoardId := parts[len(parts)-1]
	EpicBoardId, err := strconv.Atoi(epicBoardId)
	if err != nil {
		resp.Diagnostics.AddError("GitLab API error occurred", fmt.Sprintf("Unable to update epic: %s - call response %v Query %s",
			"EpicBoard ID not found in GraphQL response", response, query.Query))
		return
	}

	var groupEpicBoard *gitlab.GroupEpicBoard
	groupEpicBoard, _, err = r.client.GroupEpicBoards.GetGroupEpicBoard(groupID, EpicBoardId, gitlab.WithContext(ctx))
	if err != nil {
		if api.Is404(err) {
			tflog.Debug(ctx, "group epic board does not exist, removing from state", map[string]any{
				"group": groupID, "environment": EpicBoardId,
			})
			resp.State.RemoveResource(ctx)
			return
		}
		resp.Diagnostics.AddError("GitLab API error occured", fmt.Sprintf("Unable to read gitlab group epic board details: %s", err.Error()))
		return
	}

	data.Id = types.StringValue(utils.BuildTwoPartID(&groupID, &boardID))
	r.groupEpicBoardToStateModel(groupID, groupEpicBoard, data)

	// Log the creation of the resource
	tflog.Debug(ctx, "updated a group epic board", map[string]any{
		"group": groupID, "board": groupEpicBoard.Name,
	})

	// Save data into Terraform state
	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
}