6442892572

Committed 07 Oct 2023 06:45PM UTC coverage: 67.119% (-23.3%) from 90.418%

Build # 6442892572

Build Type

push

github

Committed by

thschmitt

Commit Message

Upgrade to golang 1.21, update dependencies to latest versions

- Upgrade to golang 1.21
- Update all dependencies to latest versions

Run Details

3068 of 4571 relevant lines covered (67.12%)

362.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/commandline/show_command_handler.go

package commandline

import (
        "encoding/json"
        "sort"

        "github.com/UiPath/uipathcli/parser"
        "github.com/urfave/cli/v2"
)

// showCommandHandler prints all available uipathcli commands
type showCommandHandler struct {
}

type parameterJson struct {
        Name          string        `json:"name"`
        Type          string        `json:"type"`
        Description   string        `json:"description"`
        Required      bool          `json:"required"`
        AllowedValues []interface{} `json:"allowedValues"`
        DefaultValue  interface{}   `json:"defaultValue"`
        Example       string        `json:"example"`
}

type commandJson struct {
        Name        string          `json:"name"`
        Description string          `json:"description"`
        Parameters  []parameterJson `json:"parameters"`
        Subcommands []commandJson   `json:"subcommands"`
}

func (h showCommandHandler) Execute(definitions []parser.Definition, globalFlags []cli.Flag) (string, error) {
        result := commandJson{
                Name:        "uipath",
                Description: "Command line interface to simplify, script and automate API calls for UiPath services",
                Parameters:  h.convertFlagsToCommandParameters(globalFlags),
                Subcommands: h.convertDefinitionsToCommands(definitions),
        }
        bytes, err := json.MarshalIndent(result, "", "  ")
        if err != nil {
                return "", err
        }
        return string(bytes), nil
}

func (h showCommandHandler) convertDefinitionsToCommands(definitions []parser.Definition) []commandJson {
        commands := []commandJson{}
        for _, d := range definitions {
                command := h.convertDefinitionToCommands(d)
                commands = append(commands, command)
        }
        return commands
}

func (h showCommandHandler) convertDefinitionToCommands(definition parser.Definition) commandJson {
        categories := map[string]commandJson{}

        for _, op := range definition.Operations {
                if op.Category == nil {
                        command := h.convertOperationToCommand(op)
                        categories[command.Name] = command
                } else {
                        h.createOrUpdateCategory(op, categories)
                }
        }

        commands := []commandJson{}
        for _, command := range categories {
                commands = append(commands, command)
        }

        h.sort(commands)
        for _, command := range commands {
                h.sort(command.Subcommands)
        }
        return commandJson{
                Name:        definition.Name,
                Description: definition.Description,
                Subcommands: commands,
        }
}

func (h showCommandHandler) createOrUpdateCategory(operation parser.Operation, categories map[string]commandJson) {
        command, found := categories[operation.Category.Name]
        if !found {
                command = h.createCategoryCommand(operation)
        }
        command.Subcommands = append(command.Subcommands, h.convertOperationToCommand(operation))
        categories[operation.Category.Name] = command
}

func (h showCommandHandler) createCategoryCommand(operation parser.Operation) commandJson {
        return commandJson{
                Name:        operation.Category.Name,
                Description: operation.Category.Description,
        }
}

func (h showCommandHandler) convertOperationToCommand(operation parser.Operation) commandJson {
        return commandJson{
                Name:        operation.Name,
                Description: operation.Description,
                Parameters:  h.convertParametersToCommandParameters(operation.Parameters),
        }
}

func (h showCommandHandler) convertFlagsToCommandParameters(flags []cli.Flag) []parameterJson {
        result := []parameterJson{}
        for _, f := range flags {
                result = append(result, h.convertFlagToCommandParameter(f))
        }
        return result
}

func (h showCommandHandler) convertParametersToCommandParameters(parameters []parser.Parameter) []parameterJson {
        result := []parameterJson{}
        for _, p := range parameters {
                result = append(result, h.convertParameterToCommandParameter(p))
        }
        return result
}

func (h showCommandHandler) convertFlagToCommandParameter(flag cli.Flag) parameterJson {
        intFlag, ok := flag.(*cli.IntFlag)
        if ok {
                return parameterJson{
                        Name:          intFlag.Name,
                        Description:   intFlag.Usage,
                        Type:          "integer",
                        Required:      false,
                        AllowedValues: []interface{}{},
                        DefaultValue:  intFlag.Value,
                }
        }
        boolFlag, ok := flag.(*cli.BoolFlag)
        if ok {
                return parameterJson{
                        Name:          boolFlag.Name,
                        Description:   boolFlag.Usage,
                        Type:          "boolean",
                        Required:      false,
                        AllowedValues: []interface{}{},
                        DefaultValue:  boolFlag.Value,
                }
        }
        stringFlag := flag.(*cli.StringFlag)
        return parameterJson{
                Name:          stringFlag.Name,
                Description:   stringFlag.Usage,
                Type:          "string",
                Required:      false,
                AllowedValues: []interface{}{},
                DefaultValue:  stringFlag.Value,
        }
}

func (h showCommandHandler) convertParameterToCommandParameter(parameter parser.Parameter) parameterJson {
        formatter := newParameterFormatter(parameter)
        return parameterJson{
                Name:          parameter.Name,
                Description:   parameter.Description,
                Type:          parameter.Type,
                Required:      parameter.Required,
                AllowedValues: parameter.AllowedValues,
                DefaultValue:  parameter.DefaultValue,
                Example:       formatter.UsageExample(),
        }
}

func (h showCommandHandler) sort(commands []commandJson) {
        sort.Slice(commands, func(i, j int) bool {
                return commands[i].Name < commands[j].Name
        })
}

func newShowCommandHandler() *showCommandHandler {
        return &showCommandHandler{}
}

1	package commandline
2
3	import (
4	"encoding/json"
5	"sort"
6
7	"github.com/UiPath/uipathcli/parser"
8	"github.com/urfave/cli/v2"
9	)
10
11	// showCommandHandler prints all available uipathcli commands
12	type showCommandHandler struct {
13	}
14
15	type parameterJson struct {
16	Name string `json:"name"`
17	Type string `json:"type"`
18	Description string `json:"description"`
19	Required bool `json:"required"`
20	AllowedValues []interface{} `json:"allowedValues"`
21	DefaultValue interface{} `json:"defaultValue"`
22	Example string `json:"example"`
23	}
24
25	type commandJson struct {
26	Name string `json:"name"`
27	Description string `json:"description"`
28	Parameters []parameterJson `json:"parameters"`
29	Subcommands []commandJson `json:"subcommands"`
30	}
31
32	func (h showCommandHandler) Execute(definitions []parser.Definition, globalFlags []cli.Flag) (string, error) {	×
33	result := commandJson{	×
34	Name: "uipath",	×
35	Description: "Command line interface to simplify, script and automate API calls for UiPath services",	×
36	Parameters: h.convertFlagsToCommandParameters(globalFlags),	×
37	Subcommands: h.convertDefinitionsToCommands(definitions),	×
38	}	×
39	bytes, err := json.MarshalIndent(result, "", " ")	×
40	if err != nil {	×
41	return "", err	×
42	}	×
43	return string(bytes), nil	×
44	}
45
46	func (h showCommandHandler) convertDefinitionsToCommands(definitions []parser.Definition) []commandJson {	×
47	commands := []commandJson{}	×
48	for _, d := range definitions {	×
49	command := h.convertDefinitionToCommands(d)	×
50	commands = append(commands, command)	×
51	}	×
52	return commands	×
53	}
54
55	func (h showCommandHandler) convertDefinitionToCommands(definition parser.Definition) commandJson {	×
56	categories := map[string]commandJson{}	×
57		×
58	for _, op := range definition.Operations {	×
59	if op.Category == nil {	×
60	command := h.convertOperationToCommand(op)	×
61	categories[command.Name] = command	×
62	} else {	×
63	h.createOrUpdateCategory(op, categories)	×
64	}	×
65	}
66
67	commands := []commandJson{}	×
68	for _, command := range categories {	×
69	commands = append(commands, command)	×
70	}	×
71
72	h.sort(commands)	×
73	for _, command := range commands {	×
74	h.sort(command.Subcommands)	×
75	}	×
76	return commandJson{	×
77	Name: definition.Name,	×
78	Description: definition.Description,	×
79	Subcommands: commands,	×
80	}	×
81	}
82
83	func (h showCommandHandler) createOrUpdateCategory(operation parser.Operation, categories map[string]commandJson) {	×
84	command, found := categories[operation.Category.Name]	×
85	if !found {	×
86	command = h.createCategoryCommand(operation)	×
87	}	×
88	command.Subcommands = append(command.Subcommands, h.convertOperationToCommand(operation))	×
89	categories[operation.Category.Name] = command	×
90	}
91
92	func (h showCommandHandler) createCategoryCommand(operation parser.Operation) commandJson {	×
93	return commandJson{	×
94	Name: operation.Category.Name,	×
95	Description: operation.Category.Description,	×
96	}	×
97	}	×
98
99	func (h showCommandHandler) convertOperationToCommand(operation parser.Operation) commandJson {	×
100	return commandJson{	×
101	Name: operation.Name,	×
102	Description: operation.Description,	×
103	Parameters: h.convertParametersToCommandParameters(operation.Parameters),	×
104	}	×
105	}	×
106
107	func (h showCommandHandler) convertFlagsToCommandParameters(flags []cli.Flag) []parameterJson {	×
108	result := []parameterJson{}	×
109	for _, f := range flags {	×
110	result = append(result, h.convertFlagToCommandParameter(f))	×
111	}	×
112	return result	×
113	}
114
115	func (h showCommandHandler) convertParametersToCommandParameters(parameters []parser.Parameter) []parameterJson {	×
116	result := []parameterJson{}	×
117	for _, p := range parameters {	×
118	result = append(result, h.convertParameterToCommandParameter(p))	×
119	}	×
120	return result	×
121	}
122
123	func (h showCommandHandler) convertFlagToCommandParameter(flag cli.Flag) parameterJson {	×
124	intFlag, ok := flag.(*cli.IntFlag)	×
125	if ok {	×
126	return parameterJson{	×
127	Name: intFlag.Name,	×
128	Description: intFlag.Usage,	×
129	Type: "integer",	×
130	Required: false,	×
131	AllowedValues: []interface{}{},	×
132	DefaultValue: intFlag.Value,	×
133	}	×
134	}	×
135	boolFlag, ok := flag.(*cli.BoolFlag)	×
136	if ok {	×
137	return parameterJson{	×
138	Name: boolFlag.Name,	×
139	Description: boolFlag.Usage,	×
140	Type: "boolean",	×
141	Required: false,	×
142	AllowedValues: []interface{}{},	×
143	DefaultValue: boolFlag.Value,	×
144	}	×
145	}	×
146	stringFlag := flag.(*cli.StringFlag)	×
147	return parameterJson{	×
148	Name: stringFlag.Name,	×
149	Description: stringFlag.Usage,	×
150	Type: "string",	×
151	Required: false,	×
152	AllowedValues: []interface{}{},	×
153	DefaultValue: stringFlag.Value,	×
154	}	×
155	}
156
157	func (h showCommandHandler) convertParameterToCommandParameter(parameter parser.Parameter) parameterJson {	×
158	formatter := newParameterFormatter(parameter)	×
159	return parameterJson{	×
160	Name: parameter.Name,	×
161	Description: parameter.Description,	×
162	Type: parameter.Type,	×
163	Required: parameter.Required,	×
164	AllowedValues: parameter.AllowedValues,	×
165	DefaultValue: parameter.DefaultValue,	×
166	Example: formatter.UsageExample(),	×
167	}	×
168	}	×
169
170	func (h showCommandHandler) sort(commands []commandJson) {	×
171	sort.Slice(commands, func(i, j int) bool {	×
172	return commands[i].Name < commands[j].Name	×
173	})	×
174	}
175
176	func newShowCommandHandler() *showCommandHandler {	×
177	return &showCommandHandler{}	×
178	}	×

UiPath / uipathcli / 6442892572

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous