incident.CatalogEntries

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

function tryOutput_(
	...fns: Array<() => pulumi.Input<any>>
): pulumi.Output<any> {
	if (fns.length === 0) {
		throw new Error("try: all parameters failed");
	}
	const [fn, ...rest] = fns;
	try {
		return pulumi.output(fn()).apply(result => result !== undefined ? result : tryOutput_(...rest));
	} catch {
		return tryOutput_(...rest);
	}
	throw new Error("try: all parameters failed");
}


function try_(
	...fns: Array<() => any>
): any {
	for (const fn of fns) {
		try {
			const result = fn();
			if (result === undefined) {
				continue;
			}
			return result;
		} catch (e) {
			continue;
		}
	}
	throw new Error("try: all parameters failed");
}


//###############################################################################
// Simple Example
//###############################################################################
const simpleExample = new incident.CatalogType("simple_example", {
    name: "Simple Example",
    description: "A simple example catalog type",
    sourceRepoUrl: "https://example.com/myrepo",
});
const exampleUrl = new incident.CatalogTypeAttribute("example_url", {
    catalogTypeId: simpleExample.id,
    name: "url",
    type: "String",
});
const simpleExampleCatalogEntries = new incident.CatalogEntries("simple_example", {
    catalogEntriesId: simpleExample.id,
    entries: {
        foo: {
            name: "Foo",
            attributeValues: exampleUrl.id.apply(id => {
                [id]: {
                    value: "https://example.com/foo",
                },
            }),
        },
        bar: {
            name: "Bar",
            attributeValues: exampleUrl.id.apply(id => {
                [id]: {
                    value: "https://example.com/bar",
                },
            }),
        },
    },
});
const catalog = .reduce((__obj, entry) => ({ ...__obj, [String(entry.uid)]: entry }), {});
// Define the catalog type, creating attributes that map to the values in the
// catalog data source.
const service = new incident.CatalogType("service", {
    name: "Service",
    description: "All services that we run at Example Org",
    sourceRepoUrl: "",
});
const serviceOwner = new incident.CatalogTypeAttribute("service_owner", {
    catalogTypeId: service.id,
    name: "Owner",
    type: "String",
});
const serviceDescription = new incident.CatalogTypeAttribute("service_description", {
    catalogTypeId: service.id,
    name: "Description",
    type: "String",
});
const serviceTags = new incident.CatalogTypeAttribute("service_tags", {
    catalogTypeId: service.id,
    name: "Tags",
    type: "String",
    array: true,
});
//###############################################################################
// Provision the entries
//###############################################################################
// This is where we create all the entries. If we have any entries in Service
// that are not defined in this resource, we will delete them.
const services = new incident.CatalogEntries("services", {
    catalogEntriesId: service.id,
    entries: Object.entries(catalog).sort().reduce((__obj, [externalId, entry]) => ({ ...__obj, [externalId]: {
        name: entry.metadata.name,
        aliases: [entry.metadata.name],
        attributeValues: pulumi.all([serviceOwner.id, tryOutput_(
            () => entry.spec.owner,
            () => null
        ), serviceDescription.id, tryOutput_(
            () => entry.metadata.description,
            () => null
        ), serviceTags.id, tryOutput_(
            () => entry.metadata.tags,
            () => null
        )]).apply(([serviceOwnerId, _try, serviceDescriptionId, _try1, serviceTagsId, _try2]) => Object.entries({
            [serviceOwnerId]: {
                value: _try,
            },
            [serviceDescriptionId]: {
                value: _try1,
            },
            [serviceTagsId]: {
                arrayValue: _try2,
            },
        }).sort().filter(([attribute, binding]) => try_(
            () => binding.value,
            () => binding.arrayValue
        ) != null).reduce((__obj, [attribute, binding]) => ({ ...__obj, [attribute]: binding }), {})),
    } }), {}),
});

import pulumi
import pulumi_incident as incident
import pulumi_std as std

def try_(*fns):
    for fn in fns:
        try:
            result = fn()
            return result
        except:
            continue
    return None


################################################################################
# Simple Example
################################################################################
simple_example = incident.CatalogType("simple_example",
    name="Simple Example",
    description="A simple example catalog type",
    source_repo_url="https://example.com/myrepo")
example_url = incident.CatalogTypeAttribute("example_url",
    catalog_type_id=simple_example.id,
    name="url",
    type="String")
simple_example_catalog_entries = incident.CatalogEntries("simple_example",
    catalog_entries_id=simple_example.id,
    entries={
        "foo": {
            "name": "Foo",
            "attribute_values": example_url.id.apply(lambda id: {
                id: {
                    "value": "https://example.com/foo",
                },
            }),
        },
        "bar": {
            "name": "Bar",
            "attribute_values": example_url.id.apply(lambda id: {
                id: {
                    "value": "https://example.com/bar",
                },
            }),
        },
    })
catalog = {str(entry["uid"]): entry for entry in std.jsondecode(input=std.file(input="catalog.json")["result"])["result"]}
# Define the catalog type, creating attributes that map to the values in the
# catalog data source.
service = incident.CatalogType("service",
    name="Service",
    description="All services that we run at Example Org",
    source_repo_url="")
service_owner = incident.CatalogTypeAttribute("service_owner",
    catalog_type_id=service.id,
    name="Owner",
    type="String")
service_description = incident.CatalogTypeAttribute("service_description",
    catalog_type_id=service.id,
    name="Description",
    type="String")
service_tags = incident.CatalogTypeAttribute("service_tags",
    catalog_type_id=service.id,
    name="Tags",
    type="String",
    array=True)
################################################################################
# Provision the entries
################################################################################
# This is where we create all the entries. If we have any entries in Service
# that are not defined in this resource, we will delete them.
services = incident.CatalogEntries("services",
    catalog_entries_id=service.id,
    entries={external_id: {
        "name": entry["metadata"]["name"],
        "aliases": [entry["metadata"]["name"]],
        "attribute_values": pulumi.Output.all(
            serviceOwnerId=service_owner.id,
            try_=try_(
                lambda: entry["spec"]["owner"],
                lambda: None
            ),
            serviceDescriptionId=service_description.id,
            try_1=try_(
                lambda: entry["metadata"]["description"],
                lambda: None
            ),
            serviceTagsId=service_tags.id,
            try_2=try_(
                lambda: entry["metadata"]["tags"],
                lambda: None
            )
).apply(lambda resolved_outputs: {attribute: binding for attribute, binding in sorted({
            resolved_outputs['serviceOwnerId']: {
                "value": resolved_outputs['try_'],
            },
            resolved_outputs['serviceDescriptionId']: {
                "value": resolved_outputs['try_1'],
            },
            resolved_outputs['serviceTagsId']: {
                "arrayValue": resolved_outputs['try_2'],
            },
        }.items()) if try_(
            lambda: binding["value"],
            lambda: binding["arrayValue"]
        ) is not None})
,
    } for externalId, entry in sorted(catalog.items())})

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

################################################################################
# Simple Example
################################################################################
resource "incident_catalogtype" "simple_example" {
  name            = "Simple Example"
  description     = "A simple example catalog type"
  source_repo_url = "https://example.com/myrepo"
}
resource "incident_catalogtypeattribute" "example_url" {
  catalog_type_id = incident_catalogtype.simple_example.id
  name            = "url"
  type            = "String"
}
resource "incident_catalogentries" "simple_example" {
  catalog_entries_id = incident_catalogtype.simple_example.id
  entries = {
    "foo" = {
      name = "Foo"
      attribute_values = {
        incident_catalogtypeattribute.example_url.id = {
          value = "https://example.com/foo"
        }
      }
    }
    "bar" = {
      name = "Bar"
      attribute_values = {
        incident_catalogtypeattribute.example_url.id = {
          value = "https://example.com/bar"
        }
      }
    }
  }
}
################################################################################
# Create the type
################################################################################
# Define the catalog type, creating attributes that map to the values in the
# catalog data source.
resource "incident_catalogtype" "service" {
  name            = "Service"
  description     = "All services that we run at Example Org"
  source_repo_url = ""
}
resource "incident_catalogtypeattribute" "service_owner" {
  catalog_type_id = incident_catalogtype.service.id
  name            = "Owner"
  type            = "String"
}
resource "incident_catalogtypeattribute" "service_description" {
  catalog_type_id = incident_catalogtype.service.id
  name            = "Description"
  type            = "String"
}
resource "incident_catalogtypeattribute" "service_tags" {
  catalog_type_id = incident_catalogtype.service.id
  name            = "Tags"
  type            = "String"
  array           = true
}
################################################################################
# Provision the entries
################################################################################
# This is where we create all the entries. If we have any entries in Service
# that are not defined in this resource, we will delete them.
resource "incident_catalogentries" "services" {
  catalog_entries_id = incident_catalogtype.service.id
  entries = {for externalId, entry in local.catalog : externalId => {
    "name"    = entry["metadata"]["name"]
    "aliases" = [entry["metadata"]["name"]]
    "attributeValues" = {for attribute, binding in {
      incident_catalogtypeattribute.service_owner.id = {
        "value" = try(entry["spec"]["owner"], null)
      }
      incident_catalogtypeattribute.service_description.id = {
        "value" = try(entry["metadata"]["description"], null)
      }
      incident_catalogtypeattribute.service_tags.id = {
        "arrayValue" = try(entry["metadata"]["tags"], null)
      }
    } : attribute => binding if try(binding.value, binding.arrayValue) != null}
  } }
}
locals {
  catalog = {for entry in jsondecode(file("catalog.json")) : entry["uid"] => entry}
}

var catalogEntriesResource = new Incident.CatalogEntries("catalogEntriesResource", new()
{
    CatalogEntriesId = "string",
    Entries = 
    {
        { "string", new Incident.Inputs.CatalogEntriesEntriesArgs
        {
            AttributeValues = 
            {
                { "string", new Incident.Inputs.CatalogEntriesEntriesAttributeValuesArgs
                {
                    ArrayValues = new[]
                    {
                        "string",
                    },
                    Value = "string",
                } },
            },
            Name = "string",
            Aliases = new[]
            {
                "string",
            },
            Id = "string",
            Rank = 0,
        } },
    },
    ManagedAttributes = new[]
    {
        "string",
    },
});

example, err := incident.NewCatalogEntries(ctx, "catalogEntriesResource", &incident.CatalogEntriesArgs{
	CatalogEntriesId: pulumi.String("string"),
	Entries: incident.CatalogEntriesEntriesMap{
		"string": &incident.CatalogEntriesEntriesArgs{
			AttributeValues: incident.CatalogEntriesEntriesAttributeValuesMap{
				"string": &incident.CatalogEntriesEntriesAttributeValuesArgs{
					ArrayValues: pulumi.StringArray{
						pulumi.String("string"),
					},
					Value: pulumi.String("string"),
				},
			},
			Name: pulumi.String("string"),
			Aliases: pulumi.StringArray{
				pulumi.String("string"),
			},
			Id:   pulumi.String("string"),
			Rank: pulumi.Int(0),
		},
	},
	ManagedAttributes: pulumi.StringArray{
		pulumi.String("string"),
	},
})

resource "incident_catalog_entries" "catalogEntriesResource" {
  lifecycle {
    create_before_destroy = true
  }
  catalog_entries_id = "string"
  entries = {
    "string" = {
      attribute_values = {
        "string" = {
          array_values = ["string"]
          value        = "string"
        }
      }
      name    = "string"
      aliases = ["string"]
      id      = "string"
      rank    = 0
    }
  }
  managed_attributes = ["string"]
}

var catalogEntriesResource = new CatalogEntries("catalogEntriesResource", CatalogEntriesArgs.builder()
    .catalogEntriesId("string")
    .entries(Map.of("string", CatalogEntriesEntriesArgs.builder()
        .attributeValues(Map.of("string", CatalogEntriesEntriesAttributeValuesArgs.builder()
            .arrayValues("string")
            .value("string")
            .build()))
        .name("string")
        .aliases("string")
        .id("string")
        .rank(0)
        .build()))
    .managedAttributes("string")
    .build());

catalog_entries_resource = incident.CatalogEntries("catalogEntriesResource",
    catalog_entries_id="string",
    entries={
        "string": {
            "attribute_values": {
                "string": {
                    "array_values": ["string"],
                    "value": "string",
                },
            },
            "name": "string",
            "aliases": ["string"],
            "id": "string",
            "rank": 0,
        },
    },
    managed_attributes=["string"])

const catalogEntriesResource = new incident.CatalogEntries("catalogEntriesResource", {
    catalogEntriesId: "string",
    entries: {
        string: {
            attributeValues: {
                string: {
                    arrayValues: ["string"],
                    value: "string",
                },
            },
            name: "string",
            aliases: ["string"],
            id: "string",
            rank: 0,
        },
    },
    managedAttributes: ["string"],
});

type: incident:CatalogEntries
properties:
    catalogEntriesId: string
    entries:
        string:
            aliases:
                - string
            attributeValues:
                string:
                    arrayValues:
                        - string
                    value: string
            id: string
            name: string
            rank: 0
    managedAttributes:
        - string