Function runDocsTableDimensionCommand

internal/cmd/docs_table_ops.go:190–236

(ctx context.Context, flags *RootFlags, command docsTableDimensionCommand)

}

func runDocsTableDimensionCommand(ctx context.Context, flags *RootFlags, command docsTableDimensionCommand) error {
	docID, err := validateDocsTableMutationArgs(command.docID, command.table)
	if err != nil {
		return err
	}
	if command.target == 0 && !command.appendAtEnd {
		return usagef("--%s cannot be 0", command.dimension)
	}
	targetValue := any(command.target)
	if command.appendAtEnd {
		targetValue = "end"
	}
	if dryRunErr := dryRunExit(ctx, flags, command.dryRunOp, map[string]any{
		"documentId":              docID,
		"table":                   command.table,
		string(command.dimension): targetValue,
		"tab":                     command.tab,
	}); dryRunErr != nil {
		return dryRunErr
	}

	svc, loaded, selected, err := loadDocsSelectedTables(ctx, flags, docID, command.tab, command.table)
	if err != nil {
		return err
	}
	requests := make([]*docs.Request, 0, len(selected))
	results := make([]docsTableMutationResult, 0, len(selected))
	for _, target := range selected {
		req, resolved, buildErr := docstable.BuildDimensionRequest(
			docsTablePlanTarget(target.tableWithIndex),
			command.dimension,
			docstable.Action(command.action),
			command.target,
			command.appendAtEnd,
			loaded.tabID,
		)
		if buildErr != nil {
			return usage(buildErr.Error())
		}
		requests = append(requests, req)
		results = append(results, docsTableMutationResult{TableIndex: target.index, Index: resolved})
	}
	if _, err := executeDocsTableRequests(ctx, svc, docID, loaded.full.RevisionId, requests); err != nil {
		return fmt.Errorf("%s table %s: %w", command.action, command.dimension, err)
	}
	return writeDocsTableMutationResult(ctx, docID, loaded.tabID, command.action, string(command.dimension), results)
}

func (c *DocsTableMergeCmd) Run(ctx context.Context, flags *RootFlags) error {
	startRow, startCol, endRow, endCol, err := parseDocsTableRange(c.Range)