qiyuesuo-client/client.go

package qiyuesuosdk

import (
	"bytes"
	"crypto/md5"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/url"
	"strings"
	"time"

	"git.sxidc.com/student-physical-examination/contract_lock_sdk/utils"
	"github.com/google/uuid"
)

// Client 契约锁开放平台客户端；仅封装 HTTP/签名与契约锁 API，不含业务状态机。
type Client struct {
	cfg          Config
	signDefaults SignDefaults
	sdk          *utils.SdkClient
	http         *http.Client
}

// New 创建客户端。signDefaults 可为零值，签章时可按请求单独传入 ProcessID/Launcher。
func New(cfg Config, signDefaults SignDefaults) *Client {
	address := strings.TrimRight(cfg.Address, "/")
	return &Client{
		cfg:          cfg,
		signDefaults: signDefaults,
		sdk:          utils.NewSdkClient(address, cfg.AppToken, cfg.AppSecret),
		http:         &http.Client{Timeout: 60 * time.Second},
	}
}

func (c *Client) baseURL() string {
	return strings.TrimRight(c.cfg.Address, "/")
}

// PortalURL 契约锁用户前台地址（制章、验证码登录）。
func (c *Client) PortalURL() string {
	return UserPortalURL(c.baseURL())
}

func (c *Client) authHeaders() map[string]string {
	nonce := uuid.NewString()
	timestamp := fmt.Sprintf("%d", time.Now().UnixMilli())
	raw := c.cfg.AppToken + c.cfg.AppSecret + timestamp + nonce
	sum := md5.Sum([]byte(raw))
	return map[string]string{
		"x-qys-accesstoken": c.cfg.AppToken,
		"x-qys-timestamp":   timestamp,
		"x-qys-nonce":       nonce,
		"x-qys-signature":   hex.EncodeToString(sum[:]),
	}
}

func (c *Client) postJSON(path string, body any, out any) error {
	payload, err := json.Marshal(body)
	if err != nil {
		return err
	}
	req, err := http.NewRequest(http.MethodPost, c.baseURL()+path, bytes.NewReader(payload))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
	for k, v := range c.authHeaders() {
		req.Header.Set(k, v)
	}
	return c.doJSON(req, out)
}

func (c *Client) getQuery(path string, query url.Values, out any) error {
	u := c.baseURL() + path
	if len(query) > 0 {
		u += "?" + query.Encode()
	}
	req, err := http.NewRequest(http.MethodGet, u, nil)
	if err != nil {
		return err
	}
	for k, v := range c.authHeaders() {
		req.Header.Set(k, v)
	}
	return c.doJSON(req, out)
}

func (c *Client) doJSON(req *http.Request, out any) error {
	resp, err := c.http.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	data, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	if out == nil {
		return nil
	}
	return json.Unmarshal(data, out)
}

func (c *Client) postMultipart(path string, fields map[string]string, fileField string, fileBytes []byte, out any) error {
	var buf bytes.Buffer
	w := multipart.NewWriter(&buf)
	for k, v := range fields {
		if err := w.WriteField(k, v); err != nil {
			return err
		}
	}
	if len(fileBytes) > 0 && fileField != "" {
		part, err := w.CreateFormFile(fileField, "document.pdf")
		if err != nil {
			return err
		}
		if _, err = part.Write(fileBytes); err != nil {
			return err
		}
	}
	if err := w.Close(); err != nil {
		return err
	}

	req, err := http.NewRequest(http.MethodPost, c.baseURL()+path, &buf)
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", w.FormDataContentType())
	for k, v := range c.authHeaders() {
		req.Header.Set(k, v)
	}
	return c.doJSON(req, out)
}

func (c *Client) postForImageBytes(path string, body any) ([]byte, string, error) {
	payload, err := json.Marshal(body)
	if err != nil {
		return nil, "", err
	}
	req, err := http.NewRequest(http.MethodPost, c.baseURL()+path, bytes.NewReader(payload))
	if err != nil {
		return nil, "", err
	}
	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
	req.Header.Set("Accept", "application/json,image/*,*/*")
	for k, v := range c.authHeaders() {
		req.Header.Set(k, v)
	}
	resp, err := c.http.Do(req)
	if err != nil {
		return nil, "", err
	}
	defer resp.Body.Close()
	data, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, "", err
	}
	contentType := strings.TrimSpace(strings.Split(resp.Header.Get("Content-Type"), ";")[0])
	if len(data) > 0 && data[0] == '{' {
		var wrapper struct {
			apiResponse
			Result json.RawMessage `json:"result"`
		}
		if err = json.Unmarshal(data, &wrapper); err != nil {
			return nil, "", err
		}
		if err = wrapper.err(); err != nil {
			return nil, "", err
		}
		if len(wrapper.Result) == 0 || string(wrapper.Result) == "null" {
			return nil, "", ErrSealImageUnavailable
		}
		var resultStr string
		if err = json.Unmarshal(wrapper.Result, &resultStr); err == nil && resultStr != "" {
			img, decErr := base64.StdEncoding.DecodeString(resultStr)
			if decErr != nil {
				return nil, "", decErr
			}
			if contentType == "" {
				contentType = "image/png"
			}
			return img, contentType, nil
		}
		return nil, "", ErrSealImageUnavailable
	}
	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		return nil, "", fmt.Errorf("qiyuesuo: http %d", resp.StatusCode)
	}
	if contentType == "" {
		contentType = "image/png"
	}
	return data, contentType, nil
}

func (c *Client) download(path string, query url.Values) ([]byte, error) {
	u := c.baseURL() + path
	if len(query) > 0 {
		u += "?" + query.Encode()
	}
	req, err := http.NewRequest(http.MethodGet, u, nil)
	if err != nil {
		return nil, err
	}
	for k, v := range c.authHeaders() {
		req.Header.Set(k, v)
	}
	resp, err := c.http.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	return io.ReadAll(resp.Body)
}

func (c *Client) serviceOK(resp *utils.SdkResponse) error {
	if resp == nil {
		return fmt.Errorf("qiyuesuo: empty sdk response")
	}
	if resp.Message == "SUCCESS" {
		return nil
	}
	return fmt.Errorf("qiyuesuo: %s", resp.Message)
}

func (c *Client) serviceString(resp *utils.SdkResponse) (string, error) {
	if err := c.serviceOK(resp); err != nil {
		return "", err
	}
	if resp.Result == nil {
		return "", nil
	}
	if s, ok := resp.Result.(string); ok {
		return s, nil
	}
	return "", fmt.Errorf("qiyuesuo: unexpected result type %T", resp.Result)
}

func (c *Client) resolveProcessID(id string) string {
	if id != "" {
		return id
	}
	return c.signDefaults.ProcessID
}

func (c *Client) resolveLauncher(name string) string {
	if name != "" {
		return name
	}
	return c.signDefaults.TenantName
}