13944852368

Committed 19 Mar 2025 10:56AM UTC coverage: 90.44% (+0.3%) from 90.112%

Build # 13944852368

Build Type

push

github

Committed by

thschmitt

Commit Message

Add new api package with orchestrator and du client

- Moved the orchestrator client to new api package.

- Extracted client-related logic from the DigitizeCommand and
  Upload/DownloadCommand into the new api package.

- Changed auth module to only return the auth token and no more
  additional headers to simplify the auth module.

Run Details

260 of 291 new or added lines in 21 files covered. (89.35%)

1 existing line in 1 file now uncovered.

5894 of 6517 relevant lines covered (90.44%)

1.01 hits per line

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

95.65

/plugin/digitizer/digitize_command.go

package digitzer

import (
        "errors"
        "fmt"
        "net/url"
        "strings"
        "time"

        "github.com/UiPath/uipathcli/log"
        "github.com/UiPath/uipathcli/output"
        "github.com/UiPath/uipathcli/plugin"
        "github.com/UiPath/uipathcli/utils/api"
        "github.com/UiPath/uipathcli/utils/stream"
        "github.com/UiPath/uipathcli/utils/visualization"
)

// The DigitizeCommand is a convenient wrapper over the async digitizer API
// to make it seem like it is a single sync call.
type DigitizeCommand struct{}

func (c DigitizeCommand) Command() plugin.Command {
        return *plugin.NewCommand("du").
                WithCategory("digitization", "Document Digitization", "Digitizes a document, extracting its Document Object Model (DOM) and text.").
                WithOperation("digitize", "Digitize file", "Digitize the given file").
                WithParameter("project-id", plugin.ParameterTypeString, "The project id", false).
                WithParameter("file", plugin.ParameterTypeBinary, "The file to digitize", true).
                WithParameter("content-type", plugin.ParameterTypeString, "The content type", false)
}

func (c DigitizeCommand) Execute(ctx plugin.ExecutionContext, writer output.OutputWriter, logger log.Logger) error {
        if ctx.Organization == "" {
                return errors.New("Organization is not set")
        }
        if ctx.Tenant == "" {
                return errors.New("Tenant is not set")
        }
        documentId, err := c.startDigitization(ctx, logger)
        if err != nil {
                return err
        }

        for i := 1; i <= 60; i++ {
                finished, err := c.waitForDigitization(documentId, ctx, writer, logger)
                if err != nil {
                        return err
                }
                if finished {
                        return nil
                }
                time.Sleep(1 * time.Second)
        }
        return fmt.Errorf("Digitization with documentId '%s' did not finish in time", documentId)
}

func (c DigitizeCommand) startDigitization(ctx plugin.ExecutionContext, logger log.Logger) (string, error) {
        uploadBar := visualization.NewProgressBar(logger)
        defer uploadBar.Remove()

        projectId := c.getProjectId(ctx.Parameters)
        file := ctx.Input
        if file == nil {
                file = c.getFileParameter(ctx.Parameters)
        }
        contentType := c.getParameter("content-type", ctx.Parameters)
        if contentType == "" {
                contentType = "application/octet-stream"
        }

        baseUri := c.formatUri(ctx.BaseUri, ctx.Organization, ctx.Tenant)
        client := api.NewDuClient(baseUri, ctx.Auth.Token, ctx.Debug, ctx.Settings, logger)
        return client.StartDigitization(projectId, file, contentType, uploadBar)
}

func (c DigitizeCommand) waitForDigitization(documentId string, ctx plugin.ExecutionContext, writer output.OutputWriter, logger log.Logger) (bool, error) {
        projectId := c.getProjectId(ctx.Parameters)
        baseUri := c.formatUri(ctx.BaseUri, ctx.Organization, ctx.Tenant)
        client := api.NewDuClient(baseUri, ctx.Auth.Token, ctx.Debug, ctx.Settings, logger)
        result, err := client.GetDigitizationResult(projectId, documentId)
        if err != nil {
                return true, err
        }
        if result == "" {
                return false, nil
        }

        err = writer.WriteResponse(*output.NewResponseInfo(200, "200 OK", "HTTP/1.1", map[string][]string{}, strings.NewReader(result)))
        return true, err
}

func (c DigitizeCommand) formatUri(baseUri url.URL, org string, tenant string) string {
        path := baseUri.Path
        if baseUri.Path == "" {
                path = "/{organization}/{tenant}/du_"
        }
        path = strings.ReplaceAll(path, "{organization}", org)
        path = strings.ReplaceAll(path, "{tenant}", tenant)
        path = strings.TrimSuffix(path, "/")
        return fmt.Sprintf("%s://%s%s", baseUri.Scheme, baseUri.Host, path)
}

func (c DigitizeCommand) getProjectId(parameters []plugin.ExecutionParameter) string {
        projectId := c.getParameter("project-id", parameters)
        if projectId == "" {
                projectId = "00000000-0000-0000-0000-000000000000"
        }
        return projectId
}

func (c DigitizeCommand) getParameter(name string, parameters []plugin.ExecutionParameter) string {
        result := ""
        for _, p := range parameters {
                if p.Name == name {
                        if data, ok := p.Value.(string); ok {
                                result = data
                                break
                        }
                }
        }
        return result
}

func (c DigitizeCommand) getFileParameter(parameters []plugin.ExecutionParameter) stream.Stream {
        var result stream.Stream
        for _, p := range parameters {
                if p.Name == "file" {
                        if stream, ok := p.Value.(stream.Stream); ok {
                                result = stream
                                break
                        }
                }
        }
        return result
}

func NewDigitizeCommand() *DigitizeCommand {
        return &DigitizeCommand{}
}

1	package digitzer
2
3	import (
4	"errors"
5	"fmt"
6	"net/url"
7	"strings"
8	"time"
9
10	"github.com/UiPath/uipathcli/log"
11	"github.com/UiPath/uipathcli/output"
12	"github.com/UiPath/uipathcli/plugin"
13	"github.com/UiPath/uipathcli/utils/api"
14	"github.com/UiPath/uipathcli/utils/stream"
15	"github.com/UiPath/uipathcli/utils/visualization"
16	)
17
18	// The DigitizeCommand is a convenient wrapper over the async digitizer API
19	// to make it seem like it is a single sync call.
20	type DigitizeCommand struct{}
21
22	func (c DigitizeCommand) Command() plugin.Command {	1✔
23	return *plugin.NewCommand("du").	1✔
24	WithCategory("digitization", "Document Digitization", "Digitizes a document, extracting its Document Object Model (DOM) and text.").	1✔
25	WithOperation("digitize", "Digitize file", "Digitize the given file").	1✔
26	WithParameter("project-id", plugin.ParameterTypeString, "The project id", false).	1✔
27	WithParameter("file", plugin.ParameterTypeBinary, "The file to digitize", true).	1✔
28	WithParameter("content-type", plugin.ParameterTypeString, "The content type", false)	1✔
29	}	1✔
30
31	func (c DigitizeCommand) Execute(ctx plugin.ExecutionContext, writer output.OutputWriter, logger log.Logger) error {	1✔
32	if ctx.Organization == "" {	2✔
33	return errors.New("Organization is not set")	1✔
34	}	1✔
35	if ctx.Tenant == "" {	2✔
36	return errors.New("Tenant is not set")	1✔
37	}	1✔
38	documentId, err := c.startDigitization(ctx, logger)	1✔
39	if err != nil {	2✔
40	return err	1✔
41	}	1✔
42
43	for i := 1; i <= 60; i++ {	2✔
44	finished, err := c.waitForDigitization(documentId, ctx, writer, logger)	1✔
45	if err != nil {	2✔
46	return err	1✔
47	}	1✔
48	if finished {	2✔
49	return nil	1✔
50	}	1✔
51	time.Sleep(1 * time.Second)	×
52	}
53	return fmt.Errorf("Digitization with documentId '%s' did not finish in time", documentId)	×
54	}
55
56	func (c DigitizeCommand) startDigitization(ctx plugin.ExecutionContext, logger log.Logger) (string, error) {	1✔
57	uploadBar := visualization.NewProgressBar(logger)	1✔
58	defer uploadBar.Remove()	1✔
59		1✔
60	projectId := c.getProjectId(ctx.Parameters)	1✔
61	file := ctx.Input	1✔
62	if file == nil {	2✔
63	file = c.getFileParameter(ctx.Parameters)	1✔
64	}	1✔
65	contentType := c.getParameter("content-type", ctx.Parameters)	1✔
66	if contentType == "" {	2✔
67	contentType = "application/octet-stream"	1✔
68	}	1✔
69
70	baseUri := c.formatUri(ctx.BaseUri, ctx.Organization, ctx.Tenant)	1✔
71	client := api.NewDuClient(baseUri, ctx.Auth.Token, ctx.Debug, ctx.Settings, logger)	1✔
72	return client.StartDigitization(projectId, file, contentType, uploadBar)	1✔
73	}
74
75	func (c DigitizeCommand) waitForDigitization(documentId string, ctx plugin.ExecutionContext, writer output.OutputWriter, logger log.Logger) (bool, error) {	1✔
76	projectId := c.getProjectId(ctx.Parameters)	1✔
77	baseUri := c.formatUri(ctx.BaseUri, ctx.Organization, ctx.Tenant)	1✔
78	client := api.NewDuClient(baseUri, ctx.Auth.Token, ctx.Debug, ctx.Settings, logger)	1✔
79	result, err := client.GetDigitizationResult(projectId, documentId)	1✔
80	if err != nil {	2✔
81	return true, err	1✔
82	}	1✔
83	if result == "" {	1✔
NEW 84	return false, nil	×
UNCOV 85	}	×
86
87	err = writer.WriteResponse(*output.NewResponseInfo(200, "200 OK", "HTTP/1.1", map[string][]string{}, strings.NewReader(result)))	1✔
88	return true, err	1✔
89	}
90
91	func (c DigitizeCommand) formatUri(baseUri url.URL, org string, tenant string) string {	1✔
92	path := baseUri.Path	1✔
93	if baseUri.Path == "" {	2✔
94	path = "/{organization}/{tenant}/du_"	1✔
95	}	1✔
96	path = strings.ReplaceAll(path, "{organization}", org)	1✔
97	path = strings.ReplaceAll(path, "{tenant}", tenant)	1✔
98	path = strings.TrimSuffix(path, "/")	1✔
99	return fmt.Sprintf("%s://%s%s", baseUri.Scheme, baseUri.Host, path)	1✔
100	}
101
102	func (c DigitizeCommand) getProjectId(parameters []plugin.ExecutionParameter) string {	1✔
103	projectId := c.getParameter("project-id", parameters)	1✔
104	if projectId == "" {	2✔
105	projectId = "00000000-0000-0000-0000-000000000000"	1✔
106	}	1✔
107	return projectId	1✔
108	}
109
110	func (c DigitizeCommand) getParameter(name string, parameters []plugin.ExecutionParameter) string {	1✔
111	result := ""	1✔
112	for _, p := range parameters {	2✔
113	if p.Name == name {	2✔
114	if data, ok := p.Value.(string); ok {	2✔
115	result = data	1✔
116	break	1✔
117	}
118	}
119	}
120	return result	1✔
121	}
122
123	func (c DigitizeCommand) getFileParameter(parameters []plugin.ExecutionParameter) stream.Stream {	1✔
124	var result stream.Stream	1✔
125	for _, p := range parameters {	2✔
126	if p.Name == "file" {	2✔
127	if stream, ok := p.Value.(stream.Stream); ok {	2✔
128	result = stream	1✔
129	break	1✔
130	}
131	}
132	}
133	return result	1✔
134	}
135
136	func NewDigitizeCommand() *DigitizeCommand {	1✔
137	return &DigitizeCommand{}	1✔
138	}	1✔

UiPath / uipathcli / 13944852368

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