package questiontable import ( "bytes" "context" "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "strings" "sync" "time" ) // Default DingTalk API base. const defaultBase = "https://api.dingtalk.com" // Config holds the required parameters for the DingTalk question-table client. type Config struct { ClientID string Secret string BaseID string SheetID string OperatorID string FieldMapping map[string]string // TokenURL overrides the token endpoint. Empty → default. TokenURL string // BaseURL overrides the API base. Empty → default. BaseURL string } // defaultTransport is a clone of http.DefaultTransport with Proxy=nil so the // default client never uses a proxy (even from env). Shared across clients. var defaultTransport = func() *http.Transport { dt, ok := http.DefaultTransport.(*http.Transport) if !ok { return &http.Transport{ Proxy: nil, ForceAttemptHTTP2: true, MaxIdleConns: 100, IdleConnTimeout: 90 * time.Second, TLSHandshakeTimeout: 10 * time.Second, ExpectContinueTimeout: 1 * time.Second, } } // Clone, then clear Proxy. clone := dt.Clone() clone.Proxy = nil return clone }() // Client is a stdlib-only DingTalk HTTP client that inserts records into a // Notable v1 base. It owns a mutex-protected in-memory access-token cache. type Client struct { clientID string secret string baseID string sheetID string operatorID string fieldMapping map[string]string tokenURL string baseURL string http *http.Client mu sync.Mutex token string tokenExp time.Time } // NewClient creates a validated Client. It returns an error when any of // clientID, secret, baseID, sheetID, or operatorID is empty. // httpClient may be nil; a default is used in that case. func NewClient(cfg Config, httpClient *http.Client) (*Client, error) { // Trim and validate. clientID := strings.TrimSpace(cfg.ClientID) if clientID == "" { return nil, errors.New("questiontable: client id is required") } secret := strings.TrimSpace(cfg.Secret) if secret == "" { return nil, errors.New("questiontable: secret is required") } baseID := strings.TrimSpace(cfg.BaseID) if baseID == "" { return nil, errors.New("questiontable: base id is required") } sheetID := strings.TrimSpace(cfg.SheetID) if sheetID == "" { return nil, errors.New("questiontable: sheet id is required") } operatorID := strings.TrimSpace(cfg.OperatorID) if operatorID == "" { return nil, errors.New("questiontable: operator id is required") } if httpClient == nil { httpClient = &http.Client{ Transport: defaultTransport, Timeout: 30 * time.Second, } } tokenURL := strings.TrimSpace(cfg.TokenURL) if tokenURL == "" { tokenURL = defaultBase + "/v1.0/oauth2/accessToken" } baseURL := strings.TrimSpace(cfg.BaseURL) if baseURL == "" { baseURL = defaultBase } return &Client{ clientID: clientID, secret: secret, baseID: baseID, sheetID: sheetID, operatorID: operatorID, fieldMapping: cloneFieldMapping(cfg.FieldMapping), tokenURL: tokenURL, baseURL: baseURL, http: httpClient, }, nil } // TokenURL returns the configured token URL (test seam). func (c *Client) TokenURL() string { return c.tokenURL } // BaseURL returns the configured API base (test seam). func (c *Client) BaseURL() string { return c.baseURL } // insertRecordReq is the JSON body for the Notable v1 insertRecord endpoint. type insertRecordReq struct { Records []insertRecord `json:"records"` } type insertRecord struct { Fields map[string]interface{} `json:"fields"` } // insertRecordResp is the success response body. type insertRecordResp struct { Value []struct { ID string `json:"id"` } `json:"value"` } // tokenResp is the access-token response body. type tokenResp struct { AccessToken string `json:"accessToken"` ExpireIn int64 `json:"expireIn"` } // InsertRecord sends a single question-table row to DingTalk Notable v1. // It remains the compatibility entry point for the existing question-table dispatcher. func (c *Client) InsertRecord(ctx context.Context, row Row) (string, error) { return c.InsertFields(ctx, row.ToFields()) } // InsertFields sends one already-typed field map to DingTalk Notable v1 and // returns the record ID. It is shared by other reviewed Notable table schemas. func (c *Client) InsertFields(ctx context.Context, fields map[string]interface{}) (string, error) { fields = c.remapFields(fields) token, err := c.getAccessToken(ctx) if err != nil { return "", fmt.Errorf("questiontable token: %w", err) } path := fmt.Sprintf("/v1.0/notable/bases/%s/sheets/%s/records", url.PathEscape(c.baseID), url.PathEscape(c.sheetID)) reqURL := c.baseURL + path + "?operatorId=" + url.QueryEscape(c.operatorID) body := insertRecordReq{Records: []insertRecord{{Fields: fields}}} jsonBody, err := json.Marshal(body) if err != nil { return "", fmt.Errorf("questiontable marshal: %w", err) } req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqURL, bytes.NewReader(jsonBody)) if err != nil { return "", fmt.Errorf("questiontable request: %w", err) } req.Header.Set("Content-Type", "application/json") req.Header.Set("x-acs-dingtalk-access-token", token) resp, err := c.http.Do(req) if err != nil { return "", safeDoErr(ctx, err) } defer resp.Body.Close() // Read bounded response body. raw, err := io.ReadAll(io.LimitReader(resp.Body, 64<<10)) if err != nil { return "", fmt.Errorf("questiontable read response: %w", err) } if resp.StatusCode < 200 || resp.StatusCode >= 300 { return "", fmt.Errorf("questiontable insert returned HTTP %d", resp.StatusCode) } var ir insertRecordResp if err := json.Unmarshal(raw, &ir); err != nil { return "", fmt.Errorf("questiontable decode response: %w", err) } if len(ir.Value) == 0 { return "", errors.New("questiontable empty value list") } if strings.TrimSpace(ir.Value[0].ID) == "" { return "", errors.New("questiontable empty record id") } return ir.Value[0].ID, nil } func cloneFieldMapping(in map[string]string) map[string]string { out := make(map[string]string, len(in)) for key, value := range in { out[key] = value } return out } var providerFieldLogical = map[string]string{ "ZaMZF6j": "chinese_question", "SCug9My": "asked_time", "S2XA1uZ": "asker", "bETcL3r": "original_question", "Y4cpmxU": "answer", "JgY2f1z": "trigger_person", "DNIV3mQ": "language", "eBc6a6b": "department", "fPNLeVW": "region", "01ZM8y7": "standard_question", "fj3JQ1C": "original_question", "07YYagS": "language", "Eu7gkKu": "asker", } func (c *Client) remapFields(in map[string]interface{}) map[string]interface{} { if len(c.fieldMapping) == 0 { return in } out := make(map[string]interface{}, len(in)) for providerID, value := range in { logical := providerFieldLogical[providerID] if mapped := c.fieldMapping[logical]; logical != "" && mapped != "" { out[mapped] = value } else { out[providerID] = value } } return out } // safeDoErr wraps an http.Do error without exposing the raw URL or credentials. // If the context is already done, returns a wrapped ctx.Err() so errors.Is works. func safeDoErr(ctx context.Context, err error) error { if ctx.Err() != nil { return fmt.Errorf("questiontable insert: %w", ctx.Err()) } return errors.New("questiontable insert: network error") } // getAccessToken returns a cached token or fetches a new one. func (c *Client) getAccessToken(ctx context.Context) (string, error) { c.mu.Lock() if c.token != "" && time.Now().Before(c.tokenExp) { tok := c.token c.mu.Unlock() return tok, nil } c.mu.Unlock() return c.fetchToken(ctx) } // fetchToken calls the DingTalk OAuth2 endpoint and caches the result. func (c *Client) fetchToken(ctx context.Context) (string, error) { c.mu.Lock() defer c.mu.Unlock() // Double-check inside lock. if c.token != "" && time.Now().Before(c.tokenExp) { return c.token, nil } body := map[string]string{ "appKey": c.clientID, "appSecret": c.secret, } jsonBody, err := json.Marshal(body) if err != nil { return "", fmt.Errorf("questiontable token marshal: %w", err) } req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.tokenURL, bytes.NewReader(jsonBody)) if err != nil { return "", fmt.Errorf("questiontable token request: %w", err) } req.Header.Set("Content-Type", "application/json") resp, err := c.http.Do(req) if err != nil { return "", safeTokenDoErr(ctx, err) } defer resp.Body.Close() raw, err := io.ReadAll(io.LimitReader(resp.Body, 64<<10)) if err != nil { return "", fmt.Errorf("questiontable token read: %w", err) } if resp.StatusCode < 200 || resp.StatusCode >= 300 { return "", fmt.Errorf("questiontable token returned HTTP %d", resp.StatusCode) } var tr tokenResp if err := json.Unmarshal(raw, &tr); err != nil { return "", fmt.Errorf("questiontable token decode: %w", err) } if strings.TrimSpace(tr.AccessToken) == "" { return "", errors.New("questiontable empty access token") } // Token expiry must never be extended beyond DingTalk's expireIn. if tr.ExpireIn <= 0 { return "", errors.New("questiontable token: non-positive expireIn") } exp := time.Duration(tr.ExpireIn) * time.Second // For very short TTL (<=30s), cache for a positive fraction (TTL/2). if exp <= 30*time.Second { exp = exp / 2 } else { // Safety margin: subtract 30 seconds from expiry. exp -= 30 * time.Second } c.token = tr.AccessToken c.tokenExp = time.Now().Add(exp) return c.token, nil } // safeTokenDoErr wraps an http.Do error from token fetch without exposing raw URL or credentials. func safeTokenDoErr(ctx context.Context, err error) error { if ctx.Err() != nil { return fmt.Errorf("questiontable token: %w", ctx.Err()) } return errors.New("questiontable token: network error") }