FranklinWH-Toolbox/service/repositories/api/fwh_pro/fwhHttpClient.go

package fwh_pro

import (
	"context"
	"encoding/json"
	"fwh-toolbox-server/config"
	"fwh-toolbox-server/domain"
	"fwh-toolbox-server/utils/httpClient"
	"net/http"
	"net/url"
	"time"
)

const (
	timeout time.Duration = 3 * time.Minute // fwh请求超时3min
)

var (
	fwhEnergy     string
	fwhOss        string
	fwhUser       string
	fwhPassword   string
	fwhHttpClient httpClient.HttpClient
)

// FwhHttpInit
func FwhHttpInit(cfg *config.FwhApiConfig) {
	fwhEnergy = cfg.FwhEnergy
	fwhOss = cfg.FwhOss
	fwhUser = cfg.FwhUser
	fwhPassword = cfg.FwhPassword

	fwhHttpClient = httpClient.HttpClient{}
	fwhHttpClient.RegisterLogin(reLogin)
}

// 获取完整EnergyURL
func getFullEnergyUrl(relativeURL string) string {
	return "https://" + fwhEnergy + relativeURL
}

// 获取完整OssURL
func getFullOssUrl(relativeURL string) string {
	// return "https://" + fwhOss + relativeURL
	return "https://" + fwhEnergy + relativeURL
}

// 仅用户登录或者不需要token的请求
func FwhHttpGetWithoutToken(url string, params url.Values) (*httpClient.Response, error) {
	t := timeout / time.Second
	opt := httpClient.HttpClientOptions{
		Timeout: &t,
		Header: &http.Header{
			"Accept": {"application/json", "text/plain", "*/*"},
		},
	}
	return fwhHttpClient.HttpGet(url, &params, &opt)
}

func FwhHttpGet(url string, params url.Values) (*httpClient.Response, error) {
	t := timeout / time.Second
	opt := httpClient.HttpClientOptions{
		Timeout: &t,
		Header: &http.Header{
			"Logintoken": {getLoginToken()},
			"Accept":     {"application/json", "text/plain", "*/*"},
		},
	}
	return fwhHttpClient.HttpGet(url, &params, &opt)
}

func FwhHttpGetContext(ctx context.Context, url string, params url.Values) (*httpClient.Response, error) {
	t := timeout / time.Second
	opt := httpClient.HttpClientOptions{
		Timeout: &t,
		Context: ctx,
		Header: &http.Header{
			"Logintoken": {getLoginToken()},
			"Accept":     {"application/json", "text/plain", "*/*"},
		},
	}
	return fwhHttpClient.HttpGet(url, &params, &opt)
}

// 仅用户登录或者不需要token的请求
func FwhHttpPostWithoutToken(url string, body any) (*httpClient.Response, error) {
	t := timeout / time.Second
	opt := httpClient.HttpClientOptions{
		Timeout: &t,
		Header: &http.Header{
			"Accept": {"application/json", "text/plain", "*/*"},
		},
	}
	return fwhHttpClient.HttpPost(url, body, &opt)
}

func FwhHttpPost(url string, body any) (*httpClient.Response, error) {
	t := timeout / time.Second
	opt := httpClient.HttpClientOptions{
		Timeout: &t,
		Header: &http.Header{
			"Logintoken": {getLoginToken()},
			"Accept":     {"application/json", "text/plain", "*/*"},
		},
	}
	return fwhHttpClient.HttpPost(url, body, &opt)
}

func FwhHttpPostContext(ctx context.Context, url string, body any) (*httpClient.Response, error) {
	t := timeout / time.Second
	opt := httpClient.HttpClientOptions{
		Timeout: &t,
		Context: ctx,
		Header: &http.Header{
			"Logintoken": {getLoginToken()},
			"Accept":     {"application/json", "text/plain", "*/*"},
		},
	}
	return fwhHttpClient.HttpPost(url, body, &opt)
}

func FwhHttpGetUnmarshalContext[T any](ctx context.Context, url string, params url.Values) (*domain.FwhResponse[T], error) {
	for attempt := 0; attempt < 2; attempt++ {
		res, err := FwhHttpGetContext(ctx, url, params)
		if err != nil {
			return nil, err
		}
		var data domain.FwhResponse[T]
		if err := json.Unmarshal(res.Body, &data); err != nil {
			return nil, err
		}
		if data.Code != 401 || attempt == 1 {
			return &data, nil
		}
		reLogin()
	}
	return nil, ctx.Err()
}

func FwhHttpPostUnmarshalContext[T any](ctx context.Context, url string, body any) (*domain.FwhResponse[T], error) {
	for attempt := 0; attempt < 2; attempt++ {
		res, err := FwhHttpPostContext(ctx, url, body)
		if err != nil {
			return nil, err
		}
		var data domain.FwhResponse[T]
		if err := json.Unmarshal(res.Body, &data); err != nil {
			return nil, err
		}
		if data.Code != 401 || attempt == 1 {
			return &data, nil
		}
		reLogin()
	}
	return nil, ctx.Err()
}

/************ 实现标准结构体解析 ************/

func FwhHttpGetUnmarshal[T any](url string, params url.Values) (*domain.FwhResponse[T], error) {
	res, err := FwhHttpGet(url, params)
	if err != nil {
		return nil, err
	}

	var data domain.FwhResponse[T]
	// 反序列化（unmarshal）
	jsonErr := json.Unmarshal(res.Body, &data)
	if jsonErr != nil {
		return nil, jsonErr
	}

	if data.Code == 401 {
		// invalid token
		reLogin() // 重新登录

		// 重新请求
		res, err := FwhHttpGet(url, params)
		if err != nil {
			return nil, err
		}

		// 反序列化（unmarshal）
		jsonErr := json.Unmarshal(res.Body, &data)
		if jsonErr != nil {
			return nil, jsonErr
		}
	}

	return &data, nil
}

func FwhHttpGetUnmarshalPage[T any](url string, params url.Values) (*domain.FwhPageResponse[T], error) {
	res, err := FwhHttpGet(url, params)
	if err != nil {
		return nil, err
	}

	var data domain.FwhPageResponse[T]
	// 反序列化（unmarshal）
	jsonErr := json.Unmarshal(res.Body, &data)
	if jsonErr != nil {
		return nil, jsonErr
	}

	if data.Code == 401 {
		// invalid token
		reLogin() // 重新登录

		// 重新请求
		res, err := FwhHttpGet(url, params)
		if err != nil {
			return nil, err
		}

		// 反序列化（unmarshal）
		jsonErr := json.Unmarshal(res.Body, &data)
		if jsonErr != nil {
			return nil, jsonErr
		}
	}

	return &data, nil
}

func FwhHttpGetUnmarshalA[T any](url string, params url.Values) (*domain.FwhResponseA[T], error) {
	res, err := FwhHttpGet(url, params)
	if err != nil {
		return nil, err
	}

	var data domain.FwhResponseA[T]
	// 反序列化（unmarshal）
	jsonErr := json.Unmarshal(res.Body, &data)
	if jsonErr != nil {
		return nil, jsonErr
	}

	if data.Code == 401 {
		// invalid token
		reLogin() // 重新登录

		// 重新请求
		res, err := FwhHttpGet(url, params)
		if err != nil {
			return nil, err
		}

		// 反序列化（unmarshal）
		jsonErr := json.Unmarshal(res.Body, &data)
		if jsonErr != nil {
			return nil, jsonErr
		}
	}

	return &data, nil
}

func FwhHttpGetUnmarshalB[T any](url string, params url.Values) (*domain.FwhResponseB[T], error) {
	res, err := FwhHttpGet(url, params)
	if err != nil {
		return nil, err
	}

	var data domain.FwhResponseB[T]
	// 反序列化（unmarshal）
	jsonErr := json.Unmarshal(res.Body, &data)
	if jsonErr != nil {
		return nil, jsonErr
	}

	if data.Code == 401 {
		// invalid token
		reLogin() // 重新登录

		// 重新请求
		res, err := FwhHttpGet(url, params)
		if err != nil {
			return nil, err
		}

		// 反序列化（unmarshal）
		jsonErr := json.Unmarshal(res.Body, &data)
		if jsonErr != nil {
			return nil, jsonErr
		}
	}

	return &data, nil
}

func FwhHttpPostUnmarshal[T any](url string, body any) (*domain.FwhResponse[T], error) {

	res, err := FwhHttpPost(url, body)
	if err != nil {
		return nil, err
	}

	var data domain.FwhResponse[T]
	// 反序列化（unmarshal）
	jsonErr := json.Unmarshal(res.Body, &data)
	if jsonErr != nil {
		return nil, jsonErr
	}

	if data.Code == 401 {
		// invalid token
		reLogin() // 重新登录

		// 重新请求
		res, err := FwhHttpPost(url, body)
		if err != nil {
			return nil, err
		}

		// 反序列化（unmarshal）
		jsonErr := json.Unmarshal(res.Body, &data)
		if jsonErr != nil {
			return nil, jsonErr
		}
	}

	return &data, nil
}

func FwhHttpPostUnmarshalPage[T any](url string, body any) (*domain.FwhPageResponse[T], error) {
	res, err := FwhHttpPost(url, body)
	if err != nil {
		return nil, err
	}

	var data domain.FwhPageResponse[T]
	// 反序列化（unmarshal）
	jsonErr := json.Unmarshal(res.Body, &data)
	if jsonErr != nil {
		return nil, jsonErr
	}

	if data.Code == 401 {
		// invalid token
		reLogin() // 重新登录

		// 重新请求
		res, err := FwhHttpPost(url, body)
		if err != nil {
			return nil, err
		}

		// 反序列化（unmarshal）
		jsonErr := json.Unmarshal(res.Body, &data)
		if jsonErr != nil {
			return nil, jsonErr
		}
	}

	return &data, nil
}