dbtcloud.getProject

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

// projects data sources can use the project_id parameter (preferred uniqueness is ensured)
const testProject = dbtcloud.getProject({
    projectId: dbtCloudProjectId,
});
// or they can use project names
// the provider will raise an error if more than one project is found with the same name
const anotherTestProject = dbtcloud.getProject({
    name: "My other project name",
});

import pulumi
import pulumi_dbtcloud as dbtcloud

# projects data sources can use the project_id parameter (preferred uniqueness is ensured)
test_project = dbtcloud.get_project(project_id=dbt_cloud_project_id)
# or they can use project names
# the provider will raise an error if more than one project is found with the same name
another_test_project = dbtcloud.get_project(name="My other project name")

package main

import (
	"github.com/pulumi/pulumi-dbtcloud/sdk/go/dbtcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// projects data sources can use the project_id parameter (preferred uniqueness is ensured)
		_, err := dbtcloud.LookupProject(ctx, &dbtcloud.LookupProjectArgs{
			ProjectId: pulumi.IntRef(dbtCloudProjectId),
		}, nil)
		if err != nil {
			return err
		}
		// or they can use project names
		// the provider will raise an error if more than one project is found with the same name
		_, err = dbtcloud.LookupProject(ctx, &dbtcloud.LookupProjectArgs{
			Name: pulumi.StringRef("My other project name"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DbtCloud = Pulumi.DbtCloud;

return await Deployment.RunAsync(() => 
{
    // projects data sources can use the project_id parameter (preferred uniqueness is ensured)
    var testProject = DbtCloud.GetProject.Invoke(new()
    {
        ProjectId = dbtCloudProjectId,
    });

    // or they can use project names
    // the provider will raise an error if more than one project is found with the same name
    var anotherTestProject = DbtCloud.GetProject.Invoke(new()
    {
        Name = "My other project name",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dbtcloud.DbtcloudFunctions;
import com.pulumi.dbtcloud.inputs.GetProjectArgs;
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) {
        // projects data sources can use the project_id parameter (preferred uniqueness is ensured)
        final var testProject = DbtcloudFunctions.getProject(GetProjectArgs.builder()
            .projectId(dbtCloudProjectId)
            .build());

        // or they can use project names
        // the provider will raise an error if more than one project is found with the same name
        final var anotherTestProject = DbtcloudFunctions.getProject(GetProjectArgs.builder()
            .name("My other project name")
            .build());

    }
}

variables:
  # projects data sources can use the project_id parameter (preferred uniqueness is ensured)
  testProject:
    fn::invoke:
      Function: dbtcloud:getProject
      Arguments:
        projectId: ${dbtCloudProjectId}
  # or they can use project names
  # // the provider will raise an error if more than one project is found with the same name
  anotherTestProject:
    fn::invoke:
      Function: dbtcloud:getProject
      Arguments:
        name: My other project name

function getProject(args: GetProjectArgs, opts?: InvokeOptions): Promise<GetProjectResult>
function getProjectOutput(args: GetProjectOutputArgs, opts?: InvokeOptions): Output<GetProjectResult>

def get_project(name: Optional[str] = None,
                project_id: Optional[int] = None,
                opts: Optional[InvokeOptions] = None) -> GetProjectResult
def get_project_output(name: Optional[pulumi.Input[str]] = None,
                project_id: Optional[pulumi.Input[int]] = None,
                opts: Optional[InvokeOptions] = None) -> Output[GetProjectResult]

func LookupProject(ctx *Context, args *LookupProjectArgs, opts ...InvokeOption) (*LookupProjectResult, error)
func LookupProjectOutput(ctx *Context, args *LookupProjectOutputArgs, opts ...InvokeOption) LookupProjectResultOutput

public static class GetProject 
{
    public static Task<GetProjectResult> InvokeAsync(GetProjectArgs args, InvokeOptions? opts = null)
    public static Output<GetProjectResult> Invoke(GetProjectInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetProjectResult> getProject(GetProjectArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: dbtcloud:index/getProject:getProject
  arguments:
    # arguments dictionary