dbtcloud.Job

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

// a job that has github_webhook and git_provider_webhook 
// set to false will be categorized as a "Deploy Job"
const dailyJob = new dbtcloud.Job("daily_job", {
    environmentId: prodEnvironment.environmentId,
    executeSteps: ["dbt build"],
    generateDocs: true,
    isActive: true,
    name: "Daily job",
    numThreads: 64,
    projectId: dbtProject.id,
    runGenerateSources: true,
    targetName: "default",
    triggers: {
        github_webhook: false,
        git_provider_webhook: false,
        schedule: true,
        on_merge: false,
    },
    scheduleDays: [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
    ],
    scheduleType: "days_of_week",
    scheduleHours: [0],
});
// a job that has github_webhook and git_provider_webhook set 
// to true will be categorized as a "Continuous Integration Job"
const ciJob = new dbtcloud.Job("ci_job", {
    environmentId: ciEnvironment.environmentId,
    executeSteps: ["dbt build -s state:modified+ --fail-fast"],
    generateDocs: false,
    deferringEnvironmentId: prodEnvironment.environmentId,
    name: "CI Job",
    numThreads: 32,
    projectId: dbtProject.id,
    runGenerateSources: false,
    triggers: {
        github_webhook: true,
        git_provider_webhook: true,
        schedule: false,
        on_merge: false,
    },
    scheduleDays: [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
    ],
    scheduleType: "days_of_week",
});
// a job that is set to be triggered after another job finishes
// this is sometimes referred as 'job chaining'
const downstreamJob = new dbtcloud.Job("downstream_job", {
    environmentId: project2ProdEnvironment.environmentId,
    executeSteps: ["dbt build -s +my_model"],
    generateDocs: true,
    name: "Downstream job in project 2",
    numThreads: 32,
    projectId: dbtProject2.id,
    runGenerateSources: true,
    triggers: {
        github_webhook: false,
        git_provider_webhook: false,
        schedule: false,
        on_merge: false,
    },
    scheduleDays: [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
    ],
    scheduleType: "days_of_week",
    jobCompletionTriggerCondition: {
        jobId: dailyJob.id,
        projectId: dbtProject.id,
        statuses: ["success"],
    },
});

import pulumi
import pulumi_dbtcloud as dbtcloud

# a job that has github_webhook and git_provider_webhook 
# set to false will be categorized as a "Deploy Job"
daily_job = dbtcloud.Job("daily_job",
    environment_id=prod_environment["environmentId"],
    execute_steps=["dbt build"],
    generate_docs=True,
    is_active=True,
    name="Daily job",
    num_threads=64,
    project_id=dbt_project["id"],
    run_generate_sources=True,
    target_name="default",
    triggers={
        "github_webhook": False,
        "git_provider_webhook": False,
        "schedule": True,
        "on_merge": False,
    },
    schedule_days=[
        0,
        1,
        2,
        3,
        4,
        5,
        6,
    ],
    schedule_type="days_of_week",
    schedule_hours=[0])
# a job that has github_webhook and git_provider_webhook set 
# to true will be categorized as a "Continuous Integration Job"
ci_job = dbtcloud.Job("ci_job",
    environment_id=ci_environment["environmentId"],
    execute_steps=["dbt build -s state:modified+ --fail-fast"],
    generate_docs=False,
    deferring_environment_id=prod_environment["environmentId"],
    name="CI Job",
    num_threads=32,
    project_id=dbt_project["id"],
    run_generate_sources=False,
    triggers={
        "github_webhook": True,
        "git_provider_webhook": True,
        "schedule": False,
        "on_merge": False,
    },
    schedule_days=[
        0,
        1,
        2,
        3,
        4,
        5,
        6,
    ],
    schedule_type="days_of_week")
# a job that is set to be triggered after another job finishes
# this is sometimes referred as 'job chaining'
downstream_job = dbtcloud.Job("downstream_job",
    environment_id=project2_prod_environment["environmentId"],
    execute_steps=["dbt build -s +my_model"],
    generate_docs=True,
    name="Downstream job in project 2",
    num_threads=32,
    project_id=dbt_project2["id"],
    run_generate_sources=True,
    triggers={
        "github_webhook": False,
        "git_provider_webhook": False,
        "schedule": False,
        "on_merge": False,
    },
    schedule_days=[
        0,
        1,
        2,
        3,
        4,
        5,
        6,
    ],
    schedule_type="days_of_week",
    job_completion_trigger_condition=dbtcloud.JobJobCompletionTriggerConditionArgs(
        job_id=daily_job.id,
        project_id=dbt_project["id"],
        statuses=["success"],
    ))

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// a job that has github_webhook and git_provider_webhook
		// set to false will be categorized as a "Deploy Job"
		dailyJob, err := dbtcloud.NewJob(ctx, "daily_job", &dbtcloud.JobArgs{
			EnvironmentId: pulumi.Any(prodEnvironment.EnvironmentId),
			ExecuteSteps: pulumi.StringArray{
				pulumi.String("dbt build"),
			},
			GenerateDocs:       pulumi.Bool(true),
			IsActive:           pulumi.Bool(true),
			Name:               pulumi.String("Daily job"),
			NumThreads:         pulumi.Int(64),
			ProjectId:          pulumi.Any(dbtProject.Id),
			RunGenerateSources: pulumi.Bool(true),
			TargetName:         pulumi.String("default"),
			Triggers: pulumi.BoolMap{
				"github_webhook":       pulumi.Bool(false),
				"git_provider_webhook": pulumi.Bool(false),
				"schedule":             pulumi.Bool(true),
				"on_merge":             pulumi.Bool(false),
			},
			ScheduleDays: pulumi.IntArray{
				pulumi.Int(0),
				pulumi.Int(1),
				pulumi.Int(2),
				pulumi.Int(3),
				pulumi.Int(4),
				pulumi.Int(5),
				pulumi.Int(6),
			},
			ScheduleType: pulumi.String("days_of_week"),
			ScheduleHours: pulumi.IntArray{
				pulumi.Int(0),
			},
		})
		if err != nil {
			return err
		}
		// a job that has github_webhook and git_provider_webhook set
		// to true will be categorized as a "Continuous Integration Job"
		_, err = dbtcloud.NewJob(ctx, "ci_job", &dbtcloud.JobArgs{
			EnvironmentId: pulumi.Any(ciEnvironment.EnvironmentId),
			ExecuteSteps: pulumi.StringArray{
				pulumi.String("dbt build -s state:modified+ --fail-fast"),
			},
			GenerateDocs:           pulumi.Bool(false),
			DeferringEnvironmentId: pulumi.Any(prodEnvironment.EnvironmentId),
			Name:                   pulumi.String("CI Job"),
			NumThreads:             pulumi.Int(32),
			ProjectId:              pulumi.Any(dbtProject.Id),
			RunGenerateSources:     pulumi.Bool(false),
			Triggers: pulumi.BoolMap{
				"github_webhook":       pulumi.Bool(true),
				"git_provider_webhook": pulumi.Bool(true),
				"schedule":             pulumi.Bool(false),
				"on_merge":             pulumi.Bool(false),
			},
			ScheduleDays: pulumi.IntArray{
				pulumi.Int(0),
				pulumi.Int(1),
				pulumi.Int(2),
				pulumi.Int(3),
				pulumi.Int(4),
				pulumi.Int(5),
				pulumi.Int(6),
			},
			ScheduleType: pulumi.String("days_of_week"),
		})
		if err != nil {
			return err
		}
		// a job that is set to be triggered after another job finishes
		// this is sometimes referred as 'job chaining'
		_, err = dbtcloud.NewJob(ctx, "downstream_job", &dbtcloud.JobArgs{
			EnvironmentId: pulumi.Any(project2ProdEnvironment.EnvironmentId),
			ExecuteSteps: pulumi.StringArray{
				pulumi.String("dbt build -s +my_model"),
			},
			GenerateDocs:       pulumi.Bool(true),
			Name:               pulumi.String("Downstream job in project 2"),
			NumThreads:         pulumi.Int(32),
			ProjectId:          pulumi.Any(dbtProject2.Id),
			RunGenerateSources: pulumi.Bool(true),
			Triggers: pulumi.BoolMap{
				"github_webhook":       pulumi.Bool(false),
				"git_provider_webhook": pulumi.Bool(false),
				"schedule":             pulumi.Bool(false),
				"on_merge":             pulumi.Bool(false),
			},
			ScheduleDays: pulumi.IntArray{
				pulumi.Int(0),
				pulumi.Int(1),
				pulumi.Int(2),
				pulumi.Int(3),
				pulumi.Int(4),
				pulumi.Int(5),
				pulumi.Int(6),
			},
			ScheduleType: pulumi.String("days_of_week"),
			JobCompletionTriggerCondition: &dbtcloud.JobJobCompletionTriggerConditionArgs{
				JobId:     dailyJob.ID(),
				ProjectId: pulumi.Any(dbtProject.Id),
				Statuses: pulumi.StringArray{
					pulumi.String("success"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // a job that has github_webhook and git_provider_webhook 
    // set to false will be categorized as a "Deploy Job"
    var dailyJob = new DbtCloud.Job("daily_job", new()
    {
        EnvironmentId = prodEnvironment.EnvironmentId,
        ExecuteSteps = new[]
        {
            "dbt build",
        },
        GenerateDocs = true,
        IsActive = true,
        Name = "Daily job",
        NumThreads = 64,
        ProjectId = dbtProject.Id,
        RunGenerateSources = true,
        TargetName = "default",
        Triggers = 
        {
            { "github_webhook", false },
            { "git_provider_webhook", false },
            { "schedule", true },
            { "on_merge", false },
        },
        ScheduleDays = new[]
        {
            0,
            1,
            2,
            3,
            4,
            5,
            6,
        },
        ScheduleType = "days_of_week",
        ScheduleHours = new[]
        {
            0,
        },
    });

    // a job that has github_webhook and git_provider_webhook set 
    // to true will be categorized as a "Continuous Integration Job"
    var ciJob = new DbtCloud.Job("ci_job", new()
    {
        EnvironmentId = ciEnvironment.EnvironmentId,
        ExecuteSteps = new[]
        {
            "dbt build -s state:modified+ --fail-fast",
        },
        GenerateDocs = false,
        DeferringEnvironmentId = prodEnvironment.EnvironmentId,
        Name = "CI Job",
        NumThreads = 32,
        ProjectId = dbtProject.Id,
        RunGenerateSources = false,
        Triggers = 
        {
            { "github_webhook", true },
            { "git_provider_webhook", true },
            { "schedule", false },
            { "on_merge", false },
        },
        ScheduleDays = new[]
        {
            0,
            1,
            2,
            3,
            4,
            5,
            6,
        },
        ScheduleType = "days_of_week",
    });

    // a job that is set to be triggered after another job finishes
    // this is sometimes referred as 'job chaining'
    var downstreamJob = new DbtCloud.Job("downstream_job", new()
    {
        EnvironmentId = project2ProdEnvironment.EnvironmentId,
        ExecuteSteps = new[]
        {
            "dbt build -s +my_model",
        },
        GenerateDocs = true,
        Name = "Downstream job in project 2",
        NumThreads = 32,
        ProjectId = dbtProject2.Id,
        RunGenerateSources = true,
        Triggers = 
        {
            { "github_webhook", false },
            { "git_provider_webhook", false },
            { "schedule", false },
            { "on_merge", false },
        },
        ScheduleDays = new[]
        {
            0,
            1,
            2,
            3,
            4,
            5,
            6,
        },
        ScheduleType = "days_of_week",
        CompletionTriggerCondition = new DbtCloud.Inputs.JobJobCompletionTriggerConditionArgs
        {
            JobId = dailyJob.Id,
            ProjectId = dbtProject.Id,
            Statuses = new[]
            {
                "success",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dbtcloud.Job;
import com.pulumi.dbtcloud.JobArgs;
import com.pulumi.dbtcloud.inputs.JobJobCompletionTriggerConditionArgs;
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) {
        // a job that has github_webhook and git_provider_webhook 
        // set to false will be categorized as a "Deploy Job"
        var dailyJob = new Job("dailyJob", JobArgs.builder()
            .environmentId(prodEnvironment.environmentId())
            .executeSteps("dbt build")
            .generateDocs(true)
            .isActive(true)
            .name("Daily job")
            .numThreads(64)
            .projectId(dbtProject.id())
            .runGenerateSources(true)
            .targetName("default")
            .triggers(Map.ofEntries(
                Map.entry("github_webhook", false),
                Map.entry("git_provider_webhook", false),
                Map.entry("schedule", true),
                Map.entry("on_merge", false)
            ))
            .scheduleDays(            
                0,
                1,
                2,
                3,
                4,
                5,
                6)
            .scheduleType("days_of_week")
            .scheduleHours(0)
            .build());

        // a job that has github_webhook and git_provider_webhook set 
        // to true will be categorized as a "Continuous Integration Job"
        var ciJob = new Job("ciJob", JobArgs.builder()
            .environmentId(ciEnvironment.environmentId())
            .executeSteps("dbt build -s state:modified+ --fail-fast")
            .generateDocs(false)
            .deferringEnvironmentId(prodEnvironment.environmentId())
            .name("CI Job")
            .numThreads(32)
            .projectId(dbtProject.id())
            .runGenerateSources(false)
            .triggers(Map.ofEntries(
                Map.entry("github_webhook", true),
                Map.entry("git_provider_webhook", true),
                Map.entry("schedule", false),
                Map.entry("on_merge", false)
            ))
            .scheduleDays(            
                0,
                1,
                2,
                3,
                4,
                5,
                6)
            .scheduleType("days_of_week")
            .build());

        // a job that is set to be triggered after another job finishes
        // this is sometimes referred as 'job chaining'
        var downstreamJob = new Job("downstreamJob", JobArgs.builder()
            .environmentId(project2ProdEnvironment.environmentId())
            .executeSteps("dbt build -s +my_model")
            .generateDocs(true)
            .name("Downstream job in project 2")
            .numThreads(32)
            .projectId(dbtProject2.id())
            .runGenerateSources(true)
            .triggers(Map.ofEntries(
                Map.entry("github_webhook", false),
                Map.entry("git_provider_webhook", false),
                Map.entry("schedule", false),
                Map.entry("on_merge", false)
            ))
            .scheduleDays(            
                0,
                1,
                2,
                3,
                4,
                5,
                6)
            .scheduleType("days_of_week")
            .jobCompletionTriggerCondition(JobJobCompletionTriggerConditionArgs.builder()
                .jobId(dailyJob.id())
                .projectId(dbtProject.id())
                .statuses("success")
                .build())
            .build());

    }
}

resources:
  # a job that has github_webhook and git_provider_webhook 
  # set to false will be categorized as a "Deploy Job"
  dailyJob:
    type: dbtcloud:Job
    name: daily_job
    properties:
      environmentId: ${prodEnvironment.environmentId}
      executeSteps:
        - dbt build
      generateDocs: true
      isActive: true
      name: Daily job
      numThreads: 64
      projectId: ${dbtProject.id}
      runGenerateSources: true
      targetName: default
      triggers:
        github_webhook: false
        git_provider_webhook: false
        schedule: true
        on_merge: false
      scheduleDays:
        - 0
        - 1
        - 2
        - 3
        - 4
        - 5
        - 6
      scheduleType: days_of_week
      scheduleHours:
        - 0
  # a job that has github_webhook and git_provider_webhook set 
  # to true will be categorized as a "Continuous Integration Job"
  ciJob:
    type: dbtcloud:Job
    name: ci_job
    properties:
      environmentId: ${ciEnvironment.environmentId}
      executeSteps:
        - dbt build -s state:modified+ --fail-fast
      generateDocs: false
      deferringEnvironmentId: ${prodEnvironment.environmentId}
      name: CI Job
      numThreads: 32
      projectId: ${dbtProject.id}
      runGenerateSources: false
      triggers:
        github_webhook: true
        git_provider_webhook: true
        schedule: false
        on_merge: false
      scheduleDays:
        - 0
        - 1
        - 2
        - 3
        - 4
        - 5
        - 6
      scheduleType: days_of_week
  # a job that is set to be triggered after another job finishes
  # this is sometimes referred as 'job chaining'
  downstreamJob:
    type: dbtcloud:Job
    name: downstream_job
    properties:
      environmentId: ${project2ProdEnvironment.environmentId}
      executeSteps:
        - dbt build -s +my_model
      generateDocs: true
      name: Downstream job in project 2
      numThreads: 32
      projectId: ${dbtProject2.id}
      runGenerateSources: true
      triggers:
        github_webhook: false
        git_provider_webhook: false
        schedule: false
        on_merge: false
      scheduleDays:
        - 0
        - 1
        - 2
        - 3
        - 4
        - 5
        - 6
      scheduleType: days_of_week
      jobCompletionTriggerCondition:
        jobId: ${dailyJob.id}
        projectId: ${dbtProject.id}
        statuses:
          - success

var jobResource = new DbtCloud.Job("jobResource", new()
{
    EnvironmentId = 0,
    Triggers = 
    {
        { "string", false },
    },
    ProjectId = 0,
    ExecuteSteps = new[]
    {
        "string",
    },
    NumThreads = 0,
    ScheduleCron = "string",
    GenerateDocs = false,
    IsActive = false,
    CompletionTriggerCondition = new DbtCloud.Inputs.JobJobCompletionTriggerConditionArgs
    {
        JobId = 0,
        ProjectId = 0,
        Statuses = new[]
        {
            "string",
        },
    },
    Name = "string",
    DbtVersion = "string",
    DeferringJobId = 0,
    RunGenerateSources = false,
    Description = "string",
    ScheduleDays = new[]
    {
        0,
    },
    ScheduleHours = new[]
    {
        0,
    },
    ScheduleInterval = 0,
    ScheduleType = "string",
    SelfDeferring = false,
    TargetName = "string",
    TimeoutSeconds = 0,
    DeferringEnvironmentId = 0,
    TriggersOnDraftPr = false,
});

example, err := dbtcloud.NewJob(ctx, "jobResource", &dbtcloud.JobArgs{
	EnvironmentId: pulumi.Int(0),
	Triggers: pulumi.BoolMap{
		"string": pulumi.Bool(false),
	},
	ProjectId: pulumi.Int(0),
	ExecuteSteps: pulumi.StringArray{
		pulumi.String("string"),
	},
	NumThreads:   pulumi.Int(0),
	ScheduleCron: pulumi.String("string"),
	GenerateDocs: pulumi.Bool(false),
	IsActive:     pulumi.Bool(false),
	JobCompletionTriggerCondition: &dbtcloud.JobJobCompletionTriggerConditionArgs{
		JobId:     pulumi.Int(0),
		ProjectId: pulumi.Int(0),
		Statuses: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Name:               pulumi.String("string"),
	DbtVersion:         pulumi.String("string"),
	DeferringJobId:     pulumi.Int(0),
	RunGenerateSources: pulumi.Bool(false),
	Description:        pulumi.String("string"),
	ScheduleDays: pulumi.IntArray{
		pulumi.Int(0),
	},
	ScheduleHours: pulumi.IntArray{
		pulumi.Int(0),
	},
	ScheduleInterval:       pulumi.Int(0),
	ScheduleType:           pulumi.String("string"),
	SelfDeferring:          pulumi.Bool(false),
	TargetName:             pulumi.String("string"),
	TimeoutSeconds:         pulumi.Int(0),
	DeferringEnvironmentId: pulumi.Int(0),
	TriggersOnDraftPr:      pulumi.Bool(false),
})

var jobResource = new Job("jobResource", JobArgs.builder()
    .environmentId(0)
    .triggers(Map.of("string", false))
    .projectId(0)
    .executeSteps("string")
    .numThreads(0)
    .scheduleCron("string")
    .generateDocs(false)
    .isActive(false)
    .jobCompletionTriggerCondition(JobJobCompletionTriggerConditionArgs.builder()
        .jobId(0)
        .projectId(0)
        .statuses("string")
        .build())
    .name("string")
    .dbtVersion("string")
    .deferringJobId(0)
    .runGenerateSources(false)
    .description("string")
    .scheduleDays(0)
    .scheduleHours(0)
    .scheduleInterval(0)
    .scheduleType("string")
    .selfDeferring(false)
    .targetName("string")
    .timeoutSeconds(0)
    .deferringEnvironmentId(0)
    .triggersOnDraftPr(false)
    .build());

job_resource = dbtcloud.Job("jobResource",
    environment_id=0,
    triggers={
        "string": False,
    },
    project_id=0,
    execute_steps=["string"],
    num_threads=0,
    schedule_cron="string",
    generate_docs=False,
    is_active=False,
    job_completion_trigger_condition=dbtcloud.JobJobCompletionTriggerConditionArgs(
        job_id=0,
        project_id=0,
        statuses=["string"],
    ),
    name="string",
    dbt_version="string",
    deferring_job_id=0,
    run_generate_sources=False,
    description="string",
    schedule_days=[0],
    schedule_hours=[0],
    schedule_interval=0,
    schedule_type="string",
    self_deferring=False,
    target_name="string",
    timeout_seconds=0,
    deferring_environment_id=0,
    triggers_on_draft_pr=False)

const jobResource = new dbtcloud.Job("jobResource", {
    environmentId: 0,
    triggers: {
        string: false,
    },
    projectId: 0,
    executeSteps: ["string"],
    numThreads: 0,
    scheduleCron: "string",
    generateDocs: false,
    isActive: false,
    jobCompletionTriggerCondition: {
        jobId: 0,
        projectId: 0,
        statuses: ["string"],
    },
    name: "string",
    dbtVersion: "string",
    deferringJobId: 0,
    runGenerateSources: false,
    description: "string",
    scheduleDays: [0],
    scheduleHours: [0],
    scheduleInterval: 0,
    scheduleType: "string",
    selfDeferring: false,
    targetName: "string",
    timeoutSeconds: 0,
    deferringEnvironmentId: 0,
    triggersOnDraftPr: false,
});

type: dbtcloud:Job
properties:
    dbtVersion: string
    deferringEnvironmentId: 0
    deferringJobId: 0
    description: string
    environmentId: 0
    executeSteps:
        - string
    generateDocs: false
    isActive: false
    jobCompletionTriggerCondition:
        jobId: 0
        projectId: 0
        statuses:
            - string
    name: string
    numThreads: 0
    projectId: 0
    runGenerateSources: false
    scheduleCron: string
    scheduleDays:
        - 0
    scheduleHours:
        - 0
    scheduleInterval: 0
    scheduleType: string
    selfDeferring: false
    targetName: string
    timeoutSeconds: 0
    triggers:
        string: false
    triggersOnDraftPr: false