mongodbatlas.getProjects

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

const test = mongodbatlas.getRolesOrgId({});
const testProject = new mongodbatlas.Project("test", {
    name: "project-name",
    orgId: test.then(test => test.orgId),
    teams: [
        {
            teamId: "5e0fa8c99ccf641c722fe645",
            roleNames: ["GROUP_OWNER"],
        },
        {
            teamId: "5e1dd7b4f2a30ba80a70cd4rw",
            roleNames: [
                "GROUP_READ_ONLY",
                "GROUP_DATA_ACCESS_READ_WRITE",
            ],
        },
    ],
    limits: [{
        name: "atlas.project.deployment.clusters",
        value: 26,
    }],
});
const testGetProjects = mongodbatlas.getProjects({
    pageNum: 1,
    itemsPerPage: 5,
});

import pulumi
import pulumi_mongodbatlas as mongodbatlas

test = mongodbatlas.get_roles_org_id()
test_project = mongodbatlas.Project("test",
    name="project-name",
    org_id=test.org_id,
    teams=[
        mongodbatlas.ProjectTeamArgs(
            team_id="5e0fa8c99ccf641c722fe645",
            role_names=["GROUP_OWNER"],
        ),
        mongodbatlas.ProjectTeamArgs(
            team_id="5e1dd7b4f2a30ba80a70cd4rw",
            role_names=[
                "GROUP_READ_ONLY",
                "GROUP_DATA_ACCESS_READ_WRITE",
            ],
        ),
    ],
    limits=[mongodbatlas.ProjectLimitArgs(
        name="atlas.project.deployment.clusters",
        value=26,
    )])
test_get_projects = mongodbatlas.get_projects(page_num=1,
    items_per_page=5)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := mongodbatlas.GetRolesOrgId(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = mongodbatlas.NewProject(ctx, "test", &mongodbatlas.ProjectArgs{
			Name:  pulumi.String("project-name"),
			OrgId: pulumi.String(test.OrgId),
			Teams: mongodbatlas.ProjectTeamArray{
				&mongodbatlas.ProjectTeamArgs{
					TeamId: pulumi.String("5e0fa8c99ccf641c722fe645"),
					RoleNames: pulumi.StringArray{
						pulumi.String("GROUP_OWNER"),
					},
				},
				&mongodbatlas.ProjectTeamArgs{
					TeamId: pulumi.String("5e1dd7b4f2a30ba80a70cd4rw"),
					RoleNames: pulumi.StringArray{
						pulumi.String("GROUP_READ_ONLY"),
						pulumi.String("GROUP_DATA_ACCESS_READ_WRITE"),
					},
				},
			},
			Limits: mongodbatlas.ProjectLimitArray{
				&mongodbatlas.ProjectLimitArgs{
					Name:  pulumi.String("atlas.project.deployment.clusters"),
					Value: pulumi.Int(26),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = mongodbatlas.LookupProjects(ctx, &mongodbatlas.LookupProjectsArgs{
			PageNum:      pulumi.IntRef(1),
			ItemsPerPage: pulumi.IntRef(5),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var test = Mongodbatlas.GetRolesOrgId.Invoke();

    var testProject = new Mongodbatlas.Project("test", new()
    {
        Name = "project-name",
        OrgId = test.Apply(getRolesOrgIdResult => getRolesOrgIdResult.OrgId),
        Teams = new[]
        {
            new Mongodbatlas.Inputs.ProjectTeamArgs
            {
                TeamId = "5e0fa8c99ccf641c722fe645",
                RoleNames = new[]
                {
                    "GROUP_OWNER",
                },
            },
            new Mongodbatlas.Inputs.ProjectTeamArgs
            {
                TeamId = "5e1dd7b4f2a30ba80a70cd4rw",
                RoleNames = new[]
                {
                    "GROUP_READ_ONLY",
                    "GROUP_DATA_ACCESS_READ_WRITE",
                },
            },
        },
        Limits = new[]
        {
            new Mongodbatlas.Inputs.ProjectLimitArgs
            {
                Name = "atlas.project.deployment.clusters",
                Value = 26,
            },
        },
    });

    var testGetProjects = Mongodbatlas.GetProjects.Invoke(new()
    {
        PageNum = 1,
        ItemsPerPage = 5,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.Project;
import com.pulumi.mongodbatlas.ProjectArgs;
import com.pulumi.mongodbatlas.inputs.ProjectTeamArgs;
import com.pulumi.mongodbatlas.inputs.ProjectLimitArgs;
import com.pulumi.mongodbatlas.inputs.GetProjectsArgs;
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 test = MongodbatlasFunctions.getRolesOrgId();

        var testProject = new Project("testProject", ProjectArgs.builder()
            .name("project-name")
            .orgId(test.applyValue(getRolesOrgIdResult -> getRolesOrgIdResult.orgId()))
            .teams(            
                ProjectTeamArgs.builder()
                    .teamId("5e0fa8c99ccf641c722fe645")
                    .roleNames("GROUP_OWNER")
                    .build(),
                ProjectTeamArgs.builder()
                    .teamId("5e1dd7b4f2a30ba80a70cd4rw")
                    .roleNames(                    
                        "GROUP_READ_ONLY",
                        "GROUP_DATA_ACCESS_READ_WRITE")
                    .build())
            .limits(ProjectLimitArgs.builder()
                .name("atlas.project.deployment.clusters")
                .value(26)
                .build())
            .build());

        final var testGetProjects = MongodbatlasFunctions.getProjects(GetProjectsArgs.builder()
            .pageNum(1)
            .itemsPerPage(5)
            .build());

    }
}

resources:
  testProject:
    type: mongodbatlas:Project
    name: test
    properties:
      name: project-name
      orgId: ${test.orgId}
      teams:
        - teamId: 5e0fa8c99ccf641c722fe645
          roleNames:
            - GROUP_OWNER
        - teamId: 5e1dd7b4f2a30ba80a70cd4rw
          roleNames:
            - GROUP_READ_ONLY
            - GROUP_DATA_ACCESS_READ_WRITE
      limits:
        - name: atlas.project.deployment.clusters
          value: 26
variables:
  test:
    fn::invoke:
      Function: mongodbatlas:getRolesOrgId
      Arguments: {}
  testGetProjects:
    fn::invoke:
      Function: mongodbatlas:getProjects
      Arguments:
        pageNum: 1
        itemsPerPage: 5

function getProjects(args: GetProjectsArgs, opts?: InvokeOptions): Promise<GetProjectsResult>
function getProjectsOutput(args: GetProjectsOutputArgs, opts?: InvokeOptions): Output<GetProjectsResult>

def get_projects(items_per_page: Optional[int] = None,
                 page_num: Optional[int] = None,
                 opts: Optional[InvokeOptions] = None) -> GetProjectsResult
def get_projects_output(items_per_page: Optional[pulumi.Input[int]] = None,
                 page_num: Optional[pulumi.Input[int]] = None,
                 opts: Optional[InvokeOptions] = None) -> Output[GetProjectsResult]

func LookupProjects(ctx *Context, args *LookupProjectsArgs, opts ...InvokeOption) (*LookupProjectsResult, error)
func LookupProjectsOutput(ctx *Context, args *LookupProjectsOutputArgs, opts ...InvokeOption) LookupProjectsResultOutput

public static class GetProjects 
{
    public static Task<GetProjectsResult> InvokeAsync(GetProjectsArgs args, InvokeOptions? opts = null)
    public static Output<GetProjectsResult> Invoke(GetProjectsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetProjectsResult> getProjects(GetProjectsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: mongodbatlas:index/getProjects:getProjects
  arguments:
    # arguments dictionary