coder.getTask

import * as pulumi from "@pulumi/pulumi";
import * as coder from "@pulumi/coder";

export = async () => {
    const meWorkspace = await coder.getWorkspace({});
    const meTask = await coder.getTask({});
    const task: coder.AiTask[] = [];
    for (const range = {value: 0}; range.value < (meTask.enabled ? meWorkspace.startCount : 0); range.value++) {
        task.push(new coder.AiTask(`task-${range.value}`, {appId: module["example-agent"].task_app_id}));
    }
}

import pulumi
import pulumi_coder as coder

me_workspace = coder.get_workspace()
me_task = coder.get_task()
task = []
for range in [{"value": i} for i in range(0, me_workspace.start_count if me_task.enabled else 0)]:
    task.append(coder.AiTask(f"task-{range['value']}", app_id=module["example-agent"]["task_app_id"]))

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/coder/v2/coder"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		meWorkspace, err := coder.GetWorkspace(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		meTask, err := coder.GetTask(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		var tmp0 pulumi.Float64
		if meTask.Enabled {
			tmp0 = meWorkspace.StartCount
		} else {
			tmp0 = 0
		}
		var task []*coder.AiTask
		for index := 0; index < tmp0; index++ {
			key0 := index
			_ := index
			__res, err := coder.NewAiTask(ctx, fmt.Sprintf("task-%v", key0), &coder.AiTaskArgs{
				AppId: pulumi.Any(module.ExampleAgent.Task_app_id),
			})
			if err != nil {
				return err
			}
			task = append(task, __res)
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Pulumi;
using Coder = Pulumi.Coder;

return await Deployment.RunAsync(async() => 
{
    var meWorkspace = await Coder.GetWorkspace.InvokeAsync();

    var meTask = await Coder.GetTask.InvokeAsync();

    var task = new List<Coder.AiTask>();
    for (var rangeIndex = 0; rangeIndex < meTask.Enabled ? meWorkspace.StartCount : 0; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        task.Add(new Coder.AiTask($"task-{range.Value}", new()
        {
            AppId = module.Example_agent.Task_app_id,
        }));
    }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.coder.CoderFunctions;
import com.pulumi.coder.AiTask;
import com.pulumi.coder.AiTaskArgs;
import com.pulumi.codegen.internal.KeyedValue;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var meWorkspace = CoderFunctions.getWorkspace();

        final var meTask = CoderFunctions.getTask();

        for (var i = 0; i < meTask.applyValue(getTaskResult -> getTaskResult.enabled()) ? meWorkspace.applyValue(getWorkspaceResult -> getWorkspaceResult.startCount()) : 0; i++) {
            new AiTask("task-" + i, AiTaskArgs.builder()
                .appId(module.example-agent().task_app_id())
                .build());

        
}
    }
}

resources:
  task:
    type: coder:AiTask
    properties:
      appId: ${module"example-agent"[%!s(MISSING)].task_app_id}
    options: {}
variables:
  meWorkspace:
    fn::invoke:
      function: coder:getWorkspace
      arguments: {}
  meTask:
    fn::invoke:
      function: coder:getTask
      arguments: {}

function getTask(opts?: InvokeOptions): Promise<GetTaskResult>
function getTaskOutput(opts?: InvokeOptions): Output<GetTaskResult>

def get_task(opts: Optional[InvokeOptions] = None) -> GetTaskResult
def get_task_output(opts: Optional[InvokeOptions] = None) -> Output[GetTaskResult]

func GetTask(ctx *Context, opts ...InvokeOption) (*GetTaskResult, error)
func GetTaskOutput(ctx *Context, opts ...InvokeOption) GetTaskResultOutput

public static class GetTask 
{
    public static Task<GetTaskResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetTaskResult> Invoke(InvokeOptions? opts = null)
}

public static CompletableFuture<GetTaskResult> getTask(InvokeOptions options)
public static Output<GetTaskResult> getTask(InvokeOptions options)

fn::invoke:
  function: coder:index/getTask:getTask
  arguments:
    # arguments dictionary