incident.getScheduleRotation

import * as pulumi from "@pulumi/pulumi";
import * as incident from "@incident-io/pulumi";

// Look up a rotation by name. Names are unique within a schedule, so this is
// unambiguous.
const primary = incident.getScheduleRotation({
    scheduleId: platformIncidentSchedule.id,
    name: "Primary",
});
// ...or by ID.
const primaryById = incident.getScheduleRotation({
    scheduleId: platformIncidentSchedule.id,
    id: "01MNO456PQR789STU012VWX",
});
// Useful for pointing an escalation path at one rotation rather than the whole
// schedule, when the rotation itself isn't managed here.
const platform = new incident.EscalationPath("platform", {
    name: "Platform",
    path: [{
        type: "level",
        level: {
            targets: [{
                type: "schedule",
                id: platformIncidentSchedule.id,
                urgency: "high",
                scheduleMode: "all_users_for_rota",
                selectedRotaId: primary.then(primary => primary.id),
            }],
        },
    }],
});

import pulumi
import pulumi_incident as incident

# Look up a rotation by name. Names are unique within a schedule, so this is
# unambiguous.
primary = incident.get_schedule_rotation(schedule_id=platform_incident_schedule["id"],
    name="Primary")
# ...or by ID.
primary_by_id = incident.get_schedule_rotation(schedule_id=platform_incident_schedule["id"],
    id="01MNO456PQR789STU012VWX")
# Useful for pointing an escalation path at one rotation rather than the whole
# schedule, when the rotation itself isn't managed here.
platform = incident.EscalationPath("platform",
    name="Platform",
    path=[{
        "type": "level",
        "level": {
            "targets": [{
                "type": "schedule",
                "id": platform_incident_schedule["id"],
                "urgency": "high",
                "scheduleMode": "all_users_for_rota",
                "selectedRotaId": primary.id,
            }],
        },
    }])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Look up a rotation by name. Names are unique within a schedule, so this is
		// unambiguous.
		primary, err := incident.GetScheduleRotation(ctx, &incident.LookupScheduleRotationArgs{
			ScheduleId: platformIncidentSchedule.Id,
			Name:       pulumi.StringRef("Primary"),
		}, nil)
		if err != nil {
			return err
		}
		// ...or by ID.
		_, err = incident.GetScheduleRotation(ctx, &incident.LookupScheduleRotationArgs{
			ScheduleId: platformIncidentSchedule.Id,
			Id:         pulumi.StringRef("01MNO456PQR789STU012VWX"),
		}, nil)
		if err != nil {
			return err
		}
		// Useful for pointing an escalation path at one rotation rather than the whole
		// schedule, when the rotation itself isn't managed here.
		_, err = incident.NewEscalationPath(ctx, "platform", &incident.EscalationPathArgs{
			Name: pulumi.String("Platform"),
			Path: []map[string]interface{}{
				map[string]interface{}{
					"type": "level",
					"level": map[string][]map[string]interface{}{
						"targets": []map[string]interface{}{
							map[string]interface{}{
								"type":           "schedule",
								"id":             platformIncidentSchedule.Id,
								"urgency":        "high",
								"scheduleMode":   "all_users_for_rota",
								"selectedRotaId": primary.Id,
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Look up a rotation by name. Names are unique within a schedule, so this is
    // unambiguous.
    var primary = Incident.GetScheduleRotation.Invoke(new()
    {
        ScheduleId = platformIncidentSchedule.Id,
        Name = "Primary",
    });

    // ...or by ID.
    var primaryById = Incident.GetScheduleRotation.Invoke(new()
    {
        ScheduleId = platformIncidentSchedule.Id,
        Id = "01MNO456PQR789STU012VWX",
    });

    // Useful for pointing an escalation path at one rotation rather than the whole
    // schedule, when the rotation itself isn't managed here.
    var platform = new Incident.EscalationPath("platform", new()
    {
        Name = "Platform",
        Path = new[]
        {
            
            {
                { "type", "level" },
                { "level", 
                {
                    { "targets", new[]
                    {
                        
                        {
                            { "type", "schedule" },
                            { "id", platformIncidentSchedule.Id },
                            { "urgency", "high" },
                            { "scheduleMode", "all_users_for_rota" },
                            { "selectedRotaId", primary.Apply(getScheduleRotationResult => getScheduleRotationResult.Id) },
                        },
                    } },
                } },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.IncidentFunctions;
import com.pulumi.incident.inputs.GetScheduleRotationArgs;
import com.pulumi.incident.EscalationPath;
import com.pulumi.incident.EscalationPathArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Look up a rotation by name. Names are unique within a schedule, so this is
        // unambiguous.
        final var primary = IncidentFunctions.getScheduleRotation(GetScheduleRotationArgs.builder()
            .scheduleId(platformIncidentSchedule.id())
            .name("Primary")
            .build());

        // ...or by ID.
        final var primaryById = IncidentFunctions.getScheduleRotation(GetScheduleRotationArgs.builder()
            .scheduleId(platformIncidentSchedule.id())
            .id("01MNO456PQR789STU012VWX")
            .build());

        // Useful for pointing an escalation path at one rotation rather than the whole
        // schedule, when the rotation itself isn't managed here.
        var platform = new EscalationPath("platform", EscalationPathArgs.builder()
            .name("Platform")
            .path(Arrays.asList(Map.ofEntries(
                Map.entry("type", "level"),
                Map.entry("level", Map.of("targets", Arrays.asList(Map.ofEntries(
                    Map.entry("type", "schedule"),
                    Map.entry("id", platformIncidentSchedule.id()),
                    Map.entry("urgency", "high"),
                    Map.entry("scheduleMode", "all_users_for_rota"),
                    Map.entry("selectedRotaId", primary.id())
                ))))
            )))
            .build());

    }
}

resources:
  # Useful for pointing an escalation path at one rotation rather than the whole
  # schedule, when the rotation itself isn't managed here.
  platform:
    type: incident:EscalationPath
    properties:
      name: Platform
      path:
        - type: level
          level:
            targets:
              - type: schedule
                id: ${platformIncidentSchedule.id}
                urgency: high
                scheduleMode: all_users_for_rota
                selectedRotaId: ${primary.id}
variables:
  # Look up a rotation by name. Names are unique within a schedule, so this is
  # unambiguous.
  primary:
    fn::invoke:
      function: incident:getScheduleRotation
      arguments:
        scheduleId: ${platformIncidentSchedule.id}
        name: Primary
  # ...or by ID.
  primaryById:
    fn::invoke:
      function: incident:getScheduleRotation
      arguments:
        scheduleId: ${platformIncidentSchedule.id}
        id: 01MNO456PQR789STU012VWX

pulumi {
  required_providers {
    incident = {
      source = "pulumi/incident"
    }
  }
}

data "incident_getschedulerotation" "primary" {
  schedule_id = platformIncidentSchedule.id
  name        = "Primary"
}
data "incident_getschedulerotation" "primaryById" {
  schedule_id = platformIncidentSchedule.id
  id          = "01MNO456PQR789STU012VWX"
}

# Useful for pointing an escalation path at one rotation rather than the whole
# schedule, when the rotation itself isn't managed here.
resource "incident_escalationpath" "platform" {
  name = "Platform"
  path = [{
    "type" = "level"
    "level" = {
      "targets" = [{
        "type"           = "schedule"
        "id"             = platformIncidentSchedule.id
        "urgency"        = "high"
        "scheduleMode"   = "all_users_for_rota"
        "selectedRotaId" = data.incident_getschedulerotation.primary.id
      }]
    }
  }]
}
# Look up a rotation by name. Names are unique within a schedule, so this is
# unambiguous.
# ...or by ID.

function getScheduleRotation(args: GetScheduleRotationArgs, opts?: InvokeOptions): Promise<GetScheduleRotationResult>
function getScheduleRotationOutput(args: GetScheduleRotationOutputArgs, opts?: InvokeOutputOptions): Output<GetScheduleRotationResult>

def get_schedule_rotation(id: Optional[str] = None,
                          name: Optional[str] = None,
                          schedule_id: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetScheduleRotationResult
def get_schedule_rotation_output(id: pulumi.Input[Optional[str]] = None,
                          name: pulumi.Input[Optional[str]] = None,
                          schedule_id: pulumi.Input[Optional[str]] = None,
                          opts: Optional[InvokeOutputOptions] = None) -> Output[GetScheduleRotationResult]

func LookupScheduleRotation(ctx *Context, args *LookupScheduleRotationArgs, opts ...InvokeOption) (*LookupScheduleRotationResult, error)
func LookupScheduleRotationOutput(ctx *Context, args *LookupScheduleRotationOutputArgs, opts ...InvokeOption) LookupScheduleRotationResultOutput

public static class GetScheduleRotation 
{
    public static Task<GetScheduleRotationResult> InvokeAsync(GetScheduleRotationArgs args, InvokeOptions? opts = null)
    public static Output<GetScheduleRotationResult> Invoke(GetScheduleRotationInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetScheduleRotationResult> Invoke(GetScheduleRotationInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetScheduleRotationResult> getScheduleRotation(GetScheduleRotationArgs args, InvokeOptions options)
public static Output<GetScheduleRotationResult> getScheduleRotation(GetScheduleRotationArgs args, InvokeOptions options)
public static Output<GetScheduleRotationResult> getScheduleRotation(GetScheduleRotationArgs args, InvokeOutputOptions options)

fn::invoke:
  function: incident:index/getScheduleRotation:getScheduleRotation
  arguments:
    # arguments dictionary

data "incident_get_schedule_rotation" "name" {
    # arguments
}