azure.datafactory.CustomDataset

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const exampleFactory = new azure.datafactory.Factory("example", {
    name: "example",
    location: example.location,
    resourceGroupName: example.name,
    identity: {
        type: "SystemAssigned",
    },
});
const exampleAccount = new azure.storage.Account("example", {
    name: "example",
    resourceGroupName: example.name,
    location: example.location,
    accountKind: "BlobStorage",
    accountTier: "Standard",
    accountReplicationType: "LRS",
});
const exampleLinkedCustomService = new azure.datafactory.LinkedCustomService("example", {
    name: "example",
    dataFactoryId: exampleFactory.id,
    type: "AzureBlobStorage",
    typePropertiesJson: pulumi.interpolate`{
  "connectionString":"${exampleAccount.primaryConnectionString}"
}
`,
});
const exampleContainer = new azure.storage.Container("example", {
    name: "content",
    storageAccountName: exampleAccount.name,
    containerAccessType: "private",
});
const exampleCustomDataset = new azure.datafactory.CustomDataset("example", {
    name: "example",
    dataFactoryId: exampleFactory.id,
    type: "Json",
    linkedService: {
        name: exampleLinkedCustomService.name,
        parameters: {
            key1: "value1",
        },
    },
    typePropertiesJson: pulumi.interpolate`{
  "location": {
    "container":"${exampleContainer.name}",
    "fileName":"foo.txt",
    "folderPath": "foo/bar/",
    "type":"AzureBlobStorageLocation"
  },
  "encodingName":"UTF-8"
}
`,
    description: "test description",
    annotations: [
        "test1",
        "test2",
        "test3",
    ],
    folder: "testFolder",
    parameters: {
        foo: "test1",
        Bar: "Test2",
    },
    additionalProperties: {
        foo: "test1",
        bar: "test2",
    },
    schemaJson: `{
  "type": "object",
  "properties": {
    "name": {
      "type": "object",
      "properties": {
        "firstName": {
          "type": "string"
        },
        "lastName": {
          "type": "string"
        }
      }
    },
    "age": {
      "type": "integer"
    }
  }
}
`,
});

import pulumi
import pulumi_azure as azure

example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example_factory = azure.datafactory.Factory("example",
    name="example",
    location=example.location,
    resource_group_name=example.name,
    identity={
        "type": "SystemAssigned",
    })
example_account = azure.storage.Account("example",
    name="example",
    resource_group_name=example.name,
    location=example.location,
    account_kind="BlobStorage",
    account_tier="Standard",
    account_replication_type="LRS")
example_linked_custom_service = azure.datafactory.LinkedCustomService("example",
    name="example",
    data_factory_id=example_factory.id,
    type="AzureBlobStorage",
    type_properties_json=example_account.primary_connection_string.apply(lambda primary_connection_string: f"""{{
  "connectionString":"{primary_connection_string}"
}}
"""))
example_container = azure.storage.Container("example",
    name="content",
    storage_account_name=example_account.name,
    container_access_type="private")
example_custom_dataset = azure.datafactory.CustomDataset("example",
    name="example",
    data_factory_id=example_factory.id,
    type="Json",
    linked_service={
        "name": example_linked_custom_service.name,
        "parameters": {
            "key1": "value1",
        },
    },
    type_properties_json=example_container.name.apply(lambda name: f"""{{
  "location": {{
    "container":"{name}",
    "fileName":"foo.txt",
    "folderPath": "foo/bar/",
    "type":"AzureBlobStorageLocation"
  }},
  "encodingName":"UTF-8"
}}
"""),
    description="test description",
    annotations=[
        "test1",
        "test2",
        "test3",
    ],
    folder="testFolder",
    parameters={
        "foo": "test1",
        "Bar": "Test2",
    },
    additional_properties={
        "foo": "test1",
        "bar": "test2",
    },
    schema_json="""{
  "type": "object",
  "properties": {
    "name": {
      "type": "object",
      "properties": {
        "firstName": {
          "type": "string"
        },
        "lastName": {
          "type": "string"
        }
      }
    },
    "age": {
      "type": "integer"
    }
  }
}
""")

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/datafactory"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleFactory, err := datafactory.NewFactory(ctx, "example", &datafactory.FactoryArgs{
			Name:              pulumi.String("example"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			Identity: &datafactory.FactoryIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "example", &storage.AccountArgs{
			Name:                   pulumi.String("example"),
			ResourceGroupName:      example.Name,
			Location:               example.Location,
			AccountKind:            pulumi.String("BlobStorage"),
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleLinkedCustomService, err := datafactory.NewLinkedCustomService(ctx, "example", &datafactory.LinkedCustomServiceArgs{
			Name:          pulumi.String("example"),
			DataFactoryId: exampleFactory.ID(),
			Type:          pulumi.String("AzureBlobStorage"),
			TypePropertiesJson: exampleAccount.PrimaryConnectionString.ApplyT(func(primaryConnectionString string) (string, error) {
				return fmt.Sprintf("{\n  \"connectionString\":\"%v\"\n}\n", primaryConnectionString), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		exampleContainer, err := storage.NewContainer(ctx, "example", &storage.ContainerArgs{
			Name:                pulumi.String("content"),
			StorageAccountName:  exampleAccount.Name,
			ContainerAccessType: pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		_, err = datafactory.NewCustomDataset(ctx, "example", &datafactory.CustomDatasetArgs{
			Name:          pulumi.String("example"),
			DataFactoryId: exampleFactory.ID(),
			Type:          pulumi.String("Json"),
			LinkedService: &datafactory.CustomDatasetLinkedServiceArgs{
				Name: exampleLinkedCustomService.Name,
				Parameters: pulumi.StringMap{
					"key1": pulumi.String("value1"),
				},
			},
			TypePropertiesJson: exampleContainer.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf(`{
  "location": {
    "container":"%v",
    "fileName":"foo.txt",
    "folderPath": "foo/bar/",
    "type":"AzureBlobStorageLocation"
  },
  "encodingName":"UTF-8"
}
`, name), nil
			}).(pulumi.StringOutput),
			Description: pulumi.String("test description"),
			Annotations: pulumi.StringArray{
				pulumi.String("test1"),
				pulumi.String("test2"),
				pulumi.String("test3"),
			},
			Folder: pulumi.String("testFolder"),
			Parameters: pulumi.StringMap{
				"foo": pulumi.String("test1"),
				"Bar": pulumi.String("Test2"),
			},
			AdditionalProperties: pulumi.StringMap{
				"foo": pulumi.String("test1"),
				"bar": pulumi.String("test2"),
			},
			SchemaJson: pulumi.String(`{
  "type": "object",
  "properties": {
    "name": {
      "type": "object",
      "properties": {
        "firstName": {
          "type": "string"
        },
        "lastName": {
          "type": "string"
        }
      }
    },
    "age": {
      "type": "integer"
    }
  }
}
`),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });

    var exampleFactory = new Azure.DataFactory.Factory("example", new()
    {
        Name = "example",
        Location = example.Location,
        ResourceGroupName = example.Name,
        Identity = new Azure.DataFactory.Inputs.FactoryIdentityArgs
        {
            Type = "SystemAssigned",
        },
    });

    var exampleAccount = new Azure.Storage.Account("example", new()
    {
        Name = "example",
        ResourceGroupName = example.Name,
        Location = example.Location,
        AccountKind = "BlobStorage",
        AccountTier = "Standard",
        AccountReplicationType = "LRS",
    });

    var exampleLinkedCustomService = new Azure.DataFactory.LinkedCustomService("example", new()
    {
        Name = "example",
        DataFactoryId = exampleFactory.Id,
        Type = "AzureBlobStorage",
        TypePropertiesJson = exampleAccount.PrimaryConnectionString.Apply(primaryConnectionString => @$"{{
  ""connectionString"":""{primaryConnectionString}""
}}
"),
    });

    var exampleContainer = new Azure.Storage.Container("example", new()
    {
        Name = "content",
        StorageAccountName = exampleAccount.Name,
        ContainerAccessType = "private",
    });

    var exampleCustomDataset = new Azure.DataFactory.CustomDataset("example", new()
    {
        Name = "example",
        DataFactoryId = exampleFactory.Id,
        Type = "Json",
        LinkedService = new Azure.DataFactory.Inputs.CustomDatasetLinkedServiceArgs
        {
            Name = exampleLinkedCustomService.Name,
            Parameters = 
            {
                { "key1", "value1" },
            },
        },
        TypePropertiesJson = exampleContainer.Name.Apply(name => @$"{{
  ""location"": {{
    ""container"":""{name}"",
    ""fileName"":""foo.txt"",
    ""folderPath"": ""foo/bar/"",
    ""type"":""AzureBlobStorageLocation""
  }},
  ""encodingName"":""UTF-8""
}}
"),
        Description = "test description",
        Annotations = new[]
        {
            "test1",
            "test2",
            "test3",
        },
        Folder = "testFolder",
        Parameters = 
        {
            { "foo", "test1" },
            { "Bar", "Test2" },
        },
        AdditionalProperties = 
        {
            { "foo", "test1" },
            { "bar", "test2" },
        },
        SchemaJson = @"{
  ""type"": ""object"",
  ""properties"": {
    ""name"": {
      ""type"": ""object"",
      ""properties"": {
        ""firstName"": {
          ""type"": ""string""
        },
        ""lastName"": {
          ""type"": ""string""
        }
      }
    },
    ""age"": {
      ""type"": ""integer""
    }
  }
}
",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.datafactory.Factory;
import com.pulumi.azure.datafactory.FactoryArgs;
import com.pulumi.azure.datafactory.inputs.FactoryIdentityArgs;
import com.pulumi.azure.storage.Account;
import com.pulumi.azure.storage.AccountArgs;
import com.pulumi.azure.datafactory.LinkedCustomService;
import com.pulumi.azure.datafactory.LinkedCustomServiceArgs;
import com.pulumi.azure.storage.Container;
import com.pulumi.azure.storage.ContainerArgs;
import com.pulumi.azure.datafactory.CustomDataset;
import com.pulumi.azure.datafactory.CustomDatasetArgs;
import com.pulumi.azure.datafactory.inputs.CustomDatasetLinkedServiceArgs;
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 example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());

        var exampleFactory = new Factory("exampleFactory", FactoryArgs.builder()
            .name("example")
            .location(example.location())
            .resourceGroupName(example.name())
            .identity(FactoryIdentityArgs.builder()
                .type("SystemAssigned")
                .build())
            .build());

        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
            .name("example")
            .resourceGroupName(example.name())
            .location(example.location())
            .accountKind("BlobStorage")
            .accountTier("Standard")
            .accountReplicationType("LRS")
            .build());

        var exampleLinkedCustomService = new LinkedCustomService("exampleLinkedCustomService", LinkedCustomServiceArgs.builder()
            .name("example")
            .dataFactoryId(exampleFactory.id())
            .type("AzureBlobStorage")
            .typePropertiesJson(exampleAccount.primaryConnectionString().applyValue(primaryConnectionString -> """
{
  "connectionString":"%s"
}
", primaryConnectionString)))
            .build());

        var exampleContainer = new Container("exampleContainer", ContainerArgs.builder()
            .name("content")
            .storageAccountName(exampleAccount.name())
            .containerAccessType("private")
            .build());

        var exampleCustomDataset = new CustomDataset("exampleCustomDataset", CustomDatasetArgs.builder()
            .name("example")
            .dataFactoryId(exampleFactory.id())
            .type("Json")
            .linkedService(CustomDatasetLinkedServiceArgs.builder()
                .name(exampleLinkedCustomService.name())
                .parameters(Map.of("key1", "value1"))
                .build())
            .typePropertiesJson(exampleContainer.name().applyValue(name -> """
{
  "location": {
    "container":"%s",
    "fileName":"foo.txt",
    "folderPath": "foo/bar/",
    "type":"AzureBlobStorageLocation"
  },
  "encodingName":"UTF-8"
}
", name)))
            .description("test description")
            .annotations(            
                "test1",
                "test2",
                "test3")
            .folder("testFolder")
            .parameters(Map.ofEntries(
                Map.entry("foo", "test1"),
                Map.entry("Bar", "Test2")
            ))
            .additionalProperties(Map.ofEntries(
                Map.entry("foo", "test1"),
                Map.entry("bar", "test2")
            ))
            .schemaJson("""
{
  "type": "object",
  "properties": {
    "name": {
      "type": "object",
      "properties": {
        "firstName": {
          "type": "string"
        },
        "lastName": {
          "type": "string"
        }
      }
    },
    "age": {
      "type": "integer"
    }
  }
}
            """)
            .build());

    }
}

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  exampleFactory:
    type: azure:datafactory:Factory
    name: example
    properties:
      name: example
      location: ${example.location}
      resourceGroupName: ${example.name}
      identity:
        type: SystemAssigned
  exampleAccount:
    type: azure:storage:Account
    name: example
    properties:
      name: example
      resourceGroupName: ${example.name}
      location: ${example.location}
      accountKind: BlobStorage
      accountTier: Standard
      accountReplicationType: LRS
  exampleLinkedCustomService:
    type: azure:datafactory:LinkedCustomService
    name: example
    properties:
      name: example
      dataFactoryId: ${exampleFactory.id}
      type: AzureBlobStorage
      typePropertiesJson: |
        {
          "connectionString":"${exampleAccount.primaryConnectionString}"
        }        
  exampleContainer:
    type: azure:storage:Container
    name: example
    properties:
      name: content
      storageAccountName: ${exampleAccount.name}
      containerAccessType: private
  exampleCustomDataset:
    type: azure:datafactory:CustomDataset
    name: example
    properties:
      name: example
      dataFactoryId: ${exampleFactory.id}
      type: Json
      linkedService:
        name: ${exampleLinkedCustomService.name}
        parameters:
          key1: value1
      typePropertiesJson: |
        {
          "location": {
            "container":"${exampleContainer.name}",
            "fileName":"foo.txt",
            "folderPath": "foo/bar/",
            "type":"AzureBlobStorageLocation"
          },
          "encodingName":"UTF-8"
        }        
      description: test description
      annotations:
        - test1
        - test2
        - test3
      folder: testFolder
      parameters:
        foo: test1
        Bar: Test2
      additionalProperties:
        foo: test1
        bar: test2
      schemaJson: |
        {
          "type": "object",
          "properties": {
            "name": {
              "type": "object",
              "properties": {
                "firstName": {
                  "type": "string"
                },
                "lastName": {
                  "type": "string"
                }
              }
            },
            "age": {
              "type": "integer"
            }
          }
        }        

var customDatasetResource = new Azure.DataFactory.CustomDataset("customDatasetResource", new()
{
    DataFactoryId = "string",
    LinkedService = new Azure.DataFactory.Inputs.CustomDatasetLinkedServiceArgs
    {
        Name = "string",
        Parameters = 
        {
            { "string", "string" },
        },
    },
    Type = "string",
    TypePropertiesJson = "string",
    AdditionalProperties = 
    {
        { "string", "string" },
    },
    Annotations = new[]
    {
        "string",
    },
    Description = "string",
    Folder = "string",
    Name = "string",
    Parameters = 
    {
        { "string", "string" },
    },
    SchemaJson = "string",
});

example, err := datafactory.NewCustomDataset(ctx, "customDatasetResource", &datafactory.CustomDatasetArgs{
	DataFactoryId: pulumi.String("string"),
	LinkedService: &datafactory.CustomDatasetLinkedServiceArgs{
		Name: pulumi.String("string"),
		Parameters: pulumi.StringMap{
			"string": pulumi.String("string"),
		},
	},
	Type:               pulumi.String("string"),
	TypePropertiesJson: pulumi.String("string"),
	AdditionalProperties: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Annotations: pulumi.StringArray{
		pulumi.String("string"),
	},
	Description: pulumi.String("string"),
	Folder:      pulumi.String("string"),
	Name:        pulumi.String("string"),
	Parameters: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	SchemaJson: pulumi.String("string"),
})

var customDatasetResource = new CustomDataset("customDatasetResource", CustomDatasetArgs.builder()
    .dataFactoryId("string")
    .linkedService(CustomDatasetLinkedServiceArgs.builder()
        .name("string")
        .parameters(Map.of("string", "string"))
        .build())
    .type("string")
    .typePropertiesJson("string")
    .additionalProperties(Map.of("string", "string"))
    .annotations("string")
    .description("string")
    .folder("string")
    .name("string")
    .parameters(Map.of("string", "string"))
    .schemaJson("string")
    .build());

custom_dataset_resource = azure.datafactory.CustomDataset("customDatasetResource",
    data_factory_id="string",
    linked_service={
        "name": "string",
        "parameters": {
            "string": "string",
        },
    },
    type="string",
    type_properties_json="string",
    additional_properties={
        "string": "string",
    },
    annotations=["string"],
    description="string",
    folder="string",
    name="string",
    parameters={
        "string": "string",
    },
    schema_json="string")

const customDatasetResource = new azure.datafactory.CustomDataset("customDatasetResource", {
    dataFactoryId: "string",
    linkedService: {
        name: "string",
        parameters: {
            string: "string",
        },
    },
    type: "string",
    typePropertiesJson: "string",
    additionalProperties: {
        string: "string",
    },
    annotations: ["string"],
    description: "string",
    folder: "string",
    name: "string",
    parameters: {
        string: "string",
    },
    schemaJson: "string",
});

type: azure:datafactory:CustomDataset
properties:
    additionalProperties:
        string: string
    annotations:
        - string
    dataFactoryId: string
    description: string
    folder: string
    linkedService:
        name: string
        parameters:
            string: string
    name: string
    parameters:
        string: string
    schemaJson: string
    type: string
    typePropertiesJson: string