func getMPFBicep()

in cmd/bicepCmd.go [92:209]
92 lines of code
13 McCabe index (conditional complexity)

func getMPFBicep(cmd *cobra.Command, args []string) {
	setLogLevel()

	log.Info("Executing MPF for Bicep")

	log.Debugf("ResourceGroupNamePfx: %s\n", flgResourceGroupNamePfx)
	log.Debugf("DeploymentNamePfx: %s\n", flgDeploymentNamePfx)
	log.Infof("BicepFilePath: %s\n", flgBicepFilePath)
	log.Infof("ParametersFilePath: %s\n", flgParametersFilePath)
	log.Infof("BicepExecPath: %s\n", flgBicepExecPath)
	log.Infof("SubscriptionScoped: %t\n", flgSubscriptionScoped)
	log.Infof("Location: %s\n", flgLocation)

	// validate if template and parameters files exists
	if _, err := os.Stat(flgBicepFilePath); os.IsNotExist(err) {
		log.Fatal("Bicep File does not exist")
	}

	if _, err := os.Stat(flgBicepExecPath); os.IsNotExist(err) {
		log.Fatal("Bicep Executable does not exist")
	}

	if _, err := os.Stat(flgParametersFilePath); os.IsNotExist(err) {
		log.Fatal("Parameters File does not exist")
	}

	flgBicepExecPath, err := getAbsolutePath(flgBicepExecPath)
	if err != nil {
		log.Errorf("Error getting absolute path for bicep executable: %v\n", err)
	}

	flgBicepFilePath, err := getAbsolutePath(flgBicepFilePath)
	if err != nil {
		log.Errorf("Error getting absolute path for bicep file: %v\n", err)
	}

	flgParametersFilePath, err := getAbsolutePath(flgParametersFilePath)
	if err != nil {
		log.Errorf("Error getting absolute path for parameters file: %v\n", err)
	}

	armTemplatePath := strings.TrimSuffix(flgBicepFilePath, ".bicep") + ".json"
	bicepCmd := exec.Command(flgBicepExecPath, "build", flgBicepFilePath, "--outfile", armTemplatePath)
	bicepCmd.Dir = filepath.Dir(flgBicepFilePath)

	_, err = bicepCmd.CombinedOutput()
	if err != nil {
		log.Errorf("error running bicep build: %s", err)
	}
	log.Infoln("Bicep build successful, ARM Template created at:", armTemplatePath)

	ctx := context.Background()

	mpfConfig := getRootMPFConfig()
	mpfRG := domain.ResourceGroup{}
	mpfRG.ResourceGroupName = fmt.Sprintf("%s-%s", flgResourceGroupNamePfx, mpfSharedUtils.GenerateRandomString(7))
	mpfRG.ResourceGroupResourceID = fmt.Sprintf("/subscriptions/%s/resourceGroups/%s", flgSubscriptionID, mpfRG.ResourceGroupName)
	mpfRG.Location = flgLocation
	mpfConfig.ResourceGroup = mpfRG
	deploymentName := fmt.Sprintf("%s-%s", flgDeploymentNamePfx, mpfSharedUtils.GenerateRandomString(7))
	armConfig := &ARMTemplateShared.ArmTemplateAdditionalConfig{
		TemplateFilePath:   armTemplatePath,
		ParametersFilePath: flgParametersFilePath,
		DeploymentName:     deploymentName,
		SubscriptionScoped: flgSubscriptionScoped,
		Location:           flgLocation,
	}

	var rgManager usecase.ResourceGroupManager
	var spRoleAssignmentManager usecase.ServicePrincipalRolemAssignmentManager
	rgManager = resourceGroupManager.NewResourceGroupManager(flgSubscriptionID)
	spRoleAssignmentManager = sproleassignmentmanager.NewSPRoleAssignmentManager(flgSubscriptionID)

	var deploymentAuthorizationCheckerCleaner usecase.DeploymentAuthorizationCheckerCleaner
	var mpfService *usecase.MPFService
	var initialPermissionsToAdd []string
	var permissionsToAddToResult []string

	deploymentAuthorizationCheckerCleaner = ARMTemplateWhatIf.NewARMTemplateWhatIfAuthorizationChecker(flgSubscriptionID, *armConfig)
	initialPermissionsToAdd = []string{"Microsoft.Resources/deployments/*", "Microsoft.Resources/subscriptions/operationresults/read"}
	permissionsToAddToResult = []string{"Microsoft.Resources/deployments/read", "Microsoft.Resources/deployments/write"}

	var autoCreateResourceGroup bool = true
	if flgSubscriptionScoped {
		autoCreateResourceGroup = false
	}
	mpfService = usecase.NewMPFService(ctx, rgManager, spRoleAssignmentManager, deploymentAuthorizationCheckerCleaner, mpfConfig, initialPermissionsToAdd, permissionsToAddToResult, true, false, autoCreateResourceGroup)

	mpfResult, err := mpfService.GetMinimumPermissionsRequired()
	if err != nil {
		log.Fatal(err)
	}

	log.Infoln("Deleting Generated ARM Template file...")
	// delete generated ARM template file
	err = os.Remove(armTemplatePath)
	if err != nil {
		log.Errorf("Error deleting Generated ARM template file: %v\n", err)
	}

	// log.Infof("Displaying MPF Result: %v\n", mpfResult)
	log.Infof("Show Detailed Output: %t\n", flgShowDetailedOutput)
	log.Infof("JSON Output: %t\n", flgJSONOutput)
	log.Infof("Subscription ID: %s\n", mpfConfig.SubscriptionID)

	displayOptions := getDislayOptions(flgShowDetailedOutput, flgJSONOutput, mpfConfig.SubscriptionID)

	if err != nil {
		if len(mpfResult.RequiredPermissions) > 0 {
			fmt.Println("Error occurred while getting minimum permissions required. However, some permissions were identified prior to the error.")
			displayResult(mpfResult, displayOptions)
		}
		log.Fatal(err)
	}

	displayResult(mpfResult, displayOptions)

}