cmd

Documentation

Index

• Variables
• func Execute()
• func GetInput() string
• func Prompt(prompt string) string
• type FormatType
• type GetFlags
• type LagoonConfigFlags
• type ListFlags
• type NotificationFlags

Variables

var ListOrganizationUsersCmd = &cobra.Command{
	Use:     "users",
	Aliases: []string{"u"},
	Short:   "List users in an organization",
	PreRunE: func(_ *cobra.Command, _ []string) error {
		return validateTokenE(cmdLagoon)
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		debug, err := cmd.Flags().GetBool("debug")
		if err != nil {
			return err
		}
		organizationName, err := cmd.Flags().GetString("name")
		if err != nil {
			return err
		}
		if err := requiredInputCheck("Organization name", organizationName); err != nil {
			return err
		}

		current := lagoonCLIConfig.Current
		token := lagoonCLIConfig.Lagoons[current].Token
		lc := lclient.New(
			lagoonCLIConfig.Lagoons[current].GraphQL,
			lagoonCLIVersion,
			lagoonCLIConfig.Lagoons[current].Version,
			&token,
			debug)
		organization, err := l.GetOrganizationByName(context.Background(), organizationName, lc)
		handleError(err)
		users, err := l.UsersByOrganization(context.TODO(), organization.ID, lc)
		handleError(err)

		data := []output.Data{}
		for _, user := range *users {
			data = append(data, []string{
				returnNonEmptyString(user.ID),
				returnNonEmptyString(user.Email),
				returnNonEmptyString(user.FirstName),
				returnNonEmptyString(user.LastName),
				returnNonEmptyString(user.Comment),
				returnNonEmptyString(fmt.Sprintf("%v", user.Owner)),
			})
		}
		dataMain := output.Table{
			Header: []string{"ID", "Email", "First Name", "LastName", "Comment", "Owner"},
			Data:   data,
		}
		output.RenderOutput(dataMain, outputOptions)
		return nil
	},
}

var RemoveDeployTargetFromOrganizationCmd = &cobra.Command{
	Use:     "deploytarget",
	Aliases: []string{"dt"},
	Short:   "Remove a deploy target from an Organization",
	PreRunE: func(_ *cobra.Command, _ []string) error {
		return validateTokenE(lagoonCLIConfig.Current)
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		debug, err := cmd.Flags().GetBool("debug")
		handleError(err)

		organizationName, err := cmd.Flags().GetString("name")
		if err != nil {
			return err
		}
		if err := requiredInputCheck("Organization name", organizationName); err != nil {
			return err
		}
		deployTarget, err := cmd.Flags().GetUint("deploy-target")
		if err != nil {
			return err
		}
		if err := requiredInputCheck("Deploy Target", strconv.Itoa(int(deployTarget))); err != nil {
			return err
		}

		current := lagoonCLIConfig.Current
		token := lagoonCLIConfig.Lagoons[current].Token
		lc := lclient.New(
			lagoonCLIConfig.Lagoons[current].GraphQL,
			lagoonCLIVersion,
			lagoonCLIConfig.Lagoons[current].Version,
			&token,
			debug)

		organization, err := l.GetOrganizationByName(context.TODO(), organizationName, lc)
		handleError(err)

		deployTargetInput := s.RemoveDeployTargetFromOrganizationInput{
			DeployTarget: deployTarget,
			Organization: organization.ID,
		}

		if yesNo(fmt.Sprintf("You are attempting to remove deploy target '%d' from organization '%s', are you sure?", deployTarget, organization.Name)) {
			_, err := l.RemoveDeployTargetFromOrganization(context.TODO(), &deployTargetInput, lc)
			handleError(err)
			resultData := output.Result{
				Result: "success",
				ResultData: map[string]interface{}{
					"Deploy Target":     deployTarget,
					"Organization Name": organizationName,
				},
			}
			output.RenderResult(resultData, outputOptions)
		}
		return nil
	},
}

var RemoveProjectFromOrganizationCmd = &cobra.Command{
	Use:     "project",
	Aliases: []string{"p"},
	Short:   "Remove a project from an Organization",
	PreRunE: func(_ *cobra.Command, _ []string) error {
		return validateTokenE(lagoonCLIConfig.Current)
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		debug, err := cmd.Flags().GetBool("debug")
		handleError(err)

		if err := requiredInputCheck("Project name", cmdProjectName); err != nil {
			return err
		}
		organizationName, err := cmd.Flags().GetString("name")
		if err != nil {
			return err
		}
		if err := requiredInputCheck("Organization name", organizationName); err != nil {
			return err
		}

		current := lagoonCLIConfig.Current
		token := lagoonCLIConfig.Lagoons[current].Token
		lc := lclient.New(
			lagoonCLIConfig.Lagoons[current].GraphQL,
			lagoonCLIVersion,
			lagoonCLIConfig.Lagoons[current].Version,
			&token,
			debug)

		project, err := l.GetMinimalProjectByName(context.TODO(), cmdProjectName, lc)
		handleError(err)
		organization, err := l.GetOrganizationByName(context.TODO(), organizationName, lc)
		handleError(err)

		projectInput := s.RemoveProjectFromOrganizationInput{
			Project:      project.ID,
			Organization: organization.ID,
		}

		if yesNo(fmt.Sprintf("You are attempting to remove project '%s' from organization '%s'. This will return the project to a state where it has no groups or notifications associated, are you sure?", cmdProjectName, organization.Name)) {
			_, err := l.RemoveProjectFromOrganization(context.TODO(), &projectInput, lc)
			handleError(err)
			resultData := output.Result{
				Result: "success",
				ResultData: map[string]interface{}{
					"Project Name":      cmdProjectName,
					"Organization Name": organizationName,
				},
			}
			output.RenderResult(resultData, outputOptions)
		}
		return nil
	},
}

var RemoveUserFromOrganization = &cobra.Command{
	Use:     "user",
	Aliases: []string{"u"},
	Short:   "Remove a user to an Organization",
	PreRunE: func(_ *cobra.Command, _ []string) error {
		return validateTokenE(lagoonCLIConfig.Current)
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		debug, err := cmd.Flags().GetBool("debug")
		handleError(err)

		organizationName, err := cmd.Flags().GetString("name")
		if err != nil {
			return err
		}
		if err := requiredInputCheck("Organization name", organizationName); err != nil {
			return err
		}
		userEmail, err := cmd.Flags().GetString("email")
		if err != nil {
			return err
		}
		if err := requiredInputCheck("User email", userEmail); err != nil {
			return err
		}
		owner, err := cmd.Flags().GetBool("owner")
		if err != nil {
			return err
		}

		current := lagoonCLIConfig.Current
		token := lagoonCLIConfig.Lagoons[current].Token
		lc := lclient.New(
			lagoonCLIConfig.Lagoons[current].GraphQL,
			lagoonCLIVersion,
			lagoonCLIConfig.Lagoons[current].Version,
			&token,
			debug)

		organization, err := l.GetOrganizationByName(context.TODO(), organizationName, lc)
		handleError(err)

		userInput := s.AddUserToOrganizationInput{
			User:         s.UserInput{Email: userEmail},
			Organization: organization.ID,
			Owner:        owner,
		}

		orgUser := s.Organization{}

		if yesNo(fmt.Sprintf("You are attempting to remove user '%s' from organization '%s'. This removes the users ability to view or manage the organizations groups, projects, & notifications, are you sure?", userEmail, organization.Name)) {
			err = lc.RemoveUserFromOrganization(context.TODO(), &userInput, &orgUser)
			handleError(err)
			resultData := output.Result{
				Result: "success",
				ResultData: map[string]interface{}{
					"User":              userEmail,
					"Organization Name": organizationName,
				},
			}
			output.RenderResult(resultData, outputOptions)
		}
		return nil
	},
}

Functions

func Execute

func Execute()

Execute the root command.

func GetInput

func GetInput() string

GetInput reads input from an input buffer and returns the result as a string.

func Prompt

func Prompt(prompt string) string

Prompt gets input with a prompt and returns the input

Types

type FormatType

type FormatType string

FormatType .

const (
	JSON   FormatType = "JSON"
	YAML   FormatType = "YAML"
	STDOUT FormatType = "STDOUT"
)

. .

type GetFlags

type GetFlags struct {
	Project     string `json:"project,omitempty"`
	Environment string `json:"environment,omitempty"`
	RemoteID    string `json:"remoteid,omitempty"`
}

GetFlags .

type LagoonConfigFlags

type LagoonConfigFlags struct {
	Lagoon    string `json:"lagoon,omitempty"`
	Hostname  string `json:"hostname,omitempty"`
	Port      string `json:"port,omitempty"`
	GraphQL   string `json:"graphql,omitempty"`
	Token     string `json:"token,omitempty"`
	UI        string `json:"ui,omitempty"`
	Kibana    string `json:"kibana,omitempty"`
	SSHKey    string `json:"sshkey,omitempty"`
	SSHPortal bool   `json:"sshportal,omitempty"`
}

LagoonConfigFlags .

type ListFlags

type ListFlags struct {
	Project     string `json:"project,omitempty"`
	Environment string `json:"environment,omitempty"`
	Reveal      bool   `json:"reveal,omitempty"`
}

ListFlags .

type NotificationFlags

type NotificationFlags struct {
	Project             string `json:"project,omitempty"`
	NotificationName    string `json:"name,omitempty"`
	NotificationNewName string `json:"newname,omitempty"`
	NotificationOldName string `json:"old,omitempty"`
	NotificationWebhook string `json:"webhook,omitempty"`
	NotificationChannel string `json:"channel,omitempty"`
}

NotificationFlags .