func()

in internal/pkg/term/selector/selector.go [621:738]
108 lines of code
27 McCabe index (conditional complexity)

func (s *DeploySelector) deployedWorkload(workloadType string, msg, help string, app string, opts ...GetDeployedWorkloadOpts) (*DeployedWorkload, error) {
	for _, opt := range opts {
		opt(s)
	}

	var isWorkloadDeployed func(string, string, string) (bool, error)
	var listDeployedWorkloads func(string, string) ([]string, error)
	var finalMessage string
	switch workloadType {
	case svcWorkloadType:
		isWorkloadDeployed = s.deployStoreSvc.IsServiceDeployed
		listDeployedWorkloads = s.deployStoreSvc.ListDeployedServices
		finalMessage = deployedSvcFinalMsg
	case jobWorkloadType:
		isWorkloadDeployed = s.deployStoreSvc.IsJobDeployed
		listDeployedWorkloads = s.deployStoreSvc.ListDeployedJobs
		finalMessage = deployedJobFinalMsg
	case anyWorkloadType:
		isWorkloadDeployed = s.deployStoreSvc.IsWorkloadDeployed
		listDeployedWorkloads = s.deployStoreSvc.ListDeployedWorkloads
		finalMessage = deployedWkldFinalMsg
	default:
		return nil, fmt.Errorf("unrecognized workload type %s", workloadType)

	}

	var err error
	var envNames []string
	wkldTypes := map[string]string{}
	workloads, err := s.workloadLister.ListWorkloads(app)
	if err != nil {
		return nil, fmt.Errorf("list %ss: %w", workloadType, err)
	}
	for _, wkld := range workloads {
		wkldTypes[wkld.Name] = wkld.Type
	}

	if s.env != "" {
		envNames = append(envNames, s.env)
	} else {
		envNames, err = s.retrieveEnvironments(app)
		if err != nil {
			return nil, fmt.Errorf("list environments: %w", err)
		}
	}
	wkldEnvs := []*DeployedWorkload{}
	for _, envName := range envNames {
		var wkldNames []string
		if s.name != "" {
			deployed, err := isWorkloadDeployed(app, envName, s.name)
			if err != nil {
				return nil, fmt.Errorf("check if %s %s is deployed in environment %s: %w", workloadType, s.name, envName, err)
			}
			if !deployed {
				continue
			}
			wkldNames = append(wkldNames, s.name)
		} else {
			wkldNames, err = listDeployedWorkloads(app, envName)
			if err != nil {
				return nil, fmt.Errorf("list deployed %ss for environment %s: %w", workloadType, envName, err)
			}
		}
		for _, wkldName := range wkldNames {
			wkldEnv := &DeployedWorkload{
				Name: wkldName,
				Env:  envName,
				Type: wkldTypes[wkldName],
			}
			wkldEnvs = append(wkldEnvs, wkldEnv)
		}
	}
	if len(wkldEnvs) == 0 {
		return nil, fmt.Errorf("no deployed %ss found in application %s", workloadType, color.HighlightUserInput(app))
	}

	if wkldEnvs, err = s.filterWorkloads(wkldEnvs); err != nil {
		return nil, err
	}

	if len(wkldEnvs) == 0 {
		return nil, fmt.Errorf("no matching deployed %ss found in application %s", workloadType, color.HighlightUserInput(app))
	}
	// return if only one deployed workload found
	var deployedWkld *DeployedWorkload
	if len(wkldEnvs) == 1 {
		deployedWkld = wkldEnvs[0]
		switch {
		case s.name == "" && s.env == "":
			log.Infof("Found only one deployed %s %s in environment %s\n", workloadType, color.HighlightUserInput(deployedWkld.Name), color.HighlightUserInput(deployedWkld.Env))
		case s.name != "" && s.env == "":
			log.Infof("%s found only in environment %s\n", color.HighlightUserInput(deployedWkld.Name), color.HighlightUserInput(deployedWkld.Env))
		case s.name == "" && s.env != "":
			log.Infof("Only the %s %s is found in the environment %s\n", deployedWkld.Type, color.HighlightUserInput(deployedWkld.Name), color.HighlightUserInput(deployedWkld.Env))
		}
		return deployedWkld, nil
	}

	wkldEnvNames := make([]string, len(wkldEnvs))
	wkldEnvNameMap := map[string]*DeployedWorkload{}
	for i, svc := range wkldEnvs {
		wkldEnvNames[i] = svc.String()
		wkldEnvNameMap[wkldEnvNames[i]] = svc
	}

	wkldEnvName, err := s.prompt.SelectOne(
		msg,
		help,
		wkldEnvNames,
		prompt.WithFinalMessage(finalMessage),
	)
	if err != nil {
		return nil, err
	}
	deployedWkld = wkldEnvNameMap[wkldEnvName]

	return deployedWkld, nil
}