splight.Command

import * as pulumi from "@pulumi/pulumi";
import * as splight from "@splightplatform/pulumi-splight";

const myAsset = new splight.Asset("myAsset", {
    description: "My Asset Description",
    timezone: "America/Los_Angeles",
    geometry: JSON.stringify({
        type: "GeometryCollection",
        geometries: [{
            type: "Point",
            coordinates: [
                0,
                0,
            ],
        }],
    }),
});
const myAttribute = new splight.AssetAttribute("myAttribute", {
    type: "Number",
    unit: "meters",
    asset: myAsset.id,
});
const myAction = new splight.Action("myAction", {
    asset: {
        id: myAsset.id,
        name: myAsset.name,
    },
    setpoints: [{
        value: JSON.stringify(1),
        attribute: {
            id: myAttribute.id,
            name: myAttribute.name,
        },
    }],
});
const myCommand = new splight.Command("myCommand", {actions: [{
    id: myAction.id,
    name: myAction.name,
    asset: {
        id: myAsset.id,
        name: myAsset.name,
    },
}]});

import pulumi
import json
import pulumi_splight as splight

my_asset = splight.Asset("myAsset",
    description="My Asset Description",
    timezone="America/Los_Angeles",
    geometry=json.dumps({
        "type": "GeometryCollection",
        "geometries": [{
            "type": "Point",
            "coordinates": [
                0,
                0,
            ],
        }],
    }))
my_attribute = splight.AssetAttribute("myAttribute",
    type="Number",
    unit="meters",
    asset=my_asset.id)
my_action = splight.Action("myAction",
    asset={
        "id": my_asset.id,
        "name": my_asset.name,
    },
    setpoints=[{
        "value": json.dumps(1),
        "attribute": {
            "id": my_attribute.id,
            "name": my_attribute.name,
        },
    }])
my_command = splight.Command("myCommand", actions=[{
    "id": my_action.id,
    "name": my_action.name,
    "asset": {
        "id": my_asset.id,
        "name": my_asset.name,
    },
}])

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/splightplatform/pulumi-splight/sdk/go/splight"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"type": "GeometryCollection",
			"geometries": []map[string]interface{}{
				map[string]interface{}{
					"type": "Point",
					"coordinates": []float64{
						0,
						0,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		myAsset, err := splight.NewAsset(ctx, "myAsset", &splight.AssetArgs{
			Description: pulumi.String("My Asset Description"),
			Timezone:    pulumi.String("America/Los_Angeles"),
			Geometry:    pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		myAttribute, err := splight.NewAssetAttribute(ctx, "myAttribute", &splight.AssetAttributeArgs{
			Type:  pulumi.String("Number"),
			Unit:  pulumi.String("meters"),
			Asset: myAsset.ID(),
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(1)
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		myAction, err := splight.NewAction(ctx, "myAction", &splight.ActionArgs{
			Asset: &splight.ActionAssetArgs{
				Id:   myAsset.ID(),
				Name: myAsset.Name,
			},
			Setpoints: splight.ActionSetpointArray{
				&splight.ActionSetpointArgs{
					Value: pulumi.String(json1),
					Attribute: &splight.ActionSetpointAttributeArgs{
						Id:   myAttribute.ID(),
						Name: myAttribute.Name,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = splight.NewCommand(ctx, "myCommand", &splight.CommandArgs{
			Actions: splight.CommandActionArray{
				&splight.CommandActionArgs{
					Id:   myAction.ID(),
					Name: myAction.Name,
					Asset: &splight.CommandActionAssetArgs{
						Id:   myAsset.ID(),
						Name: myAsset.Name,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Splight = Splight.Splight;

return await Deployment.RunAsync(() => 
{
    var myAsset = new Splight.Asset("myAsset", new()
    {
        Description = "My Asset Description",
        Timezone = "America/Los_Angeles",
        Geometry = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["type"] = "GeometryCollection",
            ["geometries"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["type"] = "Point",
                    ["coordinates"] = new[]
                    {
                        0,
                        0,
                    },
                },
            },
        }),
    });

    var myAttribute = new Splight.AssetAttribute("myAttribute", new()
    {
        Type = "Number",
        Unit = "meters",
        Asset = myAsset.Id,
    });

    var myAction = new Splight.Action("myAction", new()
    {
        Asset = new Splight.Inputs.ActionAssetArgs
        {
            Id = myAsset.Id,
            Name = myAsset.Name,
        },
        Setpoints = new[]
        {
            new Splight.Inputs.ActionSetpointArgs
            {
                Value = JsonSerializer.Serialize(1),
                Attribute = new Splight.Inputs.ActionSetpointAttributeArgs
                {
                    Id = myAttribute.Id,
                    Name = myAttribute.Name,
                },
            },
        },
    });

    var myCommand = new Splight.Command("myCommand", new()
    {
        Actions = new[]
        {
            new Splight.Inputs.CommandActionArgs
            {
                Id = myAction.Id,
                Name = myAction.Name,
                Asset = new Splight.Inputs.CommandActionAssetArgs
                {
                    Id = myAsset.Id,
                    Name = myAsset.Name,
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.splight.Asset;
import com.pulumi.splight.AssetArgs;
import com.pulumi.splight.AssetAttribute;
import com.pulumi.splight.AssetAttributeArgs;
import com.pulumi.splight.Action;
import com.pulumi.splight.ActionArgs;
import com.pulumi.splight.inputs.ActionAssetArgs;
import com.pulumi.splight.inputs.ActionSetpointArgs;
import com.pulumi.splight.inputs.ActionSetpointAttributeArgs;
import com.pulumi.splight.Command;
import com.pulumi.splight.CommandArgs;
import com.pulumi.splight.inputs.CommandActionArgs;
import com.pulumi.splight.inputs.CommandActionAssetArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 myAsset = new Asset("myAsset", AssetArgs.builder()
            .description("My Asset Description")
            .timezone("America/Los_Angeles")
            .geometry(serializeJson(
                jsonObject(
                    jsonProperty("type", "GeometryCollection"),
                    jsonProperty("geometries", jsonArray(jsonObject(
                        jsonProperty("type", "Point"),
                        jsonProperty("coordinates", jsonArray(
                            0, 
                            0
                        ))
                    )))
                )))
            .build());

        var myAttribute = new AssetAttribute("myAttribute", AssetAttributeArgs.builder()
            .type("Number")
            .unit("meters")
            .asset(myAsset.id())
            .build());

        var myAction = new Action("myAction", ActionArgs.builder()
            .asset(ActionAssetArgs.builder()
                .id(myAsset.id())
                .name(myAsset.name())
                .build())
            .setpoints(ActionSetpointArgs.builder()
                .value(serializeJson(
                    1))
                .attribute(ActionSetpointAttributeArgs.builder()
                    .id(myAttribute.id())
                    .name(myAttribute.name())
                    .build())
                .build())
            .build());

        var myCommand = new Command("myCommand", CommandArgs.builder()
            .actions(CommandActionArgs.builder()
                .id(myAction.id())
                .name(myAction.name())
                .asset(CommandActionAssetArgs.builder()
                    .id(myAsset.id())
                    .name(myAsset.name())
                    .build())
                .build())
            .build());

    }
}

resources:
  myAsset:
    type: splight:Asset
    properties:
      description: My Asset Description
      timezone: America/Los_Angeles
      geometry:
        fn::toJSON:
          type: GeometryCollection
          geometries:
            - type: Point
              coordinates:
                - 0
                - 0
  myAttribute:
    type: splight:AssetAttribute
    properties:
      type: Number
      unit: meters
      asset: ${myAsset.id}
  myAction:
    type: splight:Action
    properties:
      asset:
        id: ${myAsset.id}
        name: ${myAsset.name}
      setpoints:
        - value:
            fn::toJSON: 1
          attribute:
            id: ${myAttribute.id}
            name: ${myAttribute.name}
  myCommand:
    type: splight:Command
    properties:
      actions:
        - id: ${myAction.id}
          name: ${myAction.name}
          asset:
            id: ${myAsset.id}
            name: ${myAsset.name}

var commandResource = new Splight.Command("commandResource", new()
{
    Actions = new[]
    {
        new Splight.Inputs.CommandActionArgs
        {
            Asset = new Splight.Inputs.CommandActionAssetArgs
            {
                Id = "string",
                Name = "string",
            },
            Id = "string",
            Name = "string",
        },
    },
    Description = "string",
    Name = "string",
});

example, err := splight.NewCommand(ctx, "commandResource", &splight.CommandArgs{
	Actions: splight.CommandActionArray{
		&splight.CommandActionArgs{
			Asset: &splight.CommandActionAssetArgs{
				Id:   pulumi.String("string"),
				Name: pulumi.String("string"),
			},
			Id:   pulumi.String("string"),
			Name: pulumi.String("string"),
		},
	},
	Description: pulumi.String("string"),
	Name:        pulumi.String("string"),
})

var commandResource = new Command("commandResource", CommandArgs.builder()
    .actions(CommandActionArgs.builder()
        .asset(CommandActionAssetArgs.builder()
            .id("string")
            .name("string")
            .build())
        .id("string")
        .name("string")
        .build())
    .description("string")
    .name("string")
    .build());

command_resource = splight.Command("commandResource",
    actions=[{
        "asset": {
            "id": "string",
            "name": "string",
        },
        "id": "string",
        "name": "string",
    }],
    description="string",
    name="string")

const commandResource = new splight.Command("commandResource", {
    actions: [{
        asset: {
            id: "string",
            name: "string",
        },
        id: "string",
        name: "string",
    }],
    description: "string",
    name: "string",
});

type: splight:Command
properties:
    actions:
        - asset:
            id: string
            name: string
          id: string
          name: string
    description: string
    name: string