gcp.apigee.DeveloperApp

resources:
  apigeeDeveloperApp:
    type: gcp:apigee:DeveloperApp
    name: apigee_developer_app
    properties:
      name: sample-app
      orgId: ${apigeeOrg.id}
      developerId: ${developer.id}
      developerEmail: ${developer.email}
      callbackUrl: https://example-call.url
      apiProducts:
        - ${apiProduct.name}
      scopes: ${apiProduct.scopes}
  apiProduct:
    type: gcp:apigee:ApiProduct
    name: api_product
    properties:
      orgId: ${apigeeOrg.id}
      name: sample-api
      displayName: A sample API Product
      approvalType: auto
      scopes:
        - read:weather
        - write:reports
    options:
      dependsOn:
        - ${apigeeInstance}
  developer:
    type: gcp:apigee:Developer
    properties:
      email: john.doe@acme.com
      firstName: John
      lastName: Doe
      userName: john.doe
      orgId: ${apigeeOrg.id}
    options:
      dependsOn:
        - ${apigeeInstance}
  apigeeInstance:
    type: gcp:apigee:Instance
    name: apigee_instance
    properties:
      name: instance
      location: us-central1
      orgId: ${apigeeOrg.id}
  apigeeOrg:
    type: gcp:apigee:Organization
    name: apigee_org
    properties:
      analyticsRegion: us-central1
      projectId: ${projectGoogleProject.projectId}
      disableVpcPeering: true
variables:
  project:
    fn::invoke:
      function: gcp:organizations:getProject
      arguments: {}

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as time from "@pulumiverse/time";

const project = new gcp.organizations.Project("project", {
    projectId: "prj",
    name: "prj",
    orgId: "123456789",
    billingAccount: "000000-0000000-0000000-000000",
    deletionPolicy: "DELETE",
});
const wait60Seconds = new time.Sleep("wait_60_seconds", {createDuration: "60s"}, {
    dependsOn: [project],
});
const apigee = new gcp.projects.Service("apigee", {
    project: project.projectId,
    service: "apigee.googleapis.com",
}, {
    dependsOn: [wait60Seconds],
});
const apigeeOrg = new gcp.apigee.Organization("apigee_org", {
    analyticsRegion: "us-central1",
    projectId: project.projectId,
    disableVpcPeering: true,
}, {
    dependsOn: [apigee],
});
const apigeeInstance = new gcp.apigee.Instance("apigee_instance", {
    name: "instance",
    location: "us-central1",
    orgId: apigeeOrg.id,
});
const apiProduct = new gcp.apigee.ApiProduct("api_product", {
    name: "sample-api",
    orgId: apigeeOrg.id,
    displayName: "A sample API Product",
    approvalType: "auto",
    scopes: [
        "read:weather",
        "write:reports",
        "write:files",
    ],
}, {
    dependsOn: [apigeeInstance],
});
const developer = new gcp.apigee.Developer("developer", {
    email: "john.doe@acme.com",
    firstName: "John",
    lastName: "Doe",
    userName: "john.doe",
    orgId: apigeeOrg.id,
}, {
    dependsOn: [apigeeInstance],
});
const apigeeDeveloperApp = new gcp.apigee.DeveloperApp("apigee_developer_app", {
    name: "sample-app",
    appFamily: "default",
    developerEmail: developer.email,
    orgId: apigeeOrg.id,
    callbackUrl: "https://example-call.url",
    keyExpiresIn: "-1",
    status: "approved",
    apiProducts: [apiProduct.name],
    scopes: apiProduct.scopes,
    attributes: [{
        name: "sample_name",
        value: "sample_value",
    }],
});

import pulumi
import pulumi_gcp as gcp
import pulumiverse_time as time

project = gcp.organizations.Project("project",
    project_id="prj",
    name="prj",
    org_id="123456789",
    billing_account="000000-0000000-0000000-000000",
    deletion_policy="DELETE")
wait60_seconds = time.Sleep("wait_60_seconds", create_duration="60s",
opts = pulumi.ResourceOptions(depends_on=[project]))
apigee = gcp.projects.Service("apigee",
    project=project.project_id,
    service="apigee.googleapis.com",
    opts = pulumi.ResourceOptions(depends_on=[wait60_seconds]))
apigee_org = gcp.apigee.Organization("apigee_org",
    analytics_region="us-central1",
    project_id=project.project_id,
    disable_vpc_peering=True,
    opts = pulumi.ResourceOptions(depends_on=[apigee]))
apigee_instance = gcp.apigee.Instance("apigee_instance",
    name="instance",
    location="us-central1",
    org_id=apigee_org.id)
api_product = gcp.apigee.ApiProduct("api_product",
    name="sample-api",
    org_id=apigee_org.id,
    display_name="A sample API Product",
    approval_type="auto",
    scopes=[
        "read:weather",
        "write:reports",
        "write:files",
    ],
    opts = pulumi.ResourceOptions(depends_on=[apigee_instance]))
developer = gcp.apigee.Developer("developer",
    email="john.doe@acme.com",
    first_name="John",
    last_name="Doe",
    user_name="john.doe",
    org_id=apigee_org.id,
    opts = pulumi.ResourceOptions(depends_on=[apigee_instance]))
apigee_developer_app = gcp.apigee.DeveloperApp("apigee_developer_app",
    name="sample-app",
    app_family="default",
    developer_email=developer.email,
    org_id=apigee_org.id,
    callback_url="https://example-call.url",
    key_expires_in="-1",
    status="approved",
    api_products=[api_product.name],
    scopes=api_product.scopes,
    attributes=[{
        "name": "sample_name",
        "value": "sample_value",
    }])

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/apigee"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/projects"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-time/sdk/go/time"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		project, err := organizations.NewProject(ctx, "project", &organizations.ProjectArgs{
			ProjectId:      pulumi.String("prj"),
			Name:           pulumi.String("prj"),
			OrgId:          pulumi.String("123456789"),
			BillingAccount: pulumi.String("000000-0000000-0000000-000000"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		wait60Seconds, err := time.NewSleep(ctx, "wait_60_seconds", &time.SleepArgs{
			CreateDuration: pulumi.String("60s"),
		}, pulumi.DependsOn([]pulumi.Resource{
			project,
		}))
		if err != nil {
			return err
		}
		apigee, err := projects.NewService(ctx, "apigee", &projects.ServiceArgs{
			Project: project.ProjectId,
			Service: pulumi.String("apigee.googleapis.com"),
		}, pulumi.DependsOn([]pulumi.Resource{
			wait60Seconds,
		}))
		if err != nil {
			return err
		}
		apigeeOrg, err := apigee.NewOrganization(ctx, "apigee_org", &apigee.OrganizationArgs{
			AnalyticsRegion:   pulumi.String("us-central1"),
			ProjectId:         project.ProjectId,
			DisableVpcPeering: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			apigee,
		}))
		if err != nil {
			return err
		}
		apigeeInstance, err := apigee.NewInstance(ctx, "apigee_instance", &apigee.InstanceArgs{
			Name:     pulumi.String("instance"),
			Location: pulumi.String("us-central1"),
			OrgId:    apigeeOrg.ID(),
		})
		if err != nil {
			return err
		}
		apiProduct, err := apigee.NewApiProduct(ctx, "api_product", &apigee.ApiProductArgs{
			Name:         pulumi.String("sample-api"),
			OrgId:        apigeeOrg.ID(),
			DisplayName:  pulumi.String("A sample API Product"),
			ApprovalType: pulumi.String("auto"),
			Scopes: pulumi.StringArray{
				pulumi.String("read:weather"),
				pulumi.String("write:reports"),
				pulumi.String("write:files"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			apigeeInstance,
		}))
		if err != nil {
			return err
		}
		developer, err := apigee.NewDeveloper(ctx, "developer", &apigee.DeveloperArgs{
			Email:     pulumi.String("john.doe@acme.com"),
			FirstName: pulumi.String("John"),
			LastName:  pulumi.String("Doe"),
			UserName:  pulumi.String("john.doe"),
			OrgId:     apigeeOrg.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			apigeeInstance,
		}))
		if err != nil {
			return err
		}
		_, err = apigee.NewDeveloperApp(ctx, "apigee_developer_app", &apigee.DeveloperAppArgs{
			Name:           pulumi.String("sample-app"),
			AppFamily:      pulumi.String("default"),
			DeveloperEmail: developer.Email,
			OrgId:          apigeeOrg.ID(),
			CallbackUrl:    pulumi.String("https://example-call.url"),
			KeyExpiresIn:   pulumi.String("-1"),
			Status:         pulumi.String("approved"),
			ApiProducts: pulumi.StringArray{
				apiProduct.Name,
			},
			Scopes: apiProduct.Scopes,
			Attributes: apigee.DeveloperAppAttributeArray{
				&apigee.DeveloperAppAttributeArgs{
					Name:  pulumi.String("sample_name"),
					Value: pulumi.String("sample_value"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Time = Pulumiverse.Time;

return await Deployment.RunAsync(() => 
{
    var project = new Gcp.Organizations.Project("project", new()
    {
        ProjectId = "prj",
        Name = "prj",
        OrgId = "123456789",
        BillingAccount = "000000-0000000-0000000-000000",
        DeletionPolicy = "DELETE",
    });

    var wait60Seconds = new Time.Sleep("wait_60_seconds", new()
    {
        CreateDuration = "60s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            project,
        },
    });

    var apigee = new Gcp.Projects.Service("apigee", new()
    {
        Project = project.ProjectId,
        ServiceName = "apigee.googleapis.com",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            wait60Seconds,
        },
    });

    var apigeeOrg = new Gcp.Apigee.Organization("apigee_org", new()
    {
        AnalyticsRegion = "us-central1",
        ProjectId = project.ProjectId,
        DisableVpcPeering = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            apigee,
        },
    });

    var apigeeInstance = new Gcp.Apigee.Instance("apigee_instance", new()
    {
        Name = "instance",
        Location = "us-central1",
        OrgId = apigeeOrg.Id,
    });

    var apiProduct = new Gcp.Apigee.ApiProduct("api_product", new()
    {
        Name = "sample-api",
        OrgId = apigeeOrg.Id,
        DisplayName = "A sample API Product",
        ApprovalType = "auto",
        Scopes = new[]
        {
            "read:weather",
            "write:reports",
            "write:files",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            apigeeInstance,
        },
    });

    var developer = new Gcp.Apigee.Developer("developer", new()
    {
        Email = "john.doe@acme.com",
        FirstName = "John",
        LastName = "Doe",
        UserName = "john.doe",
        OrgId = apigeeOrg.Id,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            apigeeInstance,
        },
    });

    var apigeeDeveloperApp = new Gcp.Apigee.DeveloperApp("apigee_developer_app", new()
    {
        Name = "sample-app",
        AppFamily = "default",
        DeveloperEmail = developer.Email,
        OrgId = apigeeOrg.Id,
        CallbackUrl = "https://example-call.url",
        KeyExpiresIn = "-1",
        Status = "approved",
        ApiProducts = new[]
        {
            apiProduct.Name,
        },
        Scopes = apiProduct.Scopes,
        Attributes = new[]
        {
            new Gcp.Apigee.Inputs.DeveloperAppAttributeArgs
            {
                Name = "sample_name",
                Value = "sample_value",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumiverse.time.Sleep;
import com.pulumiverse.time.SleepArgs;
import com.pulumi.gcp.projects.Service;
import com.pulumi.gcp.projects.ServiceArgs;
import com.pulumi.gcp.apigee.Organization;
import com.pulumi.gcp.apigee.OrganizationArgs;
import com.pulumi.gcp.apigee.Instance;
import com.pulumi.gcp.apigee.InstanceArgs;
import com.pulumi.gcp.apigee.ApiProduct;
import com.pulumi.gcp.apigee.ApiProductArgs;
import com.pulumi.gcp.apigee.Developer;
import com.pulumi.gcp.apigee.DeveloperArgs;
import com.pulumi.gcp.apigee.DeveloperApp;
import com.pulumi.gcp.apigee.DeveloperAppArgs;
import com.pulumi.gcp.apigee.inputs.DeveloperAppAttributeArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        var project = new Project("project", ProjectArgs.builder()
            .projectId("prj")
            .name("prj")
            .orgId("123456789")
            .billingAccount("000000-0000000-0000000-000000")
            .deletionPolicy("DELETE")
            .build());

        var wait60Seconds = new Sleep("wait60Seconds", SleepArgs.builder()
            .createDuration("60s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(project)
                .build());

        var apigee = new Service("apigee", ServiceArgs.builder()
            .project(project.projectId())
            .service("apigee.googleapis.com")
            .build(), CustomResourceOptions.builder()
                .dependsOn(wait60Seconds)
                .build());

        var apigeeOrg = new Organization("apigeeOrg", OrganizationArgs.builder()
            .analyticsRegion("us-central1")
            .projectId(project.projectId())
            .disableVpcPeering(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(apigee)
                .build());

        var apigeeInstance = new Instance("apigeeInstance", InstanceArgs.builder()
            .name("instance")
            .location("us-central1")
            .orgId(apigeeOrg.id())
            .build());

        var apiProduct = new ApiProduct("apiProduct", ApiProductArgs.builder()
            .name("sample-api")
            .orgId(apigeeOrg.id())
            .displayName("A sample API Product")
            .approvalType("auto")
            .scopes(            
                "read:weather",
                "write:reports",
                "write:files")
            .build(), CustomResourceOptions.builder()
                .dependsOn(apigeeInstance)
                .build());

        var developer = new Developer("developer", DeveloperArgs.builder()
            .email("john.doe@acme.com")
            .firstName("John")
            .lastName("Doe")
            .userName("john.doe")
            .orgId(apigeeOrg.id())
            .build(), CustomResourceOptions.builder()
                .dependsOn(apigeeInstance)
                .build());

        var apigeeDeveloperApp = new DeveloperApp("apigeeDeveloperApp", DeveloperAppArgs.builder()
            .name("sample-app")
            .appFamily("default")
            .developerEmail(developer.email())
            .orgId(apigeeOrg.id())
            .callbackUrl("https://example-call.url")
            .keyExpiresIn("-1")
            .status("approved")
            .apiProducts(apiProduct.name())
            .scopes(apiProduct.scopes())
            .attributes(DeveloperAppAttributeArgs.builder()
                .name("sample_name")
                .value("sample_value")
                .build())
            .build());

    }
}

resources:
  apigeeDeveloperApp:
    type: gcp:apigee:DeveloperApp
    name: apigee_developer_app
    properties:
      name: sample-app
      appFamily: default
      developerEmail: ${developer.email}
      orgId: ${apigeeOrg.id}
      callbackUrl: https://example-call.url
      keyExpiresIn: '-1'
      status: approved
      apiProducts:
        - ${apiProduct.name}
      scopes: ${apiProduct.scopes}
      attributes:
        - name: sample_name
          value: sample_value
  apiProduct:
    type: gcp:apigee:ApiProduct
    name: api_product
    properties:
      name: sample-api
      orgId: ${apigeeOrg.id}
      displayName: A sample API Product
      approvalType: auto
      scopes:
        - read:weather
        - write:reports
        - write:files
    options:
      dependsOn:
        - ${apigeeInstance}
  developer:
    type: gcp:apigee:Developer
    properties:
      email: john.doe@acme.com
      firstName: John
      lastName: Doe
      userName: john.doe
      orgId: ${apigeeOrg.id}
    options:
      dependsOn:
        - ${apigeeInstance}
  apigeeInstance:
    type: gcp:apigee:Instance
    name: apigee_instance
    properties:
      name: instance
      location: us-central1
      orgId: ${apigeeOrg.id}
  apigeeOrg:
    type: gcp:apigee:Organization
    name: apigee_org
    properties:
      analyticsRegion: us-central1
      projectId: ${project.projectId}
      disableVpcPeering: true
    options:
      dependsOn:
        - ${apigee}
  apigee:
    type: gcp:projects:Service
    properties:
      project: ${project.projectId}
      service: apigee.googleapis.com
    options:
      dependsOn:
        - ${wait60Seconds}
  wait60Seconds:
    type: time:Sleep
    name: wait_60_seconds
    properties:
      createDuration: 60s
    options:
      dependsOn:
        - ${project}
  project:
    type: gcp:organizations:Project
    properties:
      projectId: prj
      name: prj
      orgId: '123456789'
      billingAccount: 000000-0000000-0000000-000000
      deletionPolicy: DELETE

var developerAppResource = new Gcp.Apigee.DeveloperApp("developerAppResource", new()
{
    CallbackUrl = "string",
    DeveloperEmail = "string",
    OrgId = "string",
    ApiProducts = new[]
    {
        "string",
    },
    AppFamily = "string",
    Attributes = new[]
    {
        new Gcp.Apigee.Inputs.DeveloperAppAttributeArgs
        {
            Name = "string",
            Value = "string",
        },
    },
    KeyExpiresIn = "string",
    Name = "string",
    Scopes = new[]
    {
        "string",
    },
    Status = "string",
});

example, err := apigee.NewDeveloperApp(ctx, "developerAppResource", &apigee.DeveloperAppArgs{
	CallbackUrl:    pulumi.String("string"),
	DeveloperEmail: pulumi.String("string"),
	OrgId:          pulumi.String("string"),
	ApiProducts: pulumi.StringArray{
		pulumi.String("string"),
	},
	AppFamily: pulumi.String("string"),
	Attributes: apigee.DeveloperAppAttributeArray{
		&apigee.DeveloperAppAttributeArgs{
			Name:  pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
	KeyExpiresIn: pulumi.String("string"),
	Name:         pulumi.String("string"),
	Scopes: pulumi.StringArray{
		pulumi.String("string"),
	},
	Status: pulumi.String("string"),
})

var developerAppResource = new DeveloperApp("developerAppResource", DeveloperAppArgs.builder()
    .callbackUrl("string")
    .developerEmail("string")
    .orgId("string")
    .apiProducts("string")
    .appFamily("string")
    .attributes(DeveloperAppAttributeArgs.builder()
        .name("string")
        .value("string")
        .build())
    .keyExpiresIn("string")
    .name("string")
    .scopes("string")
    .status("string")
    .build());

developer_app_resource = gcp.apigee.DeveloperApp("developerAppResource",
    callback_url="string",
    developer_email="string",
    org_id="string",
    api_products=["string"],
    app_family="string",
    attributes=[{
        "name": "string",
        "value": "string",
    }],
    key_expires_in="string",
    name="string",
    scopes=["string"],
    status="string")

const developerAppResource = new gcp.apigee.DeveloperApp("developerAppResource", {
    callbackUrl: "string",
    developerEmail: "string",
    orgId: "string",
    apiProducts: ["string"],
    appFamily: "string",
    attributes: [{
        name: "string",
        value: "string",
    }],
    keyExpiresIn: "string",
    name: "string",
    scopes: ["string"],
    status: "string",
});

type: gcp:apigee:DeveloperApp
properties:
    apiProducts:
        - string
    appFamily: string
    attributes:
        - name: string
          value: string
    callbackUrl: string
    developerEmail: string
    keyExpiresIn: string
    name: string
    orgId: string
    scopes:
        - string
    status: string