rootly.WorkflowTaskCreateJiraIssue

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

return await Deployment.RunAsync(() => 
{
    var jiraWorkflowIncident = new Rootly.WorkflowIncident("jiraWorkflowIncident", new()
    {
        Description = "Open Jira ticket whenever incident starts",
        TriggerParams = new Rootly.Inputs.WorkflowIncidentTriggerParamsArgs
        {
            Triggers = new[]
            {
                "incident_created",
            },
            IncidentConditionKind = "IS",
            IncidentKinds = new[]
            {
                "normal",
            },
            IncidentConditionStatus = "IS",
            IncidentStatuses = new[]
            {
                "started",
            },
        },
        Enabled = true,
    });

    var jiraWorkflowTaskCreateJiraIssue = new Rootly.WorkflowTaskCreateJiraIssue("jiraWorkflowTaskCreateJiraIssue", new()
    {
        WorkflowId = jiraWorkflowIncident.Id,
        SkipOnFailure = false,
        Enabled = true,
        TaskParams = new Rootly.Inputs.WorkflowTaskCreateJiraIssueTaskParamsArgs
        {
            Title = "{{ incident.title }}",
            Description = "{{ incident.summary }}",
            ProjectKey = "ROOT",
            IssueType = 
            {
                { "id", "10001" },
                { "name", "Task" },
            },
            Status = 
            {
                { "id", "10000" },
                { "name", "To Do" },
            },
            Labels = "{{ incident.environment_slugs | concat: incident.service_slugs | concat: incident.functionality_slugs | concat: incident.group_slugs | join: \",\" }}",
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		jiraWorkflowIncident, err := rootly.NewWorkflowIncident(ctx, "jiraWorkflowIncident", &rootly.WorkflowIncidentArgs{
			Description: pulumi.String("Open Jira ticket whenever incident starts"),
			TriggerParams: &rootly.WorkflowIncidentTriggerParamsArgs{
				Triggers: pulumi.StringArray{
					pulumi.String("incident_created"),
				},
				IncidentConditionKind: pulumi.String("IS"),
				IncidentKinds: pulumi.StringArray{
					pulumi.String("normal"),
				},
				IncidentConditionStatus: pulumi.String("IS"),
				IncidentStatuses: pulumi.StringArray{
					pulumi.String("started"),
				},
			},
			Enabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = rootly.NewWorkflowTaskCreateJiraIssue(ctx, "jiraWorkflowTaskCreateJiraIssue", &rootly.WorkflowTaskCreateJiraIssueArgs{
			WorkflowId:    jiraWorkflowIncident.ID(),
			SkipOnFailure: pulumi.Bool(false),
			Enabled:       pulumi.Bool(true),
			TaskParams: &rootly.WorkflowTaskCreateJiraIssueTaskParamsArgs{
				Title:       pulumi.String("{{ incident.title }}"),
				Description: pulumi.String("{{ incident.summary }}"),
				ProjectKey:  pulumi.String("ROOT"),
				IssueType: pulumi.Map{
					"id":   pulumi.Any("10001"),
					"name": pulumi.Any("Task"),
				},
				Status: pulumi.Map{
					"id":   pulumi.Any("10000"),
					"name": pulumi.Any("To Do"),
				},
				Labels: pulumi.String("{{ incident.environment_slugs | concat: incident.service_slugs | concat: incident.functionality_slugs | concat: incident.group_slugs | join: \",\" }}"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.rootly.WorkflowIncident;
import com.pulumi.rootly.WorkflowIncidentArgs;
import com.pulumi.rootly.inputs.WorkflowIncidentTriggerParamsArgs;
import com.pulumi.rootly.WorkflowTaskCreateJiraIssue;
import com.pulumi.rootly.WorkflowTaskCreateJiraIssueArgs;
import com.pulumi.rootly.inputs.WorkflowTaskCreateJiraIssueTaskParamsArgs;
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 jiraWorkflowIncident = new WorkflowIncident("jiraWorkflowIncident", WorkflowIncidentArgs.builder()        
            .description("Open Jira ticket whenever incident starts")
            .triggerParams(WorkflowIncidentTriggerParamsArgs.builder()
                .triggers("incident_created")
                .incidentConditionKind("IS")
                .incidentKinds("normal")
                .incidentConditionStatus("IS")
                .incidentStatuses("started")
                .build())
            .enabled(true)
            .build());

        var jiraWorkflowTaskCreateJiraIssue = new WorkflowTaskCreateJiraIssue("jiraWorkflowTaskCreateJiraIssue", WorkflowTaskCreateJiraIssueArgs.builder()        
            .workflowId(jiraWorkflowIncident.id())
            .skipOnFailure(false)
            .enabled(true)
            .taskParams(WorkflowTaskCreateJiraIssueTaskParamsArgs.builder()
                .title("{{ incident.title }}")
                .description("{{ incident.summary }}")
                .projectKey("ROOT")
                .issueType(Map.ofEntries(
                    Map.entry("id", "10001"),
                    Map.entry("name", "Task")
                ))
                .status(Map.ofEntries(
                    Map.entry("id", "10000"),
                    Map.entry("name", "To Do")
                ))
                .labels("{{ incident.environment_slugs | concat: incident.service_slugs | concat: incident.functionality_slugs | concat: incident.group_slugs | join: \",\" }}")
                .build())
            .build());

    }
}

import pulumi
import pulumi_rootly as rootly

jira_workflow_incident = rootly.WorkflowIncident("jiraWorkflowIncident",
    description="Open Jira ticket whenever incident starts",
    trigger_params=rootly.WorkflowIncidentTriggerParamsArgs(
        triggers=["incident_created"],
        incident_condition_kind="IS",
        incident_kinds=["normal"],
        incident_condition_status="IS",
        incident_statuses=["started"],
    ),
    enabled=True)
jira_workflow_task_create_jira_issue = rootly.WorkflowTaskCreateJiraIssue("jiraWorkflowTaskCreateJiraIssue",
    workflow_id=jira_workflow_incident.id,
    skip_on_failure=False,
    enabled=True,
    task_params=rootly.WorkflowTaskCreateJiraIssueTaskParamsArgs(
        title="{{ incident.title }}",
        description="{{ incident.summary }}",
        project_key="ROOT",
        issue_type={
            "id": "10001",
            "name": "Task",
        },
        status={
            "id": "10000",
            "name": "To Do",
        },
        labels="{{ incident.environment_slugs | concat: incident.service_slugs | concat: incident.functionality_slugs | concat: incident.group_slugs | join: \",\" }}",
    ))

resources:
  jiraWorkflowIncident:
    type: rootly:WorkflowIncident
    properties:
      description: Open Jira ticket whenever incident starts
      triggerParams:
        triggers:
          - incident_created
        incidentConditionKind: IS
        incidentKinds:
          - normal
        incidentConditionStatus: IS
        incidentStatuses:
          - started
      enabled: true
  jiraWorkflowTaskCreateJiraIssue:
    type: rootly:WorkflowTaskCreateJiraIssue
    properties:
      workflowId: ${jiraWorkflowIncident.id}
      skipOnFailure: false
      enabled: true
      taskParams:
        title: '{{ incident.title }}'
        description: '{{ incident.summary }}'
        projectKey: ROOT
        issueType:
          id: '10001'
          name: Task
        status:
          id: '10000'
          name: To Do
        labels: '{{ incident.environment_slugs | concat: incident.service_slugs | concat: incident.functionality_slugs | concat: incident.group_slugs | join: "," }}'