func runRun()

in cobra/controller/run.go [85:291]
180 lines of code
50 McCabe index (conditional complexity)

func runRun(cmd *cobra.Command, args []string) error {

	token := dao.GetTeamToken(profile)
	client := aid.GetTFEClient(token)

	fArg := args[0]
	switch fArg {
	case "list":
		workspaceID, err := cmd.Flags().GetString("workspace-id")
		if err != nil {
			return fmt.Errorf("unable to get flag workspace-id\n%v", err)
		}

		list, err := runList(client, workspaceID, tfe.RunListOptions{})
		if err == nil {
			aid.PrintRunList(list)
		} else {
			return fmt.Errorf("no run was found")
		}

	case "create":
		options := aid.GetRunCreateOptions(cmd)

		workspaceID, err := cmd.Flags().GetString("workspace-id")
		if err != nil {
			return fmt.Errorf("unable to get flag workspace-id\n%v", err)
		}

		if workspaceID != "" {
			workspace, err := workspaceReadByID(client, workspaceID)
			if err != nil {
				return fmt.Errorf("unable to find workspace %s\n%v", workspaceID, err)
			}
			options.Workspace = workspace
		}

		cvID, err := cmd.Flags().GetString("configuration-version-id")
		if err != nil {
			return fmt.Errorf("unable to get flag configuration-version-id\n%v", err)
		}

		if cvID != "" {
			cv, err := configurationVersionRead(client, cvID)
			if err != nil {
				return fmt.Errorf("unable to find configuration version %s\n%v", cvID, err)
			}

			if cv.ID != "" {
				options.ConfigurationVersion = cv
			}
		}

		run, err := runCreate(client, options)

		if err == nil && run.ID != "" {
			fmt.Println(aid.ToJSON(run))
		} else {
			return fmt.Errorf("unable to create run\n%v", err)
		}

	case "read":
		id, err := cmd.Flags().GetString("id")
		if err != nil {
			return fmt.Errorf("unable to get flag id\n%v", err)
		}

		run, err := runRead(client, id)
		if err == nil {
			fmt.Println(aid.ToJSON(run))
		} else {
			return fmt.Errorf("run %s not found\n%v", id, err)
		}
	case "read-with-options":
		id, err := cmd.Flags().GetString("id")
		if err != nil {
			return fmt.Errorf("unable to get flag id\n%v", err)
		}

		options := aid.GetRunReadOptions(cmd)
		run, err := runReadWithOptions(client, id, &options)
		if err == nil {
			fmt.Println(aid.ToJSON(run))
		} else {
			return fmt.Errorf("run %s not found\n%v", id, err)
		}
	case "apply":
		id, err := cmd.Flags().GetString("id")
		if err != nil {
			return fmt.Errorf("unable to get flag id\n%v", err)
		}

		options := aid.GetRunApplyOptions(cmd)
		err = runApply(client, id, options)
		if err != nil {
			return fmt.Errorf("unable to apply run\n%v", err)
		}

		fmt.Println("run applied successfully")
	case "cancel":
		id, err := cmd.Flags().GetString("id")
		if err != nil {
			return fmt.Errorf("unable to get flag id\n%v", err)
		}

		options := aid.GetRunCancelOptions(cmd)
		err = runCancel(client, id, options)
		if err != nil {
			return fmt.Errorf("unable to cancel run\n%v", err)
		}

		fmt.Println("run cancelled successfully")
	case "cancel-all":
		workspaceID, err := cmd.Flags().GetString("workspace-id")
		if err != nil {
			return fmt.Errorf("unable to get flag workspace-id\n%v", err)
		}

		list, err := runList(client, workspaceID, tfe.RunListOptions{})
		if err == nil {
			for _, r := range list.Items {
				if r.Actions.IsCancelable {

					fmt.Printf("attempting to cancel run (%s)\n", r.ID)
					options := aid.GetRunCancelOptions(cmd)
					err := runCancel(client, r.ID, options)
					if err != nil {
						return fmt.Errorf("unable to cancel run (%s)", r.ID)
					}

					fmt.Printf("run (%s) cancelled successfully\n", r.ID)
				}
			}
		} else {
			return fmt.Errorf("no run was found")
		}
	case "force-cancel":
		id, err := cmd.Flags().GetString("id")
		if err != nil {
			return fmt.Errorf("unable to get flag id\n%v", err)
		}

		options := aid.GetRunForceCancelOptions(cmd)
		err = runForceCancel(client, id, options)
		if err != nil {
			return fmt.Errorf("unable to force ancel run\n%v", err)
		}

		fmt.Println("run cancelled successfully")
	case "force-cancel-all":
		workspaceID, err := cmd.Flags().GetString("workspace-id")
		if err != nil {
			return fmt.Errorf("unable to get flag workspace-id\n%v", err)
		}

		list, err := runList(client, workspaceID, tfe.RunListOptions{})
		if err == nil {
			for _, r := range list.Items {
				if r.Actions.IsForceCancelable {
					fmt.Printf("attempting to force-cancel run (%s)\n", r.ID)
					options := aid.GetRunForceCancelOptions(cmd)
					err := runForceCancel(client, r.ID, options)
					if err != nil {
						return fmt.Errorf("unable to force cancel run (%s)", r.ID)
					}
					fmt.Printf("run (%s) force-cancelled successfully\n", r.ID)
				}
			}
		} else {
			return fmt.Errorf("no run was found")
		}

	case "discard":
		id, err := cmd.Flags().GetString("id")
		if err != nil {
			return fmt.Errorf("unable to get flag id\n%v", err)
		}

		options := aid.GetRunDiscardOptions(cmd)
		err = runDiscard(client, id, options)
		if err != nil {
			return fmt.Errorf("unable to discard run\n%v", err)
		}
	case "discard-all":
		workspaceID, err := cmd.Flags().GetString("workspace-id")
		if err != nil {
			return fmt.Errorf("unable to get flag workspace-id\n%v", err)
		}

		list, err := runList(client, workspaceID, tfe.RunListOptions{})
		if err == nil {
			for _, r := range list.Items {
				if r.Actions.IsDiscardable {
					fmt.Printf("attempting to discard run (%s)\n", r.ID)
					options := aid.GetRunDiscardOptions(cmd)
					err := runDiscard(client, r.ID, options)
					if err != nil {
						return fmt.Errorf("unable to discard run (%s)", r.ID)
					}
					fmt.Printf("run (%s) discarded successfully\n", r.ID)
				}
			}
		} else {
			return fmt.Errorf("no run was found")
		}
	}
	return nil
}