grafana.OncallIntegration

import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const test_acc_integration = new grafana.oncall.Integration("test-acc-integration", {
    name: "my integration",
    type: "grafana",
    defaultRoute: {},
});
// Also it's possible to manage integration templates.
// Check docs to see all available templates.
const integrationWithTemplates = new grafana.oncall.Integration("integration_with_templates", {
    name: "integration_with_templates",
    type: "webhook",
    defaultRoute: {},
    templates: {
        groupingKey: "{{ payload.group_id }}",
        slack: {
            title: "Slack title",
            message: `This is example of multiline template
{{ payload.message }}
`,
            imageUrl: "{{ payload.image_url }}",
        },
    },
});

import pulumi
import pulumiverse_grafana as grafana

test_acc_integration = grafana.on_call.Integration("test-acc-integration",
    name="my integration",
    type="grafana",
    default_route={})
# Also it's possible to manage integration templates.
# Check docs to see all available templates.
integration_with_templates = grafana.on_call.Integration("integration_with_templates",
    name="integration_with_templates",
    type="webhook",
    default_route={},
    templates={
        "grouping_key": "{{ payload.group_id }}",
        "slack": {
            "title": "Slack title",
            "message": """This is example of multiline template
{{ payload.message }}
""",
            "image_url": "{{ payload.image_url }}",
        },
    })

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/onCall"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := onCall.NewIntegration(ctx, "test-acc-integration", &onCall.IntegrationArgs{
			Name:         pulumi.String("my integration"),
			Type:         pulumi.String("grafana"),
			DefaultRoute: &oncall.IntegrationDefaultRouteArgs{},
		})
		if err != nil {
			return err
		}
		// Also it's possible to manage integration templates.
		// Check docs to see all available templates.
		_, err = onCall.NewIntegration(ctx, "integration_with_templates", &onCall.IntegrationArgs{
			Name:         pulumi.String("integration_with_templates"),
			Type:         pulumi.String("webhook"),
			DefaultRoute: &oncall.IntegrationDefaultRouteArgs{},
			Templates: &oncall.IntegrationTemplatesArgs{
				GroupingKey: pulumi.String("{{ payload.group_id }}"),
				Slack: &oncall.IntegrationTemplatesSlackArgs{
					Title:    pulumi.String("Slack title"),
					Message:  pulumi.String("This is example of multiline template\n{{ payload.message }}\n"),
					ImageUrl: pulumi.String("{{ payload.image_url }}"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var test_acc_integration = new Grafana.OnCall.Integration("test-acc-integration", new()
    {
        Name = "my integration",
        Type = "grafana",
        DefaultRoute = null,
    });

    // Also it's possible to manage integration templates.
    // Check docs to see all available templates.
    var integrationWithTemplates = new Grafana.OnCall.Integration("integration_with_templates", new()
    {
        Name = "integration_with_templates",
        Type = "webhook",
        DefaultRoute = null,
        Templates = new Grafana.OnCall.Inputs.IntegrationTemplatesArgs
        {
            GroupingKey = "{{ payload.group_id }}",
            Slack = new Grafana.OnCall.Inputs.IntegrationTemplatesSlackArgs
            {
                Title = "Slack title",
                Message = @"This is example of multiline template
{{ payload.message }}
",
                ImageUrl = "{{ payload.image_url }}",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.onCall.Integration;
import com.pulumi.grafana.onCall.IntegrationArgs;
import com.pulumi.grafana.onCall.inputs.IntegrationDefaultRouteArgs;
import com.pulumi.grafana.onCall.inputs.IntegrationTemplatesArgs;
import com.pulumi.grafana.onCall.inputs.IntegrationTemplatesSlackArgs;
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 test_acc_integration = new Integration("test-acc-integration", IntegrationArgs.builder()
            .name("my integration")
            .type("grafana")
            .defaultRoute()
            .build());

        // Also it's possible to manage integration templates.
        // Check docs to see all available templates.
        var integrationWithTemplates = new Integration("integrationWithTemplates", IntegrationArgs.builder()
            .name("integration_with_templates")
            .type("webhook")
            .defaultRoute()
            .templates(IntegrationTemplatesArgs.builder()
                .groupingKey("{{ payload.group_id }}")
                .slack(IntegrationTemplatesSlackArgs.builder()
                    .title("Slack title")
                    .message("""
This is example of multiline template
{{ payload.message }}
                    """)
                    .imageUrl("{{ payload.image_url }}")
                    .build())
                .build())
            .build());

    }
}

resources:
  test-acc-integration:
    type: grafana:onCall:Integration
    properties:
      name: my integration
      type: grafana
      defaultRoute: {}
  # Also it's possible to manage integration templates.
  # Check docs to see all available templates.
  integrationWithTemplates:
    type: grafana:onCall:Integration
    name: integration_with_templates
    properties:
      name: integration_with_templates
      type: webhook
      defaultRoute: {}
      templates:
        groupingKey: '{{ payload.group_id }}'
        slack:
          title: Slack title
          message: |
            This is example of multiline template
            {{ payload.message }}            
          imageUrl: '{{ payload.image_url }}'