zpa.PolicyForwardingRuleV2

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";
import * as zpa from "@pulumi/zpa";

const thisIdPController = zpa.getIdPController({
    name: "Idp_Name",
});
const emailUserSso = zpa.getSAMLAttribute({
    name: "Email_Users",
    idpName: "Idp_Name",
});
const groupUser = zpa.getSAMLAttribute({
    name: "GroupName_Users",
    idpName: "Idp_Name",
});
const a000 = zpa.getSCIMGroups({
    name: "A000",
    idpName: "Idp_Name",
});
const b000 = zpa.getSCIMGroups({
    name: "B000",
    idpName: "Idp_Name",
});
// Create Segment Group
const thisSegmentGroup = new zpa.SegmentGroup("thisSegmentGroup", {
    description: "Example",
    enabled: true,
});
// Create Policy Access Rule V2
const thisPolicyAccessForwardingRuleV2 = new zpa.PolicyAccessForwardingRuleV2("thisPolicyAccessForwardingRuleV2", {
    description: "Example",
    action: "BYPASS",
    conditions: [
        {
            operator: "OR",
            operands: [{
                objectType: "APP_GROUP",
                values: [thisSegmentGroup.id],
            }],
        },
        {
            operator: "OR",
            operands: [
                {
                    objectType: "SAML",
                    entryValues: [
                        {
                            rhs: "user1@acme.com",
                            lhs: emailUserSso.then(emailUserSso => emailUserSso.id),
                        },
                        {
                            rhs: "A000",
                            lhs: groupUser.then(groupUser => groupUser.id),
                        },
                    ],
                },
                {
                    objectType: "SCIM_GROUP",
                    entryValues: [
                        {
                            rhs: a000.then(a000 => a000.id),
                            lhs: thisIdPController.then(thisIdPController => thisIdPController.id),
                        },
                        {
                            rhs: b000.then(b000 => b000.id),
                            lhs: thisIdPController.then(thisIdPController => thisIdPController.id),
                        },
                    ],
                },
            ],
        },
        {
            operator: "OR",
            operands: [{
                objectType: "PLATFORM",
                entryValues: [
                    {
                        rhs: "true",
                        lhs: "linux",
                    },
                    {
                        rhs: "true",
                        lhs: "android",
                    },
                ],
            }],
        },
    ],
});

import pulumi
import pulumi_zpa as zpa
import zscaler_pulumi_zpa as zpa

this_id_p_controller = zpa.get_id_p_controller(name="Idp_Name")
email_user_sso = zpa.get_saml_attribute(name="Email_Users",
    idp_name="Idp_Name")
group_user = zpa.get_saml_attribute(name="GroupName_Users",
    idp_name="Idp_Name")
a000 = zpa.get_scim_groups(name="A000",
    idp_name="Idp_Name")
b000 = zpa.get_scim_groups(name="B000",
    idp_name="Idp_Name")
# Create Segment Group
this_segment_group = zpa.SegmentGroup("thisSegmentGroup",
    description="Example",
    enabled=True)
# Create Policy Access Rule V2
this_policy_access_forwarding_rule_v2 = zpa.PolicyAccessForwardingRuleV2("thisPolicyAccessForwardingRuleV2",
    description="Example",
    action="BYPASS",
    conditions=[
        zpa.PolicyAccessForwardingRuleV2ConditionArgs(
            operator="OR",
            operands=[zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs(
                object_type="APP_GROUP",
                values=[this_segment_group.id],
            )],
        ),
        zpa.PolicyAccessForwardingRuleV2ConditionArgs(
            operator="OR",
            operands=[
                zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs(
                    object_type="SAML",
                    entry_values=[
                        zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs(
                            rhs="user1@acme.com",
                            lhs=email_user_sso.id,
                        ),
                        zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs(
                            rhs="A000",
                            lhs=group_user.id,
                        ),
                    ],
                ),
                zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs(
                    object_type="SCIM_GROUP",
                    entry_values=[
                        zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs(
                            rhs=a000.id,
                            lhs=this_id_p_controller.id,
                        ),
                        zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs(
                            rhs=b000.id,
                            lhs=this_id_p_controller.id,
                        ),
                    ],
                ),
            ],
        ),
        zpa.PolicyAccessForwardingRuleV2ConditionArgs(
            operator="OR",
            operands=[zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs(
                object_type="PLATFORM",
                entry_values=[
                    zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs(
                        rhs="true",
                        lhs="linux",
                    ),
                    zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs(
                        rhs="true",
                        lhs="android",
                    ),
                ],
            )],
        ),
    ])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		thisIdPController, err := zpa.GetIdPController(ctx, &zpa.GetIdPControllerArgs{
			Name: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		emailUserSso, err := zpa.GetSAMLAttribute(ctx, &zpa.GetSAMLAttributeArgs{
			Name:    pulumi.StringRef("Email_Users"),
			IdpName: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		groupUser, err := zpa.GetSAMLAttribute(ctx, &zpa.GetSAMLAttributeArgs{
			Name:    pulumi.StringRef("GroupName_Users"),
			IdpName: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		a000, err := zpa.GetSCIMGroups(ctx, &zpa.GetSCIMGroupsArgs{
			Name:    pulumi.StringRef("A000"),
			IdpName: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		b000, err := zpa.GetSCIMGroups(ctx, &zpa.GetSCIMGroupsArgs{
			Name:    pulumi.StringRef("B000"),
			IdpName: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		// Create Segment Group
		thisSegmentGroup, err := zpa.NewSegmentGroup(ctx, "thisSegmentGroup", &zpa.SegmentGroupArgs{
			Description: pulumi.String("Example"),
			Enabled:     pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create Policy Access Rule V2
		_, err = zpa.NewPolicyAccessForwardingRuleV2(ctx, "thisPolicyAccessForwardingRuleV2", &zpa.PolicyAccessForwardingRuleV2Args{
			Description: pulumi.String("Example"),
			Action:      pulumi.String("BYPASS"),
			Conditions: zpa.PolicyAccessForwardingRuleV2ConditionArray{
				&zpa.PolicyAccessForwardingRuleV2ConditionArgs{
					Operator: pulumi.String("OR"),
					Operands: zpa.PolicyAccessForwardingRuleV2ConditionOperandArray{
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
							ObjectType: pulumi.String("APP_GROUP"),
							Values: pulumi.StringArray{
								thisSegmentGroup.ID(),
							},
						},
					},
				},
				&zpa.PolicyAccessForwardingRuleV2ConditionArgs{
					Operator: pulumi.String("OR"),
					Operands: zpa.PolicyAccessForwardingRuleV2ConditionOperandArray{
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
							ObjectType: pulumi.String("SAML"),
							EntryValues: zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArray{
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String("user1@acme.com"),
									Lhs: pulumi.String(emailUserSso.Id),
								},
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String("A000"),
									Lhs: pulumi.String(groupUser.Id),
								},
							},
						},
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
							ObjectType: pulumi.String("SCIM_GROUP"),
							EntryValues: zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArray{
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String(a000.Id),
									Lhs: pulumi.String(thisIdPController.Id),
								},
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String(b000.Id),
									Lhs: pulumi.String(thisIdPController.Id),
								},
							},
						},
					},
				},
				&zpa.PolicyAccessForwardingRuleV2ConditionArgs{
					Operator: pulumi.String("OR"),
					Operands: zpa.PolicyAccessForwardingRuleV2ConditionOperandArray{
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
							ObjectType: pulumi.String("PLATFORM"),
							EntryValues: zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArray{
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String("true"),
									Lhs: pulumi.String("linux"),
								},
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String("true"),
									Lhs: pulumi.String("android"),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = Pulumi.Zpa;
using Zpa = Zscaler.Zpa;

return await Deployment.RunAsync(() => 
{
    var thisIdPController = Zpa.GetIdPController.Invoke(new()
    {
        Name = "Idp_Name",
    });

    var emailUserSso = Zpa.GetSAMLAttribute.Invoke(new()
    {
        Name = "Email_Users",
        IdpName = "Idp_Name",
    });

    var groupUser = Zpa.GetSAMLAttribute.Invoke(new()
    {
        Name = "GroupName_Users",
        IdpName = "Idp_Name",
    });

    var a000 = Zpa.GetSCIMGroups.Invoke(new()
    {
        Name = "A000",
        IdpName = "Idp_Name",
    });

    var b000 = Zpa.GetSCIMGroups.Invoke(new()
    {
        Name = "B000",
        IdpName = "Idp_Name",
    });

    // Create Segment Group
    var thisSegmentGroup = new Zpa.SegmentGroup("thisSegmentGroup", new()
    {
        Description = "Example",
        Enabled = true,
    });

    // Create Policy Access Rule V2
    var thisPolicyAccessForwardingRuleV2 = new Zpa.PolicyAccessForwardingRuleV2("thisPolicyAccessForwardingRuleV2", new()
    {
        Description = "Example",
        Action = "BYPASS",
        Conditions = new[]
        {
            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionArgs
            {
                Operator = "OR",
                Operands = new[]
                {
                    new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                    {
                        ObjectType = "APP_GROUP",
                        Values = new[]
                        {
                            thisSegmentGroup.Id,
                        },
                    },
                },
            },
            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionArgs
            {
                Operator = "OR",
                Operands = new[]
                {
                    new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                    {
                        ObjectType = "SAML",
                        EntryValues = new[]
                        {
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = "user1@acme.com",
                                Lhs = emailUserSso.Apply(getSAMLAttributeResult => getSAMLAttributeResult.Id),
                            },
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = "A000",
                                Lhs = groupUser.Apply(getSAMLAttributeResult => getSAMLAttributeResult.Id),
                            },
                        },
                    },
                    new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                    {
                        ObjectType = "SCIM_GROUP",
                        EntryValues = new[]
                        {
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = a000.Apply(getSCIMGroupsResult => getSCIMGroupsResult.Id),
                                Lhs = thisIdPController.Apply(getIdPControllerResult => getIdPControllerResult.Id),
                            },
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = b000.Apply(getSCIMGroupsResult => getSCIMGroupsResult.Id),
                                Lhs = thisIdPController.Apply(getIdPControllerResult => getIdPControllerResult.Id),
                            },
                        },
                    },
                },
            },
            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionArgs
            {
                Operator = "OR",
                Operands = new[]
                {
                    new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                    {
                        ObjectType = "PLATFORM",
                        EntryValues = new[]
                        {
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = "true",
                                Lhs = "linux",
                            },
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = "true",
                                Lhs = "android",
                            },
                        },
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetIdPControllerArgs;
import com.pulumi.zpa.inputs.GetSAMLAttributeArgs;
import com.pulumi.zpa.inputs.GetSCIMGroupsArgs;
import com.pulumi.zpa.SegmentGroup;
import com.pulumi.zpa.SegmentGroupArgs;
import com.pulumi.zpa.PolicyAccessForwardingRuleV2;
import com.pulumi.zpa.PolicyAccessForwardingRuleV2Args;
import com.pulumi.zpa.inputs.PolicyAccessForwardingRuleV2ConditionArgs;
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) {
        final var thisIdPController = ZpaFunctions.getIdPController(GetIdPControllerArgs.builder()
            .name("Idp_Name")
            .build());

        final var emailUserSso = ZpaFunctions.getSAMLAttribute(GetSAMLAttributeArgs.builder()
            .name("Email_Users")
            .idpName("Idp_Name")
            .build());

        final var groupUser = ZpaFunctions.getSAMLAttribute(GetSAMLAttributeArgs.builder()
            .name("GroupName_Users")
            .idpName("Idp_Name")
            .build());

        final var a000 = ZpaFunctions.getSCIMGroups(GetSCIMGroupsArgs.builder()
            .name("A000")
            .idpName("Idp_Name")
            .build());

        final var b000 = ZpaFunctions.getSCIMGroups(GetSCIMGroupsArgs.builder()
            .name("B000")
            .idpName("Idp_Name")
            .build());

        // Create Segment Group
        var thisSegmentGroup = new SegmentGroup("thisSegmentGroup", SegmentGroupArgs.builder()
            .description("Example")
            .enabled(true)
            .build());

        // Create Policy Access Rule V2
        var thisPolicyAccessForwardingRuleV2 = new PolicyAccessForwardingRuleV2("thisPolicyAccessForwardingRuleV2", PolicyAccessForwardingRuleV2Args.builder()
            .description("Example")
            .action("BYPASS")
            .conditions(            
                PolicyAccessForwardingRuleV2ConditionArgs.builder()
                    .operator("OR")
                    .operands(PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
                        .objectType("APP_GROUP")
                        .values(thisSegmentGroup.id())
                        .build())
                    .build(),
                PolicyAccessForwardingRuleV2ConditionArgs.builder()
                    .operator("OR")
                    .operands(                    
                        PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
                            .objectType("SAML")
                            .entryValues(                            
                                PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                    .rhs("user1@acme.com")
                                    .lhs(emailUserSso.applyValue(getSAMLAttributeResult -> getSAMLAttributeResult.id()))
                                    .build(),
                                PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                    .rhs("A000")
                                    .lhs(groupUser.applyValue(getSAMLAttributeResult -> getSAMLAttributeResult.id()))
                                    .build())
                            .build(),
                        PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
                            .objectType("SCIM_GROUP")
                            .entryValues(                            
                                PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                    .rhs(a000.applyValue(getSCIMGroupsResult -> getSCIMGroupsResult.id()))
                                    .lhs(thisIdPController.applyValue(getIdPControllerResult -> getIdPControllerResult.id()))
                                    .build(),
                                PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                    .rhs(b000.applyValue(getSCIMGroupsResult -> getSCIMGroupsResult.id()))
                                    .lhs(thisIdPController.applyValue(getIdPControllerResult -> getIdPControllerResult.id()))
                                    .build())
                            .build())
                    .build(),
                PolicyAccessForwardingRuleV2ConditionArgs.builder()
                    .operator("OR")
                    .operands(PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
                        .objectType("PLATFORM")
                        .entryValues(                        
                            PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                .rhs("true")
                                .lhs("linux")
                                .build(),
                            PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                .rhs("true")
                                .lhs("android")
                                .build())
                        .build())
                    .build())
            .build());

    }
}

resources:
  # Create Segment Group
  thisSegmentGroup:
    type: zpa:SegmentGroup
    properties:
      description: Example
      enabled: true
  # Create Policy Access Rule V2
  thisPolicyAccessForwardingRuleV2:
    type: zpa:PolicyAccessForwardingRuleV2
    properties:
      description: Example
      action: BYPASS
      conditions:
        - operator: OR
          operands:
            - objectType: APP_GROUP
              values:
                - ${thisSegmentGroup.id}
        - operator: OR
          operands:
            - objectType: SAML
              entryValues:
                - rhs: user1@acme.com
                  lhs: ${emailUserSso.id}
                - rhs: A000
                  lhs: ${groupUser.id}
            - objectType: SCIM_GROUP
              entryValues:
                - rhs: ${a000.id}
                  lhs: ${thisIdPController.id}
                - rhs: ${b000.id}
                  lhs: ${thisIdPController.id}
        - operator: OR
          operands:
            - objectType: PLATFORM
              entryValues:
                - rhs: 'true'
                  lhs: linux
                - rhs: 'true'
                  lhs: android
variables:
  thisIdPController:
    fn::invoke:
      Function: zpa:getIdPController
      Arguments:
        name: Idp_Name
  emailUserSso:
    fn::invoke:
      Function: zpa:getSAMLAttribute
      Arguments:
        name: Email_Users
        idpName: Idp_Name
  groupUser:
    fn::invoke:
      Function: zpa:getSAMLAttribute
      Arguments:
        name: GroupName_Users
        idpName: Idp_Name
  a000:
    fn::invoke:
      Function: zpa:getSCIMGroups
      Arguments:
        name: A000
        idpName: Idp_Name
  b000:
    fn::invoke:
      Function: zpa:getSCIMGroups
      Arguments:
        name: B000
        idpName: Idp_Name