CON-1716 MT API endpoints

api/mt/base.go

@@ -0,0 +1,33 @@
+package mt
+
+import (
+	"strings"
+
+	"github.com/Smartling/api-sdk-go/helpers/sm_client"
+)
+
+const (
+	SuccessResponseCode       = "SUCCESS"
+	QueuedTranslatedState     = "QUEUED"
+	ProcessingTranslatedState = "PROCESSING"
+	FailedTranslatedState     = "FAILED"
+	CanceledTranslatedState   = "CANCELED"
+	CompletedTranslatedState  = "COMPLETED"
+)
+
+var (
+	mtBasePath                 = "/file-translations-api/v2/"
+	contentTypeApplicationJson = "Content-Type:application/json"
+)
+
+type base struct {
+	client *smclient.Client
+}
+
+func newBase(client *smclient.Client) *base {
+	return &base{client: client}
+}
+
+func joinPath(left, right string) string {
+	return strings.TrimRight(left, "/") + "/" + strings.TrimLeft(right, "/")
+}

api/mt/downloader.go

@@ -0,0 +1,68 @@
+package mt
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/Smartling/api-sdk-go/helpers/sm_client"
+	"github.com/Smartling/api-sdk-go/helpers/sm_file"
+)
+
+// Downloader defines downloader behaviour
+type Downloader interface {
+	File(accountUID AccountUID, fileUID FileUID,
+		mtUID MtUID, localeID string) (io.Reader, error)
+	Batch(accountUID AccountUID, fileUID FileUID, mtUID MtUID) (io.Reader, error)
+}
+
+// NewDownloader returns new Downloader implementation
+func NewDownloader(client *smclient.Client) Downloader {
+	return newHttpDownloader(newBase(client))
+}
+
+type httpDownloader struct {
+	base *base
+}
+
+func newHttpDownloader(base *base) *httpDownloader {
+	return &httpDownloader{base: base}
+}
+
+// File downloads file
+func (d httpDownloader) File(accountUID AccountUID, fileUID FileUID,
+	mtUID MtUID, localeID string) (io.Reader, error) {
+	filePath := buildFilePath(accountUID, fileUID, mtUID, localeID)
+	path := joinPath(mtBasePath, filePath)
+	reader, _, err := d.base.client.Get(
+		path,
+		smfile.FileURIRequest{FileURI: string(fileUID)}.GetQuery(),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to download original file: %w", err)
+	}
+
+	return reader, nil
+}
+
+// Batch download files
+func (d httpDownloader) Batch(accountUID AccountUID, fileUID FileUID, mtUID MtUID) (io.Reader, error) {
+	batchPath := buildBatchPath(accountUID, fileUID, mtUID)
+	path := joinPath(mtBasePath, batchPath)
+	reader, _, err := d.base.client.Get(
+		path,
+		smfile.FileURIRequest{FileURI: string(fileUID)}.GetQuery(),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to download original file: %w", err)
+	}
+
+	return reader, nil
+}
+
+func buildFilePath(accountUID AccountUID, fileUID FileUID, mtUID MtUID, localeID string) string {
+	return "/accounts/" + string(accountUID) + "/files/" + string(fileUID) + "/mt/" + string(mtUID) + "/locales/" + localeID + "/file"
+}
+
+func buildBatchPath(accountUID AccountUID, fileUID FileUID, mtUID MtUID) string {
+	return "/accounts/" + string(accountUID) + "/files/" + string(fileUID) + "/mt/" + string(mtUID) + "/locales/all/file/zip"
+}

api/mt/file_translator.go

@@ -0,0 +1,85 @@
+package mt
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/Smartling/api-sdk-go/helpers/sm_client"
+	"github.com/Smartling/api-sdk-go/helpers/sm_file"
+)
+
+// FileTranslator defines file behaviour
+type FileTranslator interface {
+	Start(accountUID AccountUID, fileUID FileUID, p StartParams) (StartResponse, error)
+	Progress(accountUID AccountUID, fileUID FileUID, mtUID MtUID) (ProgressResponse, error)
+}
+
+// NewFileTranslator returns new FileTranslator implementation
+func NewFileTranslator(client *smclient.Client) FileTranslator {
+	return httpFileTranslator{base: newBase(client)}
+}
+
+type httpFileTranslator struct {
+	base *base
+}
+
+type StartParams struct {
+	SourceLocaleIO  string   `json:"sourceLocaleId"`
+	TargetLocaleIDs []string `json:"targetLocaleIds"`
+}
+
+// Start starts file translation
+func (h httpFileTranslator) Start(accountUID AccountUID, fileUID FileUID, p StartParams) (StartResponse, error) {
+	startPath := buildStartPath(accountUID, fileUID)
+	path := joinPath(mtBasePath, startPath)
+
+	payload, err := json.Marshal(p)
+	if err != nil {
+		return StartResponse{}, err
+	}
+
+	resp, err := h.base.client.Post(path, payload)
+	if err != nil {
+		return StartResponse{}, fmt.Errorf("failed to start file translation: %w", err)
+	}
+	type startResponse struct {
+		Response struct {
+			Code string `json:"code"`
+			Data struct {
+				MtUID string `json:"mtUid"`
+			} `json:"data"`
+		} `json:"response"`
+	}
+	var res startResponse
+	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
+		return StartResponse{}, fmt.Errorf("failed to parse response: %w", err)
+	}
+	return StartResponse{
+		Code:  res.Response.Code,
+		MtUID: MtUID(res.Response.Data.MtUID),
+	}, nil
+}
+
+// Progress return progress of file translation
+func (h httpFileTranslator) Progress(accountUID AccountUID, fileUID FileUID, mtUID MtUID) (ProgressResponse, error) {
+	var res ProgressResponse
+	progressPath := buildProgressPath(accountUID, fileUID, mtUID)
+	path := joinPath(mtBasePath, progressPath)
+	_, _, err := h.base.client.GetJSON(
+		path,
+		smfile.FileURIRequest{FileURI: string(fileUID)}.GetQuery(),
+		&res,
+	)
+	if err != nil {
+		return ProgressResponse{}, fmt.Errorf("failed to get progress file translation: %w", err)
+	}
+	return res, nil
+}
+
+func buildStartPath(accountUID AccountUID, fileUID FileUID) string {
+	return "/accounts/" + string(accountUID) + "/files/" + string(fileUID) + "/mt"
+}
+
+func buildProgressPath(accountUID AccountUID, fileUID FileUID, mtUID MtUID) string {
+	return "/accounts/" + string(accountUID) + "/files/" + string(fileUID) + "/mt/" + string(mtUID) + "/status"
+}

api/mt/file_translator_ent.go

@@ -0,0 +1,99 @@
+package mt
+
+// StartResponse defines start translation response
+type StartResponse struct {
+	Code  string
+	MtUID MtUID
+}
+
+// StartResponse defines start translation response
+type startResponse struct {
+	Response struct {
+		Code string `json:"code"`
+		Data struct {
+			MtUID string `json:"mtUid"`
+		} `json:"data"`
+	} `json:"response"`
+}
+
+func toStartResponse(r startResponse) StartResponse {
+	return StartResponse{
+		Code:  r.Response.Code,
+		MtUID: MtUID(r.Response.Data.MtUID),
+	}
+}
+
+// ProgressResponse defines progress translation response
+type ProgressResponse struct {
+	Code                  string
+	State                 string
+	RequestedStringCount  int
+	Error                 string
+	LocaleProcessStatuses []LocaleProcessStatusResponse
+}
+
+// LocaleProcessStatusResponse defines locale process status response
+type LocaleProcessStatusResponse struct {
+	LocaleID             string
+	State                string
+	ProcessedStringCount int
+	Error                ErrorResponse
+}
+
+// ErrorResponse defines error response
+type ErrorResponse struct {
+	Key     string
+	Message string
+	ErrorID string
+}
+
+// IsSet checks if ErrorResponse is set
+func (e ErrorResponse) IsSet() bool {
+	return e.Key != ""
+}
+
+type progressResponse struct {
+	Response struct {
+		Code string `json:"code"`
+		Data struct {
+			State                 string `json:"state"`
+			RequestedStringCount  int    `json:"requestedStringCount"`
+			Error                 string `json:"error;omitempty"`
+			LocaleProcessStatuses []struct {
+				LocaleID             string `json:"localeId"`
+				State                string `json:"state"`
+				ProcessedStringCount int    `json:"processedStringCount"`
+				Error                *struct {
+					Key     string `json:"key"`
+					Message string `json:"message"`
+					Details struct {
+						ErrorID string `json:"errorId"`
+					} `json:"details"`
+				} `json:"error"`
+			} `json:"localeProcessStatuses"`
+		} `json:"data"`
+	} `json:"response"`
+}
+
+func toProgressResponse(r progressResponse) ProgressResponse {
+	localeProcessStatuses := make([]LocaleProcessStatusResponse, len(r.Response.Data.LocaleProcessStatuses))
+	for key, val := range r.Response.Data.LocaleProcessStatuses {
+		localeProcessStatuses[key] = LocaleProcessStatusResponse{
+			LocaleID:             val.LocaleID,
+			State:                val.State,
+			ProcessedStringCount: val.ProcessedStringCount,
+			Error: ErrorResponse{
+				Key:     val.Error.Key,
+				Message: val.Error.Message,
+				ErrorID: val.Error.Details.ErrorID,
+			},
+		}
+	}
+	return ProgressResponse{
+		Code:                  r.Response.Code,
+		State:                 r.Response.Data.State,
+		RequestedStringCount:  r.Response.Data.RequestedStringCount,
+		Error:                 r.Response.Data.Error,
+		LocaleProcessStatuses: localeProcessStatuses,
+	}
+}

api/mt/file_type.go

@@ -0,0 +1,58 @@
+package mt
+
+// FileType is type for file types
+//
+//go:generate stringer -type=FileType
+type FileType int
+
+const (
+	DOCX FileType = iota + 1
+	DOCM
+	RTF
+	PPTX
+	XLSX
+	IDML
+	RESX
+	PLAIN_TEXT
+	XML
+	HTML
+	PRES
+	SRT
+	MARKDOWN
+	DITA
+	VTT
+	FLARE
+	SVG
+	XLIFF2
+	CSV
+	JSON
+	XLSX_TEMPLATE
+)
+
+// FileTypeByExt contains map with FileType by file extension
+var FileTypeByExt = map[string]FileType{
+	".docx":          DOCX,
+	".docm":          DOCM,
+	".rtf":           RTF,
+	".pptx":          PPTX,
+	".xlsx":          XLSX,
+	".idml":          IDML,
+	".resx":          RESX,
+	".txt":           PLAIN_TEXT,
+	".xml":           XML,
+	".html":          HTML,
+	".htm":           HTML,
+	".pres":          PRES,
+	".srt":           SRT,
+	".md":            MARKDOWN,
+	".markdown":      MARKDOWN,
+	".dita":          DITA,
+	".vtt":           VTT,
+	".zip":           FLARE,
+	".svg":           SVG,
+	".xlf":           XLIFF2,
+	".xliff":         XLIFF2,
+	".csv":           CSV,
+	".json":          JSON,
+	".xlsx_template": XLSX_TEMPLATE,
+}