commercetools.getState

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

const initialState = commercetools.getState({
    key: "Initial",
});
const backorder = new commercetools.State("backorder", {
    key: "backorder",
    type: "LineItemState",
    name: {
        en: "Back Order",
    },
    description: {
        en: "Not available - on back order",
    },
    initial: false,
});
const fromCreatedToAllocated = new commercetools.StateTransitions("fromCreatedToAllocated", {
    from: initialState.then(initialState => initialState.id),
    tos: [backorder.id],
});

import pulumi
import pulumi_commercetools as commercetools

initial_state = commercetools.get_state(key="Initial")
backorder = commercetools.State("backorder",
    key="backorder",
    type="LineItemState",
    name={
        "en": "Back Order",
    },
    description={
        "en": "Not available - on back order",
    },
    initial=False)
from_created_to_allocated = commercetools.StateTransitions("fromCreatedToAllocated",
    from_=initial_state.id,
    tos=[backorder.id])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		initialState, err := commercetools.LookupState(ctx, &commercetools.LookupStateArgs{
			Key: "Initial",
		}, nil)
		if err != nil {
			return err
		}
		backorder, err := commercetools.NewState(ctx, "backorder", &commercetools.StateArgs{
			Key:  pulumi.String("backorder"),
			Type: pulumi.String("LineItemState"),
			Name: pulumi.StringMap{
				"en": pulumi.String("Back Order"),
			},
			Description: pulumi.StringMap{
				"en": pulumi.String("Not available - on back order"),
			},
			Initial: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = commercetools.NewStateTransitions(ctx, "fromCreatedToAllocated", &commercetools.StateTransitionsArgs{
			From: pulumi.String(initialState.Id),
			Tos: pulumi.StringArray{
				backorder.ID(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var initialState = Commercetools.GetState.Invoke(new()
    {
        Key = "Initial",
    });

    var backorder = new Commercetools.State("backorder", new()
    {
        Key = "backorder",
        Type = "LineItemState",
        Name = 
        {
            { "en", "Back Order" },
        },
        Description = 
        {
            { "en", "Not available - on back order" },
        },
        Initial = false,
    });

    var fromCreatedToAllocated = new Commercetools.StateTransitions("fromCreatedToAllocated", new()
    {
        From = initialState.Apply(getStateResult => getStateResult.Id),
        Tos = new[]
        {
            backorder.Id,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.commercetools.CommercetoolsFunctions;
import com.pulumi.commercetools.inputs.GetStateArgs;
import com.pulumi.commercetools.State;
import com.pulumi.commercetools.StateArgs;
import com.pulumi.commercetools.StateTransitions;
import com.pulumi.commercetools.StateTransitionsArgs;
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 initialState = CommercetoolsFunctions.getState(GetStateArgs.builder()
            .key("Initial")
            .build());

        var backorder = new State("backorder", StateArgs.builder()
            .key("backorder")
            .type("LineItemState")
            .name(Map.of("en", "Back Order"))
            .description(Map.of("en", "Not available - on back order"))
            .initial(false)
            .build());

        var fromCreatedToAllocated = new StateTransitions("fromCreatedToAllocated", StateTransitionsArgs.builder()
            .from(initialState.applyValue(getStateResult -> getStateResult.id()))
            .tos(backorder.id())
            .build());

    }
}

resources:
  fromCreatedToAllocated:
    type: commercetools:StateTransitions
    properties:
      from: ${initialState.id}
      tos:
        - ${backorder.id}
  backorder:
    type: commercetools:State
    properties:
      key: backorder
      type: LineItemState
      name:
        en: Back Order
      description:
        en: Not available - on back order
      initial: false
variables:
  initialState:
    fn::invoke:
      function: commercetools:getState
      arguments:
        key: Initial

function getState(args: GetStateArgs, opts?: InvokeOptions): Promise<GetStateResult>
function getStateOutput(args: GetStateOutputArgs, opts?: InvokeOptions): Output<GetStateResult>

def get_state(key: Optional[str] = None,
              opts: Optional[InvokeOptions] = None) -> GetStateResult
def get_state_output(key: Optional[pulumi.Input[str]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[GetStateResult]

func LookupState(ctx *Context, args *LookupStateArgs, opts ...InvokeOption) (*LookupStateResult, error)
func LookupStateOutput(ctx *Context, args *LookupStateOutputArgs, opts ...InvokeOption) LookupStateResultOutput

public static class GetState 
{
    public static Task<GetStateResult> InvokeAsync(GetStateArgs args, InvokeOptions? opts = null)
    public static Output<GetStateResult> Invoke(GetStateInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetStateResult> getState(GetStateArgs args, InvokeOptions options)
public static Output<GetStateResult> getState(GetStateArgs args, InvokeOptions options)

fn::invoke:
  function: commercetools:index/getState:getState
  arguments:
    # arguments dictionary