func parseFilters()

in cmd/hub/api/logs.go [220:309]
79 lines of code
26 McCabe index (conditional complexity)

func parseFilters(selectors []string) []Filter {
	filters := make([]Filter, 0, len(selectors))

	if len(selectors) > 0 {
		for _, selector := range selectors {
			entityKind := "stackInstance"
			spec := strings.SplitN(selector, "/", 2)
			if len(spec) == 2 {
				entityKind = spec[0]
				selector = spec[1]
			}

			ids := []string{}
			switch entityKind {
			case "cloudAccount":
				accounts, err := cloudAccountsBy(selector, false)
				if err != nil {
					log.Fatalf("Unable to get Cloud Account by `%s`: %v", selector, err)
				}
				for _, account := range accounts {
					ids = append(ids, account.Id)
				}

			case "environment":
				environments, err := environmentsBy(selector)
				if err != nil {
					log.Fatalf("Unable to get Environment by `%s`: %v", selector, err)
				}
				for _, environment := range environments {
					ids = append(ids, environment.Id)
				}

			case "stackTemplate":
				templates, err := templatesBy(selector)
				if err != nil {
					log.Fatalf("Unable to get Template by `%s`: %v", selector, err)
				}
				for _, template := range templates {
					ids = append(ids, template.Id)
				}

			case "stackInstance":
				instances, err := stackInstancesBy(selector, "")
				if err != nil {
					log.Fatalf("Unable to get Stack Instance by `%s`: %v", selector, err)
				}
				for _, instance := range instances {
					ids = append(ids, instance.Id)
				}

			case "backup":
				backups, err := backupsBy(selector)
				if err != nil {
					log.Fatalf("Unable to get Backup by `%s`: %v", selector, err)
				}
				for _, backup := range backups {
					ids = append(ids, backup.Id)
				}

			case "application":
				applications, err := applicationsBy(selector)
				if err != nil {
					log.Fatalf("Unable to get Application by `%s`: %v", selector, err)
				}
				for _, application := range applications {
					ids = append(ids, application.Id)
				}

			default:
				log.Fatalf("Unknown entity kind `%s`", entityKind)
			}

			if len(ids) == 0 {
				if config.Force {
					if !util.IsUint(selector) {
						ids = []string{selector}
					}
				} else {
					log.Fatalf("Entity `%s` by `%s` not found", entityKind, selector)
				}
			}

			for _, id := range ids {
				filters = append(filters, Filter{Id: id, Entity: entityKind})
			}
		}
	}

	return filters
}