UiPath/uipathcli | Build 11162363984 | commandline/command_builder.go | Coveralls

34

func (b CommandBuilder) sort(commands []*CommandDefinition) {

1✔

35

        sort.Slice(commands, func(i, j int) bool {

2✔

36

                return commands[i].Name < commands[j].Name

1✔

37

})

1✔

40

func (b CommandBuilder) fileInput(context *CommandExecContext, parameters []parser.Parameter) utils.Stream {

1✔

41

        value := context.String(FlagNameFile)

1✔

42

        if value == "" {

2✔

43

                return nil

1✔

44

1✔

45

        if value == FlagValueFromStdIn {

2✔

46

                return b.Input

1✔

47

1✔

48

        for _, param := range parameters {

2✔

49

                if strings.EqualFold(param.FieldName, FlagNameFile) {

2✔

50

                        return nil

1✔

51

1✔

53

        return utils.NewFileStream(value)

1✔

56

func (b CommandBuilder) createExecutionParameters(context *CommandExecContext, config *config.Config, operation parser.Operation) (executor.ExecutionParameters, error) {

1✔

57

        typeConverter := newTypeConverter()

1✔

58

1✔

59

        parameters := []executor.ExecutionParameter{}

1✔

60

        for _, param := range operation.Parameters {

2✔

61

                if context.IsSet(param.Name) && param.IsArray() {

2✔

62

                        value, err := typeConverter.ConvertArray(context.StringSlice(param.Name), param)

1✔

63

                        if err != nil {

2✔

64

                                return nil, err

1✔

65

1✔

66

                        parameter := executor.NewExecutionParameter(param.FieldName, value, param.In)

1✔

67

                        parameters = append(parameters, *parameter)

1✔

68

                } else if context.IsSet(param.Name) {

2✔

69

                        value, err := typeConverter.Convert(context.String(param.Name), param)

1✔

70

                        if err != nil {

2✔

71

                                return nil, err

1✔

72

1✔

73

                        parameter := executor.NewExecutionParameter(param.FieldName, value, param.In)

1✔

74

                        parameters = append(parameters, *parameter)

1✔

75

                } else if configValue, ok := config.Parameter[param.Name]; ok {

2✔

76

                        value, err := typeConverter.Convert(configValue, param)

1✔

77

                        if err != nil {

1✔

80

                        parameter := executor.NewExecutionParameter(param.FieldName, value, param.In)

1✔

81

                        parameters = append(parameters, *parameter)

1✔

82

                } else if param.Required && param.DefaultValue != nil {

2✔

83

                        parameter := executor.NewExecutionParameter(param.FieldName, param.DefaultValue, param.In)

1✔

84

                        parameters = append(parameters, *parameter)

1✔

85

1✔

87

        parameters = append(parameters, b.createExecutionParametersFromConfigMap(config.Header, parser.ParameterInHeader)...)

1✔

88

        return parameters, nil

1✔

91

func (b CommandBuilder) createExecutionParametersFromConfigMap(params map[string]string, in string) executor.ExecutionParameters {

1✔

92

        parameters := []executor.ExecutionParameter{}

1✔

93

        for key, value := range params {

2✔

94

                parameter := executor.NewExecutionParameter(key, value, in)

1✔

95

                parameters = append(parameters, *parameter)

1✔

96

1✔

97

        return parameters

1✔

100

func (b CommandBuilder) formatAllowedValues(values []interface{}) string {

1✔

101

        result := ""

1✔

102

        separator := ""

1✔

103

        for _, value := range values {

2✔

104

                result += fmt.Sprintf("%s%v", separator, value)

1✔

105

                separator = ", "

1✔

106

1✔

107

        return result

1✔

110

func (b CommandBuilder) createFlags(parameters []parser.Parameter) []*FlagDefinition {

1✔

111

        flags := []*FlagDefinition{}

1✔

112

        for _, parameter := range parameters {

2✔

113

                formatter := newParameterFormatter(parameter)

1✔

114

                flagType := FlagTypeString

1✔

115

                if parameter.IsArray() {

2✔

116

                        flagType = FlagTypeStringArray

1✔

117

1✔

118

                flag := NewFlag(parameter.Name, formatter.Description(), flagType)

1✔

119

                flags = append(flags, flag)

1✔

121

        return flags

1✔

124

func (b CommandBuilder) sortParameters(parameters []parser.Parameter) {

1✔

125

        sort.Slice(parameters, func(i, j int) bool {

2✔

126

                if parameters[i].Required && !parameters[j].Required {

2✔

127

                        return true

1✔

128

1✔

129

                if !parameters[i].Required && parameters[j].Required {

2✔

130

                        return false

1✔

131

1✔

132

                return parameters[i].Name < parameters[j].Name

1✔

136

func (b CommandBuilder) outputFormat(config config.Config, context *CommandExecContext) (string, error) {

1✔

137

        outputFormat := context.String(FlagNameOutputFormat)

1✔

138

        if outputFormat == "" {

2✔

139

                outputFormat = config.Output

1✔

140

1✔

141

        if outputFormat == "" {

2✔

142

                outputFormat = FlagValueOutputFormatJson

1✔

143

1✔

144

        if outputFormat != FlagValueOutputFormatJson && outputFormat != FlagValueOutputFormatText {

1✔

147

        return outputFormat, nil

1✔

150

func (b CommandBuilder) createBaseUri(operation parser.Operation, config config.Config, context *CommandExecContext) (url.URL, error) {

1✔

151

        uriArgument, err := b.parseUriArgument(context)

1✔

152

        if err != nil {

1✔

156

        builder := NewUriBuilder(operation.BaseUri)

1✔

157

        builder.OverrideUri(config.Uri)

1✔

158

        builder.OverrideUri(uriArgument)

1✔

159

        return builder.Uri(), nil

1✔

162

func (b CommandBuilder) createIdentityUri(context *CommandExecContext, config config.Config, baseUri url.URL) (*url.URL, error) {

1✔

163

        uri := context.String(FlagNameIdentityUri)

1✔

164

        if uri != "" {

2✔

165

                identityUri, err := url.Parse(uri)

1✔

166

                if err != nil {

2✔

167

                        return nil, fmt.Errorf("Error parsing %s argument: %w", FlagNameIdentityUri, err)

1✔

168

1✔

172

        value := config.Auth.Config["uri"]

1✔

173

        uri, valid := value.(string)

1✔

174

        if valid && uri != "" {

2✔

175

                identityUri, err := url.Parse(uri)

1✔

176

                if err != nil {

2✔

177

                        return nil, fmt.Errorf("Error parsing identity uri config: %w", err)

1✔

178

1✔

181

        identityUri, err := url.Parse(fmt.Sprintf("%s://%s/identity_", baseUri.Scheme, baseUri.Host))

1✔

182

        if err != nil {

1✔

185

        return identityUri, nil

1✔

188

func (b CommandBuilder) parseUriArgument(context *CommandExecContext) (*url.URL, error) {

1✔

189

        uriFlag := context.String(FlagNameUri)

1✔

190

        if uriFlag == "" {

2✔

191

                return nil, nil

1✔

192

1✔

193

        uriArgument, err := url.Parse(uriFlag)

1✔

194

        if err != nil {

1✔

197

        return uriArgument, nil

1✔

200

func (b CommandBuilder) getValue(parameter parser.Parameter, context *CommandExecContext, config config.Config) string {

1✔

201

        value := context.String(parameter.Name)

1✔

202

        if value != "" {

2✔

203

                return value

1✔

204

1✔

205

        value = config.Parameter[parameter.Name]

1✔

206

        if value != "" {

2✔

207

                return value

1✔

208

1✔

209

        value = config.Header[parameter.Name]

1✔

210

        if value != "" {

1✔

213

        if parameter.DefaultValue != nil {

2✔

214

                return fmt.Sprintf("%v", parameter.DefaultValue)

1✔

215

1✔

216

        return ""

1✔

219

func (b CommandBuilder) validateArguments(context *CommandExecContext, parameters []parser.Parameter, config config.Config) error {

1✔

220

        err := errors.New("Invalid arguments:")

1✔

221

        result := true

1✔

222

        for _, parameter := range parameters {

2✔

223

                value := b.getValue(parameter, context, config)

1✔

224

                if parameter.Required && value == "" {

2✔

225

                        result = false

1✔

226

                        err = fmt.Errorf("%w\n  Argument --%s is missing", err, parameter.Name)

1✔

227

1✔

228

                if value != "" && len(parameter.AllowedValues) > 0 {

2✔

229

                        valid := false

1✔

230

                        for _, allowedValue := range parameter.AllowedValues {

2✔

231

                                if fmt.Sprintf("%v", allowedValue) == value {

2✔

232

                                        valid = true

1✔

233

                                        break

1✔

236

                        if !valid {

2✔

237

                                allowedValues := b.formatAllowedValues(parameter.AllowedValues)

1✔

238

                                result = false

1✔

239

                                err = fmt.Errorf("%w\n  Argument value '%v' for --%s is invalid, allowed values: %s", err, value, parameter.Name, allowedValues)

1✔

240

1✔

243

        if result {

2✔

244

                return nil

1✔

245

1✔

246

        return err

1✔

249

func (b CommandBuilder) logger(context executor.ExecutionContext, writer io.Writer) log.Logger {

1✔

250

        if context.Debug {

2✔

251

                return log.NewDebugLogger(writer)

1✔

252

1✔

253

        return log.NewDefaultLogger(writer)

1✔

256

func (b CommandBuilder) outputWriter(writer io.Writer, format string, query string) output.OutputWriter {

1✔

257

        var transformer output.Transformer = output.NewDefaultTransformer()

1✔

258

        if query != "" {

2✔

259

                transformer = output.NewJmesPathTransformer(query)

1✔

260

1✔

261

        if format == FlagValueOutputFormatText {

2✔

262

                return output.NewTextOutputWriter(writer, transformer)

1✔

263

1✔

264

        return output.NewJsonOutputWriter(writer, transformer)

1✔

267

func (b CommandBuilder) executeCommand(context executor.ExecutionContext, writer output.OutputWriter, logger log.Logger) error {

1✔

268

        if context.Plugin != nil {

2✔

269

                return b.PluginExecutor.Call(context, writer, logger)

1✔

270

1✔

271

        return b.Executor.Call(context, writer, logger)

1✔

274

func (b CommandBuilder) createOperationCommand(operation parser.Operation) *CommandDefinition {

1✔

275

        parameters := operation.Parameters

1✔

276

        b.sortParameters(parameters)

1✔

277

1✔

278

        flags := NewFlagBuilder().

1✔

279

                AddFlags(b.createFlags(parameters)).

1✔

280

                AddDefaultFlags(true).

1✔

281

                AddHelpFlag().

1✔

282

                Build()

1✔

283

1✔

284

        return NewCommand(operation.Name, operation.Summary, operation.Description).

1✔

285

                WithFlags(flags).

1✔

286

                WithHelpTemplate(OperationCommandHelpTemplate).

1✔

287

                WithHidden(operation.Hidden).

1✔

288

                WithAction(func(context *CommandExecContext) error {

2✔

289

                        profileName := context.String(FlagNameProfile)

1✔

290

                        config := b.ConfigProvider.Config(profileName)

1✔

291

                        if config == nil {

2✔

292

                                return fmt.Errorf("Could not find profile '%s'", profileName)

1✔

293

1✔

294

                        outputFormat, err := b.outputFormat(*config, context)

1✔

295

                        if err != nil {

1✔

298

                        query := context.String(FlagNameQuery)

1✔

299

                        wait := context.String(FlagNameWait)

1✔

300

                        waitTimeout := context.Int(FlagNameWaitTimeout)

1✔

301

1✔

302

                        baseUri, err := b.createBaseUri(operation, *config, context)

1✔

303

                        if err != nil {

1✔

307

                        input := b.fileInput(context, operation.Parameters)

1✔

308

                        if input == nil {

2✔

309

                                err = b.validateArguments(context, operation.Parameters, *config)

1✔

310

                                if err != nil {

2✔

311

                                        return err

1✔

312

1✔

315

                        parameters, err := b.createExecutionParameters(context, config, operation)

1✔

316

                        if err != nil {

2✔

317

                                return err

1✔

318

1✔

320

                        organization := context.String(FlagNameOrganization)

1✔

321

                        if organization == "" {

2✔

322

                                organization = config.Organization

1✔

323

1✔

324

                        tenant := context.String(FlagNameTenant)

1✔

325

                        if tenant == "" {

2✔

326

                                tenant = config.Tenant

1✔

327

1✔

328

                        insecure := context.Bool(FlagNameInsecure) || config.Insecure

1✔

329

                        debug := context.Bool(FlagNameDebug) || config.Debug

1✔

330

                        identityUri, err := b.createIdentityUri(context, *config, baseUri)

1✔

331

                        if err != nil {

2✔

332

                                return err

1✔

333

1✔

335

                        executionContext := executor.NewExecutionContext(

1✔

336

                                organization,

1✔

337

                                tenant,

1✔

338

                                operation.Method,

1✔

339

                                baseUri,

1✔

340

                                operation.Route,

1✔

341

                                operation.ContentType,

1✔

342

                                input,

1✔

343

                                parameters,

1✔

344

                                config.Auth,

1✔

345

                                insecure,

1✔

346

                                debug,

1✔

347

                                *identityUri,

1✔

348

                                operation.Plugin)

1✔

349

1✔

350

                        if wait != "" {

2✔

351

                                return b.executeWait(*executionContext, outputFormat, query, wait, waitTimeout)

1✔

352

1✔

353

                        return b.execute(*executionContext, outputFormat, query, nil)

1✔

357

func (b CommandBuilder) executeWait(executionContext executor.ExecutionContext, outputFormat string, query string, wait string, waitTimeout int) error {

1✔

358

        logger := log.NewDefaultLogger(b.StdErr)

1✔

359

        outputWriter := output.NewMemoryOutputWriter()

1✔

360

        for start := time.Now(); time.Since(start) < time.Duration(waitTimeout)*time.Second; {

2✔

361

                err := b.execute(executionContext, "json", "", outputWriter)

1✔

362

                result, evaluationErr := b.evaluateWaitCondition(outputWriter.Response(), wait)

1✔

363

                if evaluationErr != nil {

2✔

364

                        return evaluationErr

1✔

365

1✔

366

                if result {

2✔

367

                        resultWriter := b.outputWriter(b.StdOut, outputFormat, query)

1✔

368

                        _ = resultWriter.WriteResponse(outputWriter.Response())

1✔

369

                        return err

1✔

370

1✔

371

                logger.LogError("Condition is not met yet. Waiting...\n")

1✔

372

                time.Sleep(1 * time.Second)

1✔

374

        return errors.New("Timed out waiting for condition")

1✔

377

func (b CommandBuilder) evaluateWaitCondition(response output.ResponseInfo, wait string) (bool, error) {

1✔

378

        body, err := io.ReadAll(response.Body)

1✔

379

        if err != nil {

1✔

382

        var data interface{}

1✔

383

        err = json.Unmarshal(body, &data)

1✔

384

        if err != nil {

1✔

387

        transformer := output.NewJmesPathTransformer(wait)

1✔

388

        result, err := transformer.Execute(data)

1✔

389

        if err != nil {

2✔

390

                return false, err

1✔

391

1✔

392

        value, ok := result.(bool)

1✔

393

        if !ok {

2✔

394

                return false, fmt.Errorf("Error in wait condition: JMESPath expression needs to return boolean")

1✔

395

1✔

396

        return value, nil

1✔

399

func (b CommandBuilder) execute(executionContext executor.ExecutionContext, outputFormat string, query string, outputWriter output.OutputWriter) error {

1✔

400

        var wg sync.WaitGroup

1✔

401

        wg.Add(3)

1✔

402

        reader, writer := io.Pipe()

1✔

403

        go func() {

2✔

404

                defer wg.Done()

1✔

405

                defer reader.Close()

1✔

406

                _, _ = io.Copy(b.StdOut, reader)

1✔

407

}()

1✔

408

        errorReader, errorWriter := io.Pipe()

1✔

409

        go func() {

2✔

410

                defer wg.Done()

1✔

411

                defer errorReader.Close()

1✔

412

                _, _ = io.Copy(b.StdErr, errorReader)

1✔

413

}()

1✔

415

        var err error

1✔

416

        go func() {

2✔

417

                defer wg.Done()

1✔

418

                defer writer.Close()

1✔

419

                defer errorWriter.Close()

1✔

420

                if outputWriter == nil {

2✔

421

                        outputWriter = b.outputWriter(writer, outputFormat, query)

1✔

422

1✔

423

                logger := b.logger(executionContext, errorWriter)

1✔

424

                err = b.executeCommand(executionContext, outputWriter, logger)

1✔

427

        wg.Wait()

1✔

428

        return err

1✔

431

func (b CommandBuilder) createCategoryCommand(operation parser.Operation) *CommandDefinition {

1✔

432

        flags := NewFlagBuilder().

1✔

433

                AddHelpFlag().

1✔

434

                AddVersionFlag(true).

1✔

435

                Build()

1✔

436

1✔

437

        return NewCommand(operation.Category.Name, operation.Category.Summary, operation.Category.Description).

1✔

438

                WithFlags(flags)

1✔

439

1✔

441

func (b CommandBuilder) createServiceCommandCategory(operation parser.Operation, categories map[string]*CommandDefinition) (bool, *CommandDefinition) {

1✔

442

        isNewCategory := false

1✔

443

        operationCommand := b.createOperationCommand(operation)

1✔

444

        command, found := categories[operation.Category.Name]

1✔

445

        if !found {

2✔

446

                command = b.createCategoryCommand(operation)

1✔

447

                categories[operation.Category.Name] = command

1✔

448

                isNewCategory = true

1✔

449

1✔

450

        command.Subcommands = append(command.Subcommands, operationCommand)

1✔

451

        return isNewCategory, command

1✔

454

func (b CommandBuilder) createServiceCommand(definition parser.Definition) *CommandDefinition {

1✔

455

        categories := map[string]*CommandDefinition{}

1✔

456

        commands := []*CommandDefinition{}

1✔

457

        for _, operation := range definition.Operations {

2✔

458

                if operation.Category == nil {

2✔

459

                        command := b.createOperationCommand(operation)

1✔

460

                        commands = append(commands, command)

1✔

461

                        continue

1✔

463

                isNewCategory, command := b.createServiceCommandCategory(operation, categories)

1✔

464

                if isNewCategory {

2✔

465

                        commands = append(commands, command)

1✔

466

1✔

468

        b.sort(commands)

1✔

469

        for _, command := range commands {

2✔

470

                b.sort(command.Subcommands)

1✔

471

1✔

473

        flags := NewFlagBuilder().

1✔

474

                AddHelpFlag().

1✔

475

                AddVersionFlag(true).

1✔

476

                Build()

1✔

477

1✔

478

        return NewCommand(definition.Name, definition.Summary, definition.Description).

1✔

479

                WithFlags(flags).

1✔

480

                WithSubcommands(commands)

1✔

483

func (b CommandBuilder) createAutoCompleteEnableCommand() *CommandDefinition {

1✔

484

        const shellFlagName = "shell"

1✔

485

        const fileFlagName = "file"

1✔

486

1✔

487

        flags := NewFlagBuilder().

1✔

488

                AddFlag(NewFlag(shellFlagName, fmt.Sprintf("%s, %s", AutocompletePowershell, AutocompleteBash), FlagTypeString).

1✔

489

                        WithRequired(true)).

1✔

490

                AddFlag(NewFlag(fileFlagName, "The profile file path", FlagTypeString).

1✔

491

                        WithHidden(true)).

1✔

492

                AddHelpFlag().

1✔

493

                Build()

1✔

494

1✔

495

        return NewCommand("enable", "Enable auto complete", "Enables auto complete in your shell").

1✔

496

                WithFlags(flags).

1✔

497

                WithAction(func(context *CommandExecContext) error {

2✔

498

                        shell := context.String(shellFlagName)

1✔

499

                        filePath := context.String(fileFlagName)

1✔

500

                        handler := newAutoCompleteHandler()

1✔

501

                        output, err := handler.EnableCompleter(shell, filePath)

1✔

502

                        if err != nil {

2✔

503

                                return err

1✔

504

1✔

505

                        fmt.Fprintln(b.StdOut, output)

1✔

506

                        return nil

1✔

510

func (b CommandBuilder) createAutoCompleteCompleteCommand(version string) *CommandDefinition {

1✔

511

        const commandFlagName = "command"

1✔

512

1✔

513

        flags := NewFlagBuilder().

1✔

514

                AddFlag(NewFlag(commandFlagName, "The command to autocomplete", FlagTypeString).

1✔

515

                        WithRequired(true)).

1✔

516

                AddHelpFlag().

1✔

517

                Build()

1✔

518

1✔

519

        return NewCommand("complete", "Autocomplete suggestions", "Returns the autocomplete suggestions").

1✔

520

                WithFlags(flags).

1✔

521

                WithAction(func(context *CommandExecContext) error {

2✔

522

                        commandText := context.String("command")

1✔

523

                        exclude := []string{}

1✔

524

                        for _, flagName := range FlagNamesPredefined {

2✔

525

                                exclude = append(exclude, "--"+flagName)

1✔

526

1✔

527

                        args := strings.Split(commandText, " ")

1✔

528

                        definitions, err := b.loadAutocompleteDefinitions(args, version)

1✔

529

                        if err != nil {

1✔

532

                        commands := b.createServiceCommands(definitions)

1✔

533

                        command := NewCommand("uipath", "", "").

1✔

534

                                WithSubcommands(commands)

1✔

535

                        handler := newAutoCompleteHandler()

1✔

536

                        words := handler.Find(commandText, command, exclude)

1✔

537

                        for _, word := range words {

2✔

538

                                fmt.Fprintln(b.StdOut, word)

1✔

539

1✔

540

                        return nil

1✔

544

func (b CommandBuilder) createAutoCompleteCommand(version string) *CommandDefinition {

1✔

545

        flags := NewFlagBuilder().

1✔

546

                AddHelpFlag().

1✔

547

                Build()

1✔

548

1✔

549

        subcommands := []*CommandDefinition{

1✔

550

                b.createAutoCompleteEnableCommand(),

1✔

551

                b.createAutoCompleteCompleteCommand(version),

1✔

552

1✔

553

1✔

554

        return NewCommand("autocomplete", "Autocompletion", "Commands for autocompletion").

1✔

555

                WithFlags(flags).

1✔

556

                WithSubcommands(subcommands)

1✔

557

1✔

559

func (b CommandBuilder) createConfigCommand() *CommandDefinition {

1✔

560

        const flagNameAuth = "auth"

1✔

561

1✔

562

        flags := NewFlagBuilder().

1✔

563

                AddFlag(NewFlag(flagNameAuth, fmt.Sprintf("Authorization type: %s, %s, %s", CredentialsAuth, LoginAuth, PatAuth), FlagTypeString)).

1✔

564

                AddFlag(NewFlag(FlagNameProfile, "Profile to configure", FlagTypeString).

1✔

565

                        WithEnvVarName("UIPATH_PROFILE").

1✔

566

                        WithDefaultValue(config.DefaultProfile)).

1✔

567

                AddHelpFlag().

1✔

568

                Build()

1✔

569

1✔

570

        subcommands := []*CommandDefinition{

1✔

571

                b.createConfigSetCommand(),

1✔

572

1✔

573

1✔

574

        return NewCommand("config", "Interactive Configuration", "Interactive command to configure the CLI").

1✔

575

                WithFlags(flags).

1✔

576

                WithSubcommands(subcommands).

1✔

577

                WithAction(func(context *CommandExecContext) error {

2✔

578

                        auth := context.String(flagNameAuth)

1✔

579

                        profileName := context.String(FlagNameProfile)

1✔

580

                        handler := newConfigCommandHandler(b.StdIn, b.StdOut, b.ConfigProvider)

1✔

581

                        return handler.Configure(auth, profileName)

1✔

582

})

1✔

585

func (b CommandBuilder) createConfigSetCommand() *CommandDefinition {

1✔

586

        const flagNameKey = "key"

1✔

587

        const flagNameValue = "value"

1✔

588

1✔

589

        flags := NewFlagBuilder().

1✔

590

                AddFlag(NewFlag(flagNameKey, "The key", FlagTypeString).

1✔

591

                        WithRequired(true)).

1✔

592

                AddFlag(NewFlag(flagNameValue, "The value to set", FlagTypeString).

1✔

593

                        WithRequired(true)).

1✔

594

                AddFlag(NewFlag(FlagNameProfile, "Profile to configure", FlagTypeString).

1✔

595

                        WithEnvVarName("UIPATH_PROFILE").

1✔

596

                        WithDefaultValue(config.DefaultProfile)).

1✔

597

                AddHelpFlag().

1✔

598

                Build()

1✔

599

1✔

600

        return NewCommand("set", "Set config parameters", "Set config parameters").

1✔

601

                WithFlags(flags).

1✔

602

                WithAction(func(context *CommandExecContext) error {

2✔

603

                        profileName := context.String(FlagNameProfile)

1✔

604

                        key := context.String(flagNameKey)

1✔

605

                        value := context.String(flagNameValue)

1✔

606

                        handler := newConfigCommandHandler(b.StdIn, b.StdOut, b.ConfigProvider)

1✔

607

                        return handler.Set(key, value, profileName)

1✔

608

})

1✔

611

func (b CommandBuilder) loadDefinitions(args []string, version string) ([]parser.Definition, error) {

1✔

612

        if len(args) <= 1 || strings.HasPrefix(args[1], "-") {

2✔

613

                return b.DefinitionProvider.Index(version)

1✔

614

1✔

615

        if len(args) > 1 && args[1] == "commands" {

2✔

616

                return b.loadAllDefinitions(version)

1✔

617

1✔

618

        definition, err := b.DefinitionProvider.Load(args[1], version)

1✔

619

        if definition == nil {

2✔

620

                return nil, err

1✔

621

1✔

622

        return []parser.Definition{*definition}, err

1✔

625

func (b CommandBuilder) loadAllDefinitions(version string) ([]parser.Definition, error) {

1✔

626

        all, err := b.DefinitionProvider.Index(version)

1✔

627

        if err != nil {

1✔

630

        definitions := []parser.Definition{}

1✔

631

        for _, d := range all {

2✔

632

                definition, err := b.DefinitionProvider.Load(d.Name, version)

1✔

633

                if err != nil {

1✔

636

                if definition != nil {

2✔

637

                        definitions = append(definitions, *definition)

1✔

638

1✔

640

        return definitions, nil

1✔

643

func (b CommandBuilder) loadAutocompleteDefinitions(args []string, version string) ([]parser.Definition, error) {

1✔

644

        if len(args) <= 2 {

2✔

645

                return b.DefinitionProvider.Index(version)

1✔

646

1✔

647

        return b.loadDefinitions(args, version)

1✔

650

func (b CommandBuilder) createShowCommand(definitions []parser.Definition) *CommandDefinition {

1✔

651

        flags := NewFlagBuilder().

1✔

652

                AddHelpFlag().

1✔

653

                Build()

1✔

654

1✔

655

        return NewCommand("show", "Print CLI commands", "Print available uipath CLI commands").

1✔

656

                WithFlags(flags).

1✔

657

                WithHidden(true).

1✔

658

                WithAction(func(context *CommandExecContext) error {

2✔

659

                        defaultFlags := NewFlagBuilder().

1✔

660

                                AddDefaultFlags(false).

1✔

661

                                AddHelpFlag().

1✔

662

                                Build()

1✔

663

1✔

664

                        handler := newShowCommandHandler()

1✔

665

                        output, err := handler.Execute(definitions, defaultFlags)

1✔

666

                        if err != nil {

1✔

669

                        fmt.Fprintln(b.StdOut, output)

1✔

670

                        return nil

1✔

674

func (b CommandBuilder) createInspectCommand(definitions []parser.Definition) *CommandDefinition {

1✔

675

        flags := NewFlagBuilder().

1✔

676

                AddHelpFlag().

1✔

677

                Build()

1✔

678

1✔

679

        subcommands := []*CommandDefinition{

1✔

680

                b.createShowCommand(definitions),

1✔

681

1✔

682

1✔

683

        return NewCommand("commands", "Inspect available CLI operations", "Command to inspect available uipath CLI operations").

1✔

684

                WithFlags(flags).

1✔

685

                WithSubcommands(subcommands).

1✔

686

                WithHidden(true)

1✔

687

1✔

689

func (b CommandBuilder) createServiceCommands(definitions []parser.Definition) []*CommandDefinition {

1✔

690

        commands := []*CommandDefinition{}

1✔

691

        for _, e := range definitions {

2✔

692

                command := b.createServiceCommand(e)

1✔

693

                commands = append(commands, command)

1✔

694

1✔

695

        return commands

1✔

698

func (b CommandBuilder) parseArgument(args []string, name string) string {

1✔

699

        for i, arg := range args {

2✔

700

                if strings.TrimSpace(arg) == "--"+name {

2✔

701

                        if len(args) > i+1 {

2✔

702

                                return strings.TrimSpace(args[i+1])

1✔

703

1✔

706

        return ""

1✔

709

func (b CommandBuilder) versionFromProfile(profile string) string {

1✔

710

        config := b.ConfigProvider.Config(profile)

1✔

711

        if config == nil {

2✔

712

                return ""

1✔

713

1✔

714

        return config.Version

1✔

717

func (b CommandBuilder) Create(args []string) ([]*CommandDefinition, error) {

1✔

718

        version := b.parseArgument(args, FlagNameVersion)

1✔

719

        profile := b.parseArgument(args, FlagNameProfile)

1✔

720

        if version == "" && profile != "" {

2✔

721

                version = b.versionFromProfile(profile)

1✔

722

1✔

723

        definitions, err := b.loadDefinitions(args, version)

1✔

724

        if err != nil {

2✔

725

                return nil, err

1✔

726

1✔

727

        servicesCommands := b.createServiceCommands(definitions)

1✔

728

        autocompleteCommand := b.createAutoCompleteCommand(version)

1✔

729

        configCommand := b.createConfigCommand()

1✔

730

        inspectCommand := b.createInspectCommand(definitions)

1✔

731

        commands := append(servicesCommands, autocompleteCommand, configCommand, inspectCommand)

1✔

732

        return commands, nil

1✔

UiPath / uipathcli / 11162363984

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

UiPath / uipathcli / 11162363984

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