feat(t230): use OCR for ERP session login

backend-api/internal/platform/ocrapi/client.go

@@ -0,0 +1,138 @@
+package ocrapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+const (
+	defaultTimeout    = 5 * time.Second
+	maximumReplyBytes = 64 << 10
+)
+
+var ErrServiceInvalid = errors.New("OCR service is invalid")
+
+type Client struct {
+	endpoint string
+	http     *http.Client
+}
+
+func NewClient(endpoint string, timeout time.Duration) (*Client, error) {
+	endpoint = strings.TrimSpace(endpoint)
+	if endpoint == "" {
+		return nil, nil
+	}
+	if timeout <= 0 {
+		timeout = defaultTimeout
+	}
+	return &Client{
+		endpoint: endpoint,
+		http: &http.Client{
+			Timeout: timeout,
+			CheckRedirect: func(*http.Request, []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
+		},
+	}, nil
+}
+
+func (client *Client) Recognize(
+	ctx context.Context,
+	image []byte,
+	contentType string,
+) (string, error) {
+	if client == nil || len(image) == 0 || !strings.HasPrefix(contentType, "image/") {
+		return "", ErrServiceInvalid
+	}
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	part, err := writer.CreateFormFile("file", "captcha"+extension(contentType))
+	if err != nil {
+		return "", ErrServiceInvalid
+	}
+	if _, err := part.Write(image); err != nil || writer.Close() != nil {
+		return "", ErrServiceInvalid
+	}
+	request, err := http.NewRequestWithContext(
+		ctx,
+		http.MethodPost,
+		client.endpoint,
+		&body,
+	)
+	if err != nil {
+		return "", ErrServiceInvalid
+	}
+	request.Header.Set("Content-Type", writer.FormDataContentType())
+	response, err := client.http.Do(request)
+	if err != nil {
+		return "", ErrServiceInvalid
+	}
+	defer response.Body.Close()
+	if response.StatusCode < http.StatusOK || response.StatusCode >= http.StatusMultipleChoices {
+		return "", ErrServiceInvalid
+	}
+	reply, err := readBounded(response.Body, maximumReplyBytes)
+	if err != nil {
+		return "", ErrServiceInvalid
+	}
+	code, err := parseCode(reply, response.Header.Get("Content-Type"))
+	if err != nil {
+		return "", ErrServiceInvalid
+	}
+	return code, nil
+}
+
+func parseCode(reply []byte, contentType string) (string, error) {
+	value := ""
+	if strings.HasPrefix(strings.ToLower(contentType), "application/json") {
+		var object map[string]any
+		if err := json.Unmarshal(reply, &object); err != nil {
+			return "", ErrServiceInvalid
+		}
+		for _, key := range []string{"text", "result", "data"} {
+			if candidate, ok := object[key].(string); ok {
+				value = candidate
+				break
+			}
+		}
+	} else {
+		value = string(reply)
+	}
+	value = strings.TrimSpace(value)
+	if value == "" || len([]byte(value)) > 64 || !utf8.ValidString(value) {
+		return "", ErrServiceInvalid
+	}
+	for _, character := range value {
+		if character < 32 || character == 127 {
+			return "", ErrServiceInvalid
+		}
+	}
+	return value, nil
+}
+
+func extension(contentType string) string {
+	switch contentType {
+	case "image/png":
+		return ".png"
+	case "image/jpeg":
+		return ".jpg"
+	default:
+		return ".img"
+	}
+}
+
+func readBounded(reader io.Reader, maximum int64) ([]byte, error) {
+	result, err := io.ReadAll(io.LimitReader(reader, maximum+1))
+	if err != nil || int64(len(result)) > maximum {
+		return nil, ErrServiceInvalid
+	}
+	return result, nil
+}

backend-api/internal/platform/ocrapi/client_test.go

@@ -0,0 +1,65 @@
+package ocrapi
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestClientRecognizePostsMultipartAndParsesSupportedReplies(t *testing.T) {
+	for _, testCase := range []struct {
+		name        string
+		contentType string
+		body        string
+		want        string
+	}{
+		{"text", "text/plain", "aB12", "aB12"},
+		{"json", "application/json", `{"text":"K9"}`, "K9"},
+		{"result", "application/json", `{"result":"Z7"}`, "Z7"},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodPost || r.URL.Path != "/ocr" {
+					t.Fatalf("request = %s %s", r.Method, r.URL.Path)
+				}
+				file, header, err := r.FormFile("file")
+				if err != nil || header.Filename != "captcha.png" {
+					t.Fatalf("FormFile() = %v / %#v", err, header)
+				}
+				content, _ := io.ReadAll(file)
+				if string(content) != "image-bytes" {
+					t.Fatalf("image content = %q", content)
+				}
+				w.Header().Set("Content-Type", testCase.contentType)
+				_, _ = w.Write([]byte(testCase.body))
+			}))
+			defer server.Close()
+			client, err := NewClient(server.URL+"/ocr", 0)
+			if err != nil {
+				t.Fatalf("NewClient() error = %v", err)
+			}
+			actual, err := client.Recognize(context.Background(), []byte("image-bytes"), "image/png")
+			if err != nil || actual != testCase.want {
+				t.Fatalf("Recognize() = %q, %v", actual, err)
+			}
+		})
+	}
+}
+
+func TestClientRecognizeFailsClosed(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Redirect(w, r, "/other", http.StatusFound)
+	}))
+	defer server.Close()
+	client, err := NewClient(server.URL+"/ocr", 0)
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+	_, err = client.Recognize(context.Background(), []byte("image"), "image/png")
+	if !errors.Is(err, ErrServiceInvalid) {
+		t.Fatalf("Recognize() error = %v", err)
+	}
+}