merge

Signed-off-by: Abhishek Kumar <[email protected]>

Author: shwstppr

cli/completer.go

@@ -357,6 +357,7 @@ func (t *autoCompleter) Do(line []rune, pos int) (options [][]rune, offset int)
 				}
 				return
 			}
+
 			if arg.Type == config.FAKE && arg.Name == "filter=" {
 				offset = 0
 				filterInputs := strings.Split(strings.Replace(argInput, ",", ",|", -1), "|")
@@ -373,6 +374,22 @@ func (t *autoCompleter) Do(line []rune, pos int) (options [][]rune, offset int)
 				return
 			}
 
+			if arg.Type == config.FAKE && arg.Name == "exclude=" {
+				offset = 0
+				excludeFilterInputs := strings.Split(strings.Replace(argInput, ",", ",|", -1), "|")
+				lastExcludeFilterInput := lastString(excludeFilterInputs)
+				for _, key := range apiFound.ResponseKeys {
+					if inArray(key, excludeFilterInputs) {
+						continue
+					}
+					if strings.HasPrefix(key, lastExcludeFilterInput) {
+						options = append(options, []rune(key[len(lastExcludeFilterInput):]))
+						offset = len(lastExcludeFilterInput)
+					}
+				}
+				return
+			}
+
 			autocompleteAPI := findAutocompleteAPI(arg, apiFound, apiMap)
 			if autocompleteAPI == nil {
 				return nil, 0

cmd/api.go

@@ -82,7 +82,7 @@ func init() {
 				if strings.HasSuffix(err.Error(), "context canceled") {
 					return nil
 				} else if response != nil {
-					printResult(r.Config.Core.Output, response, nil)
+					printResult(r.Config.Core.Output, response, nil, nil)
 				}
 				return err
 			}
@@ -98,8 +98,19 @@ func init() {
 				}
 			}
 
+			var excludeKeys []string
+			for _, arg := range apiArgs {
+				if strings.HasPrefix(arg, "exclude=") {
+					for _, excludeKey := range strings.Split(strings.Split(arg, "=")[1], ",") {
+						if len(strings.TrimSpace(excludeKey)) > 0 {
+							excludeKeys = append(excludeKeys, strings.TrimSpace(excludeKey))
+						}
+					}
+				}
+			}
+
 			if len(response) > 0 {
-				printResult(r.Config.Core.Output, response, filterKeys)
+				printResult(r.Config.Core.Output, response, filterKeys, excludeKeys)
 			}
 
 			return nil

cmd/network.go

@@ -216,7 +216,7 @@ func NewAPIRequest(r *Request, api string, args []string, isAsync bool) (map[str
 	expiresKey := "expires"
 	params.Add("response", "json")
 	params.Add("signatureversion", signatureversion)
-	params.Add(expiresKey, time.Now().UTC().Add(15 * time.Minute).Format(time.RFC3339))
+	params.Add(expiresKey, time.Now().UTC().Add(15*time.Minute).Format(time.RFC3339))
 
 	var encodedParams string
 	var err error

cmd/output.go

@@ -62,6 +62,24 @@ func printJSON(response map[string]interface{}) {
 	enc.Encode(response)
 }
 
+func getItemsFromValue(v interface{}) ([]interface{}, bool) {
+	valueType := reflect.TypeOf(v)
+	if valueType.Kind() == reflect.Slice {
+		sliceItems, ok := v.([]interface{})
+		if !ok {
+			return nil, false
+		}
+		return sliceItems, true
+	} else if valueType.Kind() == reflect.Map {
+		mapItem, ok := v.(map[string]interface{})
+		if !ok {
+			return nil, false
+		}
+		return []interface{}{mapItem}, true
+	}
+	return nil, false
+}
+
 func printText(response map[string]interface{}) {
 	format := "text"
 	for k, v := range response {
@@ -209,72 +227,70 @@ func printCsv(response map[string]interface{}, filter []string) {
 	enc.Flush()
 }
 
-func getItemsFromValue(v interface{}) ([]interface{}, bool) {
-	valueType := reflect.TypeOf(v)
-	if valueType.Kind() == reflect.Slice {
-		sliceItems, ok := v.([]interface{})
-		if !ok {
-			return nil, false
-		}
-		return sliceItems, true
-	} else if valueType.Kind() == reflect.Map {
-		mapItem, ok := v.(map[string]interface{})
-		if !ok {
-			return nil, false
-		}
-		return []interface{}{mapItem}, true
+func filterResponse(response map[string]interface{}, filter []string, excludeFilter []string, outputType string) map[string]interface{} {
+	if len(filter) == 0 && len(excludeFilter) == 0 {
+		return response
 	}
-	return nil, false
-}
 
-func filterResponse(response map[string]interface{}, filter []string, outputType string) map[string]interface{} {
-	config.Debug("Filtering response with filter:", filter, "and output type:", outputType)
-	if len(filter) == 0 {
-		return response
+	excludeSet := make(map[string]struct{}, len(excludeFilter))
+	for _, key := range excludeFilter {
+		excludeSet[key] = struct{}{}
+	}
+
+	filterSet := make(map[string]struct{}, len(filter))
+	for _, key := range filter {
+		filterSet[key] = struct{}{}
 	}
+
 	filteredResponse := make(map[string]interface{})
-	for k, v := range response {
-		valueType := reflect.TypeOf(v)
+
+	for key, value := range response {
+		valueType := reflect.TypeOf(value)
 		if valueType.Kind() == reflect.Slice || valueType.Kind() == reflect.Map {
-			items, ok := getItemsFromValue(v)
+			items, ok := getItemsFromValue(value)
 			if !ok {
-				config.Debug("Skipping non-slice/map value for key:", k)
 				continue
 			}
 			var filteredRows []interface{}
 			for _, item := range items {
 				row, ok := item.(map[string]interface{})
-				if !ok || len(row) < 1 {
-					config.Debug("Skipping non-map item for key:", k)
+				if !ok || len(row) == 0 {
 					continue
 				}
+
 				filteredRow := make(map[string]interface{})
-				for _, filterKey := range filter {
-					for field := range row {
-						if filterKey == field {
-							filteredRow[field] = row[field]
+
+				if len(filter) > 0 {
+					// Include only keys that exist in filterSet
+					for filterKey := range filterSet {
+						if val, exists := row[filterKey]; exists {
+							filteredRow[filterKey] = val
+						} else if outputType == config.COLUMN || outputType == config.CSV || outputType == config.TABLE {
+							filteredRow[filterKey] = "" // Ensure all filter keys exist in row
 						}
 					}
-					if outputType == config.COLUMN || outputType == config.CSV || outputType == config.TABLE {
-						if _, ok := filteredRow[filterKey]; !ok {
-							filteredRow[filterKey] = ""
+				} else {
+					// Exclude keys from excludeFilter
+					for field, val := range row {
+						if _, excluded := excludeSet[field]; !excluded {
+							filteredRow[field] = val
 						}
 					}
 				}
+
 				filteredRows = append(filteredRows, filteredRow)
 			}
-			filteredResponse[k] = filteredRows
+			filteredResponse[key] = filteredRows
 		} else {
-			filteredResponse[k] = v
-			continue
+			filteredResponse[key] = value
 		}
-
 	}
+
 	return filteredResponse
 }
 
-func printResult(outputType string, response map[string]interface{}, filter []string) {
-	response = filterResponse(response, filter, outputType)
+func printResult(outputType string, response map[string]interface{}, filter []string, excludeFilter []string) {
+	response = filterResponse(response, filter, excludeFilter, outputType)
 	switch outputType {
 	case config.JSON:
 		printJSON(response)

config/cache.go

@@ -151,6 +151,13 @@ func (c *Config) UpdateCache(response map[string]interface{}) interface{} {
 			Description: "cloudmonkey specific response key filtering",
 		})
 
+		// Add exclude arg
+		apiArgs = append(apiArgs, &APIArg{
+			Name:        "exclude=",
+			Type:        FAKE,
+			Description: "cloudmonkey specific response key to exlude when filtering",
+		})
+
 		sort.Slice(apiArgs, func(i, j int) bool {
 			return apiArgs[i].Name < apiArgs[j].Name
 		})