- service：优化

- utils：优化

go.mod

@@ -22,7 +22,6 @@ require (
 	go.dtapp.net/gojson v1.0.0
 	go.dtapp.net/golog v1.0.13
 	go.dtapp.net/gomongo v1.0.8
-	go.dtapp.net/gorequest v1.0.19
 	go.mongodb.org/mongo-driver v1.9.1
 	go.uber.org/zap v1.21.0
 	golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e

go.sum

@@ -267,8 +267,8 @@ go.dtapp.net/golog v1.0.13 h1:SnU6G4onDYZPOfZ9cgmj5rHdtGGOWP/Qee31aM49Wj0=
 go.dtapp.net/golog v1.0.13/go.mod h1:6w5Lt1x6/yUN3iptAi59irm4kqDJHaolDsrZ9ApsZUQ=
 go.dtapp.net/gomongo v1.0.8 h1:tuWHIpCVGIw/JFspczwOZRyeOEyl4zOcauZO6tgKbes=
 go.dtapp.net/gomongo v1.0.8/go.mod h1:QlYy1xEY48BBxwuRVV3TAzMn+OwgKp8NXWIF5Z4X70k=
-go.dtapp.net/gorequest v1.0.19 h1:ZBkXb/oD59aChfzHfReK6M3M4eu3dwpaPTefe1c8P90=
-go.dtapp.net/gorequest v1.0.19/go.mod h1:EwOfdfxsWPszOWrphCWHTN4DbYtU6fyQ/fuWQyQwSnk=
+go.dtapp.net/library/utils/gorequest v1.0.19 h1:ZBkXb/oD59aChfzHfReK6M3M4eu3dwpaPTefe1c8P90=
+go.dtapp.net/library/utils/gorequest v1.0.19/go.mod h1:EwOfdfxsWPszOWrphCWHTN4DbYtU6fyQ/fuWQyQwSnk=
 go.dtapp.net/gostring v1.0.3 h1:KSOq4D77/g5yZN/bqWfZ0kOOaPr/P1240vg03+XdENI=
 go.dtapp.net/gostring v1.0.3/go.mod h1:+ggrOvgQDQturi1QGsXEpyRN/ZPoRDaqhMujIk5lrgQ=
 go.dtapp.net/gotime v1.0.2 h1:CFIJHQXC/4t9bsJhk2cLhjHd6rpdPcJXr8BcHKHDuQo=

service/cloudflare/client.go

@@ -0,0 +1,7 @@
+package cloudflare
+
+type Client struct {
+	AccountID    string
+	ZoneID       string
+	GlobalAPIKey string
+}

service/cloudflare/const.go

@@ -0,0 +1,5 @@
+package cloudflare
+
+const (
+	URL = "https://api.cloudflare.com/client/v4/"
+)

service/dingdanxia/app.go

@@ -1,34 +1,72 @@
 package dingdanxia
 
 import (
-	"errors"
-	"go.dtapp.net/library/utils/gohttp"
+	"go.dtapp.net/golog"
 	"go.dtapp.net/library/utils/gomongo"
-	"net/http"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
 )
 
 type App struct {
-	ApiKey string
-	Mongo  gomongo.App // 日志数据库
+	apiKey       string          // 密钥
+	mongo        *gomongo.Client // 日志数据库
+	pgsql        *gorm.DB        // pgsql数据库
+	client       *gorequest.App  // 请求客户端
+	log          *golog.Api      // 日志服务
+	logTableName string          // 日志表名
+	logStatus    bool            // 日志状态
 }
 
-func (app *App) request(url string, params map[string]interface{}, method string) (resp gohttp.Response, err error) {
+// NewApp 创建实例
+func NewApp(apiKey string, pgsql *gorm.DB) *App {
+	app := &App{apiKey: apiKey}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "dingdanxia"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
+	}
+	return app
+}
+
+// 请求接口
+func (app *App) request(url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
+
 	// 公共参数
-	params["apikey"] = app.ApiKey
-	switch method {
-	case http.MethodGet:
-		// 请求
-		get, err := gohttp.Get(url, params)
-		// 日志
-		go app.mongoLog(url, params, method, get)
-		return get, err
-	case http.MethodPost:
-		// 请求
-		postJson, err := gohttp.PostForm(url, params)
-		// 日志
-		go app.mongoLog(url, params, method, postJson)
-		return postJson, err
-	default:
-		return resp, errors.New("请求类型不支持")
+	params["apikey"] = app.apiKey
+
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置方式
+	client.SetMethod(method)
+
+	// 设置格式
+	client.SetContentTypeForm()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Request()
+	if err != nil {
+		return gorequest.Response{}, err
 	}
+
+	// 日志
+	if app.mongo != nil && app.mongo.Db != nil {
+		go app.mongoLog(request)
+	}
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
 }

service/dingdanxia/jd.jy_order_details.go

@@ -2,7 +2,7 @@ package dingdanxia
 
 import (
 	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -30,11 +30,11 @@ type JdJyOrderDetailsResponse struct {
 type JdJyOrderDetailsResult struct {
 	Result JdJyOrderDetailsResponse // 结果
 	Body   []byte                   // 内容
-	Http   gohttp.Response          // 请求
+	Http   gorequest.Response       // 请求
 	Err    error                    // 错误
 }
 
-func NewJdJyOrderDetailsResult(result JdJyOrderDetailsResponse, body []byte, http gohttp.Response, err error) *JdJyOrderDetailsResult {
+func NewJdJyOrderDetailsResult(result JdJyOrderDetailsResponse, body []byte, http gorequest.Response, err error) *JdJyOrderDetailsResult {
 	return &JdJyOrderDetailsResult{Result: result, Body: body, Http: http, Err: err}
 }
 
@@ -46,6 +46,6 @@ func (app *App) JdJyOrderDetails(notMustParams ...Params) *JdJyOrderDetailsResul
 	request, err := app.request("https://api.tbk.dingdanxia.com/jd/jy_order_details", params, http.MethodPost)
 	// 定义
 	var response JdJyOrderDetailsResponse
-	err = json.Unmarshal(request.Body, &response)
-	return NewJdJyOrderDetailsResult(response, request.Body, request, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewJdJyOrderDetailsResult(response, request.ResponseBody, request, err)
 }

service/dingdanxia/jd.order_details2.go

@@ -14,6 +14,6 @@ func (app *App) JdOrderDetails2(notMustParams ...Params) *JdJyOrderDetailsResult
 	request, err := app.request("https://api.tbk.dingdanxia.com/jd/order_details2", params, http.MethodPost)
 	// 定义
 	var response JdJyOrderDetailsResponse
-	err = json.Unmarshal(request.Body, &response)
-	return NewJdJyOrderDetailsResult(response, request.Body, request, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewJdJyOrderDetailsResult(response, request.ResponseBody, request, err)
 }

service/dingdanxia/mongo.go

@@ -0,0 +1,48 @@
+package dingdanxia
+
+import (
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gorequest"
+	"net/http"
+)
+
+// 日志
+type mongoZap struct {
+	RequestTime           gomongo.BsonTime       `json:"request_time" bson:"request_time"`                       //【请求】时间
+	RequestUri            string                 `json:"request_uri" bson:"request_uri"`                         //【请求】链接
+	RequestUrl            string                 `json:"request_url" bson:"request_url"`                         //【请求】链接
+	RequestApi            string                 `json:"request_api" bson:"request_api"`                         //【请求】接口
+	RequestMethod         string                 `json:"request_method" bson:"request_method"`                   //【请求】方式
+	RequestParams         gorequest.Params       `json:"request_params" bson:"request_params"`                   //【请求】参数
+	RequestHeader         gorequest.Headers      `json:"request_header" bson:"request_header"`                   //【请求】头部
+	ResponseHeader        http.Header            `json:"response_header" bson:"response_header"`                 //【返回】头部
+	ResponseStatusCode    int                    `json:"response_status_code" bson:"response_status_code"`       //【返回】状态码
+	ResponseBody          map[string]interface{} `json:"response_body" bson:"response_body"`                     //【返回】内容
+	ResponseContentLength int64                  `json:"response_content_length" bson:"response_content_length"` //【返回】大小
+	ResponseTime          gomongo.BsonTime       `json:"response_time" bson:"response_time"`                     //【返回】时间
+}
+
+func (m *mongoZap) Database() string {
+	return "zap_log"
+}
+
+func (m *mongoZap) TableName() string {
+	return "dingdanxia"
+}
+
+func (app *App) mongoLog(request gorequest.Response) {
+	_, _ = app.mongo.Model(&mongoZap{}).InsertOne(mongoZap{
+		RequestTime:           gomongo.BsonTime(request.RequestTime),           //【请求】时间
+		RequestUri:            request.RequestUri,                              //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,      //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,     //【请求】接口
+		RequestMethod:         request.RequestMethod,                           //【请求】方式
+		RequestParams:         request.RequestParams,                           //【请求】参数
+		RequestHeader:         request.RequestHeader,                           //【请求】头部
+		ResponseHeader:        request.ResponseHeader,                          //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                      //【返回】状态码
+		ResponseBody:          gomongo.JsonDecodeNoError(request.ResponseBody), //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                   //【返回】大小
+		ResponseTime:          gomongo.BsonTime(request.ResponseTime),          //【返回】时间
+	})
+}

service/dingdanxia/mongodb.go

@@ -1,47 +0,0 @@
-package dingdanxia
-
-import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "dingdanxia_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	var body map[string]interface{}
-	_ = json.Unmarshal(request.Body, &body)
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          body,
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}

service/dingdanxia/pgsql.go

@@ -0,0 +1,26 @@
+package dingdanxia
+
+import (
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gojson"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
+	})
+}

service/dingdanxia/waimai.meituan_orderid.go

@@ -2,11 +2,11 @@ package dingdanxia
 
 import (
 	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
-type WaimaiMeituanOrderidResponse struct {
+type WaiMaiMeituanOrderIdResponse struct {
 	Code int    `json:"code"`
 	Msg  string `json:"msg"`
 	Data struct {
@@ -36,28 +36,28 @@ type WaimaiMeituanOrderidResponse struct {
 	} `json:"data"`
 }
 
-type WaimaiMeituanOrderidResult struct {
-	Result WaimaiMeituanOrderidResponse // 结果
+type WaiMaiMeituanOrderIdResult struct {
+	Result WaiMaiMeituanOrderIdResponse // 结果
 	Body   []byte                       // 内容
-	Http   gohttp.Response              // 请求
+	Http   gorequest.Response           // 请求
 	Err    error                        // 错误
 }
 
-func NewWaimaiMeituanOrderidResult(result WaimaiMeituanOrderidResponse, body []byte, http gohttp.Response, err error) *WaimaiMeituanOrderidResult {
-	return &WaimaiMeituanOrderidResult{Result: result, Body: body, Http: http, Err: err}
+func NewWaiMaiMeituanOrderIdResult(result WaiMaiMeituanOrderIdResponse, body []byte, http gorequest.Response, err error) *WaiMaiMeituanOrderIdResult {
+	return &WaiMaiMeituanOrderIdResult{Result: result, Body: body, Http: http, Err: err}
 }
 
-// WaimaiMeituanOrderid 美团联盟外卖/闪购/优选/酒店订单查询API（订单号版）
+// WaiMaiMeituanOrderId 美团联盟外卖/闪购/优选/酒店订单查询API（订单号版）
 // https://www.dingdanxia.com/doc/179/173
-func (app *App) WaimaiMeituanOrderid(orderid string) *WaimaiMeituanOrderidResult {
+func (app *App) WaiMaiMeituanOrderId(orderId string) *WaiMaiMeituanOrderIdResult {
 	// 参数
 	param := NewParams()
-	param.Set("orderid", orderid)
+	param.Set("order_id", orderId)
 	params := app.NewParamsWith(param)
 	// 请求
 	request, err := app.request("https://api.tbk.dingdanxia.com/waimai/meituan_orderid", params, http.MethodPost)
 	// 定义
-	var response WaimaiMeituanOrderidResponse
-	err = json.Unmarshal(request.Body, &response)
-	return NewWaimaiMeituanOrderidResult(response, request.Body, request, err)
+	var response WaiMaiMeituanOrderIdResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewWaiMaiMeituanOrderIdResult(response, request.ResponseBody, request, err)
 }

service/dingdanxia/waimai.meituan_orders.go

@@ -2,11 +2,11 @@ package dingdanxia
 
 import (
 	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
-type WaimaiMeituanOrdersResponse struct {
+type WaiMaiMeituanOrdersResponse struct {
 	Code         int    `json:"code"`
 	Msg          string `json:"msg"`           // 描述
 	TotalResults int    `json:"total_results"` // 总条数
@@ -27,26 +27,26 @@ type WaimaiMeituanOrdersResponse struct {
 	} `json:"data"`
 }
 
-type WaimaiMeituanOrdersResult struct {
-	Result WaimaiMeituanOrdersResponse // 结果
+type WaiMaiMeituanOrdersResult struct {
+	Result WaiMaiMeituanOrdersResponse // 结果
 	Body   []byte                      // 内容
-	Http   gohttp.Response             // 请求
+	Http   gorequest.Response          // 请求
 	Err    error                       // 错误
 }
 
-func NewWaimaiMeituanOrdersResult(result WaimaiMeituanOrdersResponse, body []byte, http gohttp.Response, err error) *WaimaiMeituanOrdersResult {
-	return &WaimaiMeituanOrdersResult{Result: result, Body: body, Http: http, Err: err}
+func NewWaiMaiMeituanOrdersResult(result WaiMaiMeituanOrdersResponse, body []byte, http gorequest.Response, err error) *WaiMaiMeituanOrdersResult {
+	return &WaiMaiMeituanOrdersResult{Result: result, Body: body, Http: http, Err: err}
 }
 
-// WaimaiMeituanOrders 美团联盟外卖/闪购/优选/酒店订单查询API
+// WaiMaiMeituanOrders 美团联盟外卖/闪购/优选/酒店订单查询API
 // https://www.dingdanxia.com/doc/176/173
-func (app *App) WaimaiMeituanOrders(notMustParams ...Params) *WaimaiMeituanOrdersResult {
+func (app *App) WaiMaiMeituanOrders(notMustParams ...Params) *WaiMaiMeituanOrdersResult {
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
 	request, err := app.request("https://api.tbk.dingdanxia.com/waimai/meituan_orders", params, http.MethodPost)
 	// 定义
-	var response WaimaiMeituanOrdersResponse
-	err = json.Unmarshal(request.Body, &response)
-	return NewWaimaiMeituanOrdersResult(response, request.Body, request, err)
+	var response WaiMaiMeituanOrdersResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewWaiMaiMeituanOrdersResult(response, request.ResponseBody, request, err)
 }

service/dingdanxia/waimai.meituan_privilege.go

@@ -2,11 +2,11 @@ package dingdanxia
 
 import (
 	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
-type WaimaiMeituanPrivilegeResponse struct {
+type WaiMaiMeituanPrivilegeResponse struct {
 	Code int    `json:"code"`
 	Msg  string `json:"msg"`
 	Data struct {
@@ -24,20 +24,20 @@ type WaimaiMeituanPrivilegeResponse struct {
 	} `json:"data"`
 }
 
-type WaimaiMeituanPrivilegeResult struct {
-	Result WaimaiMeituanPrivilegeResponse // 结果
+type WaiMaiMeituanPrivilegeResult struct {
+	Result WaiMaiMeituanPrivilegeResponse // 结果
 	Body   []byte                         // 内容
-	Http   gohttp.Response                // 请求
+	Http   gorequest.Response             // 请求
 	Err    error                          // 错误
 }
 
-func NewWaimaiMeituanPrivilegeResult(result WaimaiMeituanPrivilegeResponse, body []byte, http gohttp.Response, err error) *WaimaiMeituanPrivilegeResult {
-	return &WaimaiMeituanPrivilegeResult{Result: result, Body: body, Http: http, Err: err}
+func NewWaiMaiMeituanPrivilegeResult(result WaiMaiMeituanPrivilegeResponse, body []byte, http gorequest.Response, err error) *WaiMaiMeituanPrivilegeResult {
+	return &WaiMaiMeituanPrivilegeResult{Result: result, Body: body, Http: http, Err: err}
 }
 
-// WaimaiMeituanPrivilege 美团外卖CPS推广API接口
+// WaiMaiMeituanPrivilege 美团外卖CPS推广API接口
 // https://www.dingdanxia.com/doc/174/173
-func (app *App) WaimaiMeituanPrivilege(sid string, generateWeApp, qrcode bool) *WaimaiMeituanPrivilegeResult {
+func (app *App) WaiMaiMeituanPrivilege(sid string, generateWeApp, qrcode bool) *WaiMaiMeituanPrivilegeResult {
 	// 参数
 	param := NewParams()
 	param.Set("sid", sid)
@@ -47,7 +47,7 @@ func (app *App) WaimaiMeituanPrivilege(sid string, generateWeApp, qrcode bool) *
 	// 请求
 	request, err := app.request("https://api.tbk.dingdanxia.com/waimai/meituan_privilege", params, http.MethodPost)
 	// 定义
-	var response WaimaiMeituanPrivilegeResponse
-	err = json.Unmarshal(request.Body, &response)
-	return NewWaimaiMeituanPrivilegeResult(response, request.Body, request, err)
+	var response WaiMaiMeituanPrivilegeResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewWaiMaiMeituanPrivilegeResult(response, request.ResponseBody, request, err)
 }

service/dingdanxia/waimai.meituan_sg_privilege.go

@@ -2,11 +2,11 @@ package dingdanxia
 
 import (
 	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
-type WaimaiMeituanSgPrivilegeResponse struct {
+type WaiMaiMeituanSgPrivilegeResponse struct {
 	Code int    `json:"code"`
 	Msg  string `json:"msg"`
 	Data struct {
@@ -23,20 +23,20 @@ type WaimaiMeituanSgPrivilegeResponse struct {
 	} `json:"data"`
 }
 
-type WaimaiMeituanSgPrivilegeResult struct {
-	Result WaimaiMeituanSgPrivilegeResponse // 结果
+type WaiMaiMeituanSgPrivilegeResult struct {
+	Result WaiMaiMeituanSgPrivilegeResponse // 结果
 	Body   []byte                           // 内容
-	Http   gohttp.Response                  // 请求
+	Http   gorequest.Response               // 请求
 	Err    error                            // 错误
 }
 
-func NewWaimaiMeituanSgPrivilegeResult(result WaimaiMeituanSgPrivilegeResponse, body []byte, http gohttp.Response, err error) *WaimaiMeituanSgPrivilegeResult {
-	return &WaimaiMeituanSgPrivilegeResult{Result: result, Body: body, Http: http, Err: err}
+func NewWaiMaiMeituanSgPrivilegeResult(result WaiMaiMeituanSgPrivilegeResponse, body []byte, http gorequest.Response, err error) *WaiMaiMeituanSgPrivilegeResult {
+	return &WaiMaiMeituanSgPrivilegeResult{Result: result, Body: body, Http: http, Err: err}
 }
 
-// WaimaiMeituanSgPrivilege 美团闪购CPS推广API接口
+// WaiMaiMeituanSgPrivilege 美团闪购CPS推广API接口
 // https://www.dingdanxia.com/doc/195/173
-func (app *App) WaimaiMeituanSgPrivilege(sid string, generateWeApp, qrcode bool) *WaimaiMeituanSgPrivilegeResult {
+func (app *App) WaiMaiMeituanSgPrivilege(sid string, generateWeApp, qrcode bool) *WaiMaiMeituanSgPrivilegeResult {
 	// 参数
 	param := NewParams()
 	param.Set("sid", sid)
@@ -46,7 +46,7 @@ func (app *App) WaimaiMeituanSgPrivilege(sid string, generateWeApp, qrcode bool)
 	// 请求
 	request, err := app.request("https://api.tbk.dingdanxia.com/waimai/meituan_sg_privilege", params, http.MethodPost)
 	// 定义
-	var response WaimaiMeituanSgPrivilegeResponse
-	err = json.Unmarshal(request.Body, &response)
-	return NewWaimaiMeituanSgPrivilegeResult(response, request.Body, request, err)
+	var response WaiMaiMeituanSgPrivilegeResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewWaiMaiMeituanSgPrivilegeResult(response, request.ResponseBody, request, err)
 }

service/dingtalk/app.go

@@ -1,39 +1,63 @@
 package dingtalk
 
 import (
-	"encoding/json"
-	"errors"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gomongo"
-	"net/http"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
 )
 
 type App struct {
-	Secret      string
-	AccessToken string
-	Mongo       gomongo.App // 日志数据库
+	secret       string
+	accessToken  string
+	pgsql        *gorm.DB       // pgsql数据库
+	client       *gorequest.App // 请求客户端
+	log          *golog.Api     // 日志服务
+	logTableName string         // 日志表名
+	logStatus    bool           // 日志状态
 }
 
-func (app *App) request(url string, params map[string]interface{}, method string) ([]byte, error) {
-	switch method {
-	case http.MethodGet:
-		// 请求
-		get, err := gohttp.Get(url, params)
-		// 日志
-		go app.mongoLog(url, params, method, get)
-		return get.Body, err
-	case http.MethodPost:
-		// 请求参数
-		paramsMarshal, err := json.Marshal(params)
-		if err != nil {
-			return nil, err
-		}
-		// 请求
-		postJson, err := gohttp.PostJson(url, paramsMarshal)
-		// 日志
-		go app.mongoLog(url, params, method, postJson)
-		return postJson.Body, err
-	default:
-		return nil, errors.New("请求类型不支持")
+func NewApp(secret, accessToken string, pgsql *gorm.DB) *App {
+	app := &App{secret: secret, accessToken: accessToken}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "dingtalk"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
 	}
+	return app
+}
+
+func (app *App) request(url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
+
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置方式
+	client.SetMethod(method)
+
+	// 设置格式
+	client.SetContentTypeJson()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Request()
+	if err != nil {
+		return gorequest.Response{}, err
+	}
+
+	// 日志
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
 }

service/dingtalk/mongodb.go

@@ -1,47 +0,0 @@
-package dingtalk
-
-import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "dingtalk_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	var body map[string]interface{}
-	_ = json.Unmarshal(request.Body, &body)
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          body,
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}

service/dingtalk/pgsql.go

@@ -0,0 +1,26 @@
+package dingtalk
+
+import (
+	"go.dtapp.net/gojson"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
+	})
+}

service/dingtalk/robot.send.go

@@ -3,6 +3,7 @@ package dingtalk
 import (
 	"encoding/json"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 	"time"
 )
@@ -13,13 +14,14 @@ type RobotSendResponse struct {
 }
 
 type RobotSendResult struct {
-	Result RobotSendResponse // 结果
-	Body   []byte            // 内容
-	Err    error             // 错误
+	Result RobotSendResponse  // 结果
+	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
+	Err    error              // 错误
 }
 
-func NewRobotSendResult(result RobotSendResponse, body []byte, err error) *RobotSendResult {
-	return &RobotSendResult{Result: result, Body: body, Err: err}
+func NewRobotSendResult(result RobotSendResponse, body []byte, http gorequest.Response, err error) *RobotSendResult {
+	return &RobotSendResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // RobotSend 自定义机器人
@@ -30,9 +32,9 @@ func (app *App) RobotSend(notMustParams ...Params) *RobotSendResult {
 	// 时间
 	timestamp := time.Now().UnixNano() / 1e6
 	// 请求
-	body, err := app.request(fmt.Sprintf("https://oapi.dingtalk.com/robot/send?access_token=%s&timestamp=%d&sign=%s", app.AccessToken, timestamp, app.sign(timestamp)), params, http.MethodPost)
+	request, err := app.request(fmt.Sprintf("https://oapi.dingtalk.com/robot/send?access_token=%s&timestamp=%d&sign=%s", app.accessToken, timestamp, app.sign(timestamp)), params, http.MethodPost)
 	// 定义
 	var response RobotSendResponse
-	err = json.Unmarshal(body, &response)
-	return NewRobotSendResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewRobotSendResult(response, request.ResponseBody, request, err)
 }

service/dingtalk/sign.go

@@ -8,8 +8,8 @@ import (
 )
 
 func (app *App) sign(t int64) string {
-	secStr := fmt.Sprintf("%d\n%s", t, app.Secret)
-	hmac256 := hmac.New(sha256.New, []byte(app.Secret))
+	secStr := fmt.Sprintf("%d\n%s", t, app.secret)
+	hmac256 := hmac.New(sha256.New, []byte(app.secret))
 	hmac256.Write([]byte(secStr))
 	result := hmac256.Sum(nil)
 	return base64.StdEncoding.EncodeToString(result)

service/douyin/api.go

@@ -0,0 +1,218 @@
+package douyin
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/mvdan/xurls"
+	"go.dtapp.net/library/utils/gorequest"
+	"net/http"
+	"regexp"
+	"strings"
+)
+
+type AnalysisResponse struct {
+	StatusCode int `json:"status_code"`
+	ItemList   []struct {
+		AwemePoiInfo struct {
+			Tag  string `json:"tag"`
+			Icon struct {
+				UrlList []string `json:"url_list"`
+				Uri     string   `json:"uri"`
+			} `json:"icon"`
+			PoiName  string `json:"poi_name"`
+			TypeName string `json:"type_name"`
+		} `json:"aweme_poi_info"`
+		Images interface{} `json:"images"`
+		Author struct {
+			Geofencing       interface{} `json:"geofencing"`
+			CardEntries      interface{} `json:"card_entries"`
+			ShortId          string      `json:"short_id"`
+			Nickname         string      `json:"nickname"`
+			FollowStatus     int         `json:"follow_status"`
+			UniqueId         string      `json:"unique_id"`
+			PlatformSyncInfo interface{} `json:"platform_sync_info"`
+			Uid              string      `json:"uid"`
+			AvatarLarger     struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"avatar_larger"`
+			PolicyVersion interface{} `json:"policy_version"`
+			MixInfo       interface{} `json:"mix_info"`
+			Signature     string      `json:"signature"`
+			AvatarThumb   struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"avatar_thumb"`
+			AvatarMedium struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"avatar_medium"`
+			FollowersDetail interface{} `json:"followers_detail"`
+			TypeLabel       interface{} `json:"type_label"`
+		} `json:"author"`
+		ChaList []struct {
+			ViewCount      int    `json:"view_count"`
+			HashTagProfile string `json:"hash_tag_profile"`
+			Cid            string `json:"cid"`
+			CoverItem      struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"cover_item"`
+			UserCount    int         `json:"user_count"`
+			ConnectMusic interface{} `json:"connect_music"`
+			Type         int         `json:"type"`
+			IsCommerce   bool        `json:"is_commerce"`
+			ChaName      string      `json:"cha_name"`
+			Desc         string      `json:"desc"`
+		} `json:"cha_list"`
+		Duration     int         `json:"duration"`
+		LongVideo    interface{} `json:"long_video"`
+		Desc         string      `json:"desc"`
+		AuthorUserId int64       `json:"author_user_id"`
+		LabelTopText interface{} `json:"label_top_text"`
+		IsPreview    int         `json:"is_preview"`
+		CreateTime   int         `json:"create_time"`
+		ShareUrl     string      `json:"share_url"`
+		RiskInfos    struct {
+			Warn             bool   `json:"warn"`
+			Type             int    `json:"type"`
+			Content          string `json:"content"`
+			ReflowUnplayable int    `json:"reflow_unplayable"`
+		} `json:"risk_infos"`
+		Promotions interface{} `json:"promotions"`
+		Music      struct {
+			Duration int    `json:"duration"`
+			Id       int64  `json:"id"`
+			Mid      string `json:"mid"`
+			Title    string `json:"title"`
+			CoverHd  struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"cover_hd"`
+			CoverLarge struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"cover_large"`
+			CoverMedium struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"cover_medium"`
+			CoverThumb struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"cover_thumb"`
+			Author  string `json:"author"`
+			PlayUrl struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"play_url"`
+			Position interface{} `json:"position"`
+			Status   int         `json:"status"`
+		} `json:"music"`
+		CommentList interface{} `json:"comment_list"`
+		ForwardId   string      `json:"forward_id"`
+		GroupIdStr  string      `json:"group_id_str"`
+		Video       struct {
+			OriginCover struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"origin_cover"`
+			HasWatermark bool `json:"has_watermark"`
+			Duration     int  `json:"duration"`
+			Height       int  `json:"height"`
+			DynamicCover struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"dynamic_cover"`
+			Width    int         `json:"width"`
+			Ratio    string      `json:"ratio"`
+			BitRate  interface{} `json:"bit_rate"`
+			Vid      string      `json:"vid"`
+			PlayAddr struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"` // 真实去水印地址
+			} `json:"play_addr"`
+			Cover struct {
+				Uri     string   `json:"uri"`
+				UrlList []string `json:"url_list"`
+			} `json:"cover"`
+		} `json:"video"`
+		TextExtra []struct {
+			Start       int    `json:"start"`
+			End         int    `json:"end"`
+			Type        int    `json:"type"`
+			HashtagName string `json:"hashtag_name"`
+			HashtagId   int64  `json:"hashtag_id"`
+		} `json:"text_extra"`
+		VideoLabels interface{} `json:"video_labels"`
+		VideoText   interface{} `json:"video_text"`
+		AwemeType   int         `json:"aweme_type"`
+		ImageInfos  interface{} `json:"image_infos"`
+		AwemeId     string      `json:"aweme_id"`
+		Statistics  struct {
+			CommentCount int    `json:"comment_count"`
+			DiggCount    int    `json:"digg_count"`
+			PlayCount    int    `json:"play_count"`
+			ShareCount   int    `json:"share_count"`
+			AwemeId      string `json:"aweme_id"`
+		} `json:"statistics"`
+		IsLiveReplay bool `json:"is_live_replay"`
+		ShareInfo    struct {
+			ShareWeiboDesc string `json:"share_weibo_desc"`
+			ShareDesc      string `json:"share_desc"`
+			ShareTitle     string `json:"share_title"`
+		} `json:"share_info"`
+		Geofencing interface{} `json:"geofencing"`
+		GroupId    int64       `json:"group_id"`
+	} `json:"item_list"`
+	FilterList []interface{} `json:"filter_list"`
+	Extra      struct {
+		Now   int64  `json:"now"`
+		Logid string `json:"logid"`
+	} `json:"extra"`
+}
+
+type AnalysisResult struct {
+	Result AnalysisResponse   // 结果
+	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
+	Err    error              // 错误
+}
+
+func NewAnalysisResult(result AnalysisResponse, body []byte, http gorequest.Response, err error) *AnalysisResult {
+	return &AnalysisResult{Result: result, Body: body, Http: http, Err: err}
+}
+
+// Analysis 抖音解析
+func (app *App) Analysis(content string) *AnalysisResult {
+
+	// 提取url
+	var url string
+	if strings.Contains(content, "douyin.com") {
+		url = xurls.Relaxed.FindString(content)
+	} else if strings.Contains(content, "iesdouyin.com") {
+		url = xurls.Relaxed.FindString(content)
+	} else {
+		return NewAnalysisResult(AnalysisResponse{}, nil, gorequest.Response{}, errors.New("url为空"))
+	}
+
+	// 重定向信息
+	request302, err := app.request302(url)
+	if err != nil {
+		return NewAnalysisResult(AnalysisResponse{}, nil, gorequest.Response{}, err)
+	}
+
+	// 提取编号
+	itemIds := regexp.MustCompile(`\d+`).FindStringSubmatch(request302)
+	if len(itemIds) < 1 {
+		return NewAnalysisResult(AnalysisResponse{}, nil, gorequest.Response{}, errors.New("参数错误"))
+	}
+
+	// 请求
+	request, err := app.request("https://www.iesdouyin.com/web/api/v2/aweme/iteminfo/?item_ids="+itemIds[0], map[string]interface{}{}, http.MethodGet)
+
+	// 定义
+	var response AnalysisResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewAnalysisResult(response, request.ResponseBody, request, err)
+}

service/douyin/app.go

@@ -0,0 +1,98 @@
+package douyin
+
+import (
+	"errors"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
+	"net/http"
+	"strings"
+)
+
+type App struct {
+	ua           string         // 用户代理
+	pgsql        *gorm.DB       // pgsql数据库
+	client       *gorequest.App // 请求客户端
+	log          *golog.Api     // 日志服务
+	logTableName string         // 日志表名
+	logStatus    bool           // 日志状态
+}
+
+func NewApp(pgsql *gorm.DB) *App {
+	app := &App{ua: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1"}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "douyin"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
+	}
+	return app
+}
+
+func (app *App) request(url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
+
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置方式
+	client.SetMethod(method)
+
+	// 设置格式
+	client.SetContentTypeJson()
+
+	// 设置用户代理
+	client.SetUserAgent(app.ua)
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Request()
+	if err != nil {
+		return gorequest.Response{}, err
+	}
+
+	// 日志
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
+}
+
+func (app *App) request302(url string) (string, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", err
+	}
+	client := new(http.Client)
+	client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+		return errors.New("redirect")
+	}
+
+	response, err := client.Do(req)
+	if err != nil {
+		if response.StatusCode == http.StatusFound {
+			location, err := response.Location()
+			return location.String(), err
+		} else {
+			return "", err
+		}
+	}
+
+	return "", nil
+}
+
+func (app *App) urlJudge(str string) string {
+	if strings.Index(str, "douyin.com") != -1 || strings.Index(str, "iesdouyin.com") != -1 {
+		return str
+	}
+	return ""
+}

service/douyin/pgsql.go

@@ -0,0 +1,26 @@
+package douyin
+
+import (
+	"go.dtapp.net/gojson"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
+	})
+}

service/eastiot/Iot_api.query_ordered_pkgInfo.go

@@ -2,6 +2,7 @@ package eastiot
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -23,11 +24,12 @@ type IotApiQueryOrderedPkgInfoResponse struct {
 type IotApiQueryOrderedPkgInfoResult struct {
 	Result IotApiQueryOrderedPkgInfoResponse // 结果
 	Body   []byte                            // 内容
+	Http   gorequest.Response                // 请求
 	Err    error                             // 错误
 }
 
-func NewIotApiQueryOrderedPkgInfoResult(result IotApiQueryOrderedPkgInfoResponse, body []byte, err error) *IotApiQueryOrderedPkgInfoResult {
-	return &IotApiQueryOrderedPkgInfoResult{Result: result, Body: body, Err: err}
+func NewIotApiQueryOrderedPkgInfoResult(result IotApiQueryOrderedPkgInfoResponse, body []byte, http gorequest.Response, err error) *IotApiQueryOrderedPkgInfoResult {
+	return &IotApiQueryOrderedPkgInfoResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // IotApiQueryOrderedPkgInfo 查询流量卡已订购流量包
@@ -38,9 +40,9 @@ func (app *App) IotApiQueryOrderedPkgInfo(simId string) *IotApiQueryOrderedPkgIn
 	param.Set("simId", simId)
 	params := app.NewParamsWith(param)
 	// 请求
-	body, err := app.request("http://m2m.eastiot.net/Api/IotApi/queryOrderedPkgInfo", params, http.MethodPost)
+	request, err := app.request("http://m2m.eastiot.net/Api/IotApi/queryOrderedPkgInfo", params, http.MethodPost)
 	// 定义
 	var response IotApiQueryOrderedPkgInfoResponse
-	err = json.Unmarshal(body, &response)
-	return NewIotApiQueryOrderedPkgInfoResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewIotApiQueryOrderedPkgInfoResult(response, request.ResponseBody, request, err)
 }

service/eastiot/Iot_api.query_sim_pkgInfo.go

@@ -2,6 +2,7 @@ package eastiot
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -29,11 +30,12 @@ type IotApiQuerySimPkgInfoResponse struct {
 type IotApiQuerySimPkgInfoResult struct {
 	Result IotApiQuerySimPkgInfoResponse // 结果
 	Body   []byte                        // 内容
+	Http   gorequest.Response            // 请求
 	Err    error                         // 错误
 }
 
-func NewIotApiQuerySimPkgInfoResult(result IotApiQuerySimPkgInfoResponse, body []byte, err error) *IotApiQuerySimPkgInfoResult {
-	return &IotApiQuerySimPkgInfoResult{Result: result, Body: body, Err: err}
+func NewIotApiQuerySimPkgInfoResult(result IotApiQuerySimPkgInfoResponse, body []byte, http gorequest.Response, err error) *IotApiQuerySimPkgInfoResult {
+	return &IotApiQuerySimPkgInfoResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // IotApiQuerySimPkgInfo 流量卡可用流量包查询
@@ -45,9 +47,9 @@ func (app *App) IotApiQuerySimPkgInfo(simId string, sd int) *IotApiQuerySimPkgIn
 	param.Set("sd", sd)
 	params := app.NewParamsWith(param)
 	// 请求
-	body, err := app.request("http://m2m.eastiot.net/Api/IotApi/querySimPkgInfo", params, http.MethodPost)
+	request, err := app.request("http://m2m.eastiot.net/Api/IotApi/querySimPkgInfo", params, http.MethodPost)
 	// 定义
 	var response IotApiQuerySimPkgInfoResponse
-	err = json.Unmarshal(body, &response)
-	return NewIotApiQuerySimPkgInfoResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewIotApiQuerySimPkgInfoResult(response, request.ResponseBody, request, err)
 }

service/eastiot/Iot_api.query_user_pkgInfo.go

@@ -2,6 +2,7 @@ package eastiot
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -28,20 +29,21 @@ type IotApiQueryUserPkgInfoResponse struct {
 type IotApiQueryUserPkgInfoResult struct {
 	Result IotApiQueryUserPkgInfoResponse // 结果
 	Body   []byte                         // 内容
+	Http   gorequest.Response             // 请求
 	Err    error                          // 错误
 }
 
-func NewIotApiQueryUserPkgInfoResult(result IotApiQueryUserPkgInfoResponse, body []byte, err error) *IotApiQueryUserPkgInfoResult {
-	return &IotApiQueryUserPkgInfoResult{Result: result, Body: body, Err: err}
+func NewIotApiQueryUserPkgInfoResult(result IotApiQueryUserPkgInfoResponse, body []byte, http gorequest.Response, err error) *IotApiQueryUserPkgInfoResult {
+	return &IotApiQueryUserPkgInfoResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // IotApiQueryUserPkgInfo 账户可用流量包查询
 // https://www.showdoc.com.cn/916774523755909/4850094776758927
 func (app *App) IotApiQueryUserPkgInfo() *IotApiQueryUserPkgInfoResult {
 	// 请求
-	body, err := app.request("http://m2m.eastiot.net/Api/IotApi/queryUserPkgInfo", map[string]interface{}{}, http.MethodPost)
+	request, err := app.request("http://m2m.eastiot.net/Api/IotApi/queryUserPkgInfo", map[string]interface{}{}, http.MethodPost)
 	// 定义
 	var response IotApiQueryUserPkgInfoResponse
-	err = json.Unmarshal(body, &response)
-	return NewIotApiQueryUserPkgInfoResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewIotApiQueryUserPkgInfoResult(response, request.ResponseBody, request, err)
 }

service/eastiot/Iot_api.recharge_sim.go

@@ -2,6 +2,7 @@ package eastiot
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -13,11 +14,12 @@ type IotApiRechargeSimResponse struct {
 type IotApiRechargeSimResult struct {
 	Result IotApiRechargeSimResponse // 结果
 	Body   []byte                    // 内容
+	Http   gorequest.Response        // 请求
 	Err    error                     // 错误
 }
 
-func NewIotApiRechargeSimResult(result IotApiRechargeSimResponse, body []byte, err error) *IotApiRechargeSimResult {
-	return &IotApiRechargeSimResult{Result: result, Body: body, Err: err}
+func NewIotApiRechargeSimResult(result IotApiRechargeSimResponse, body []byte, http gorequest.Response, err error) *IotApiRechargeSimResult {
+	return &IotApiRechargeSimResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // IotApiRechargeSim 单卡流量充值
@@ -26,9 +28,9 @@ func (app *App) IotApiRechargeSim(notMustParams ...Params) *IotApiRechargeSimRes
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
-	body, err := app.request("http://m2m.eastiot.net/Api/IotApi/rechargeSim", params, http.MethodPost)
+	request, err := app.request("http://m2m.eastiot.net/Api/IotApi/rechargeSim", params, http.MethodPost)
 	// 定义
 	var response IotApiRechargeSimResponse
-	err = json.Unmarshal(body, &response)
-	return NewIotApiRechargeSimResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewIotApiRechargeSimResult(response, request.ResponseBody, request, err)
 }

service/eastiot/api.Iot_api.get_all_sim_type.go

@@ -2,6 +2,7 @@ package eastiot
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -18,20 +19,21 @@ type IotApiGetAllSimTypeResponse struct {
 type IotApiGetAllSimTypeResult struct {
 	Result IotApiGetAllSimTypeResponse // 结果
 	Body   []byte                      // 内容
+	Http   gorequest.Response          // 请求
 	Err    error                       // 错误
 }
 
-func NewIotApiGetAllSimTypeResult(result IotApiGetAllSimTypeResponse, body []byte, err error) *IotApiGetAllSimTypeResult {
-	return &IotApiGetAllSimTypeResult{Result: result, Body: body, Err: err}
+func NewIotApiGetAllSimTypeResult(result IotApiGetAllSimTypeResponse, body []byte, http gorequest.Response, err error) *IotApiGetAllSimTypeResult {
+	return &IotApiGetAllSimTypeResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // IotApiGetAllSimType 卡类型列表查询
 // https://www.showdoc.com.cn/916774523755909/4858492092033167
 func (app *App) IotApiGetAllSimType() *IotApiGetAllSimTypeResult {
 	// 请求
-	body, err := app.request("http://m2m.eastiot.net/Api/IotApi/getAllSimType", map[string]interface{}{}, http.MethodPost)
+	request, err := app.request("http://m2m.eastiot.net/Api/IotApi/getAllSimType", map[string]interface{}{}, http.MethodPost)
 	// 定义
 	var response IotApiGetAllSimTypeResponse
-	err = json.Unmarshal(body, &response)
-	return NewIotApiGetAllSimTypeResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewIotApiGetAllSimTypeResult(response, request.ResponseBody, request, err)
 }

service/eastiot/app.go

@@ -1,39 +1,76 @@
 package eastiot
 
 import (
-	"errors"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gomongo"
-	"net/http"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
 	"time"
 )
 
 type App struct {
-	AppID  string
-	ApiKey string
-	Mongo  gomongo.App // 日志数据库
+	appId        string
+	apiKey       string
+	mongo        *gomongo.Client // 日志数据库
+	pgsql        *gorm.DB        // pgsql数据库
+	client       *gorequest.App  // 请求客户端
+	log          *golog.Api      // 日志服务
+	logTableName string          // 日志表名
+	logStatus    bool            // 日志状态
 }
 
-func (app *App) request(url string, params map[string]interface{}, method string) ([]byte, error) {
+func NewApp(appID string, apiKey string, pgsql *gorm.DB) *App {
+	app := &App{appId: appID, apiKey: apiKey}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "eastiot"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
+	}
+	return app
+}
+
+func (app *App) request(url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
+
 	// 公共参数
-	params["appId"] = app.AppID
+	params["appId"] = app.appId
 	params["timeStamp"] = time.Now().Unix()
+
 	// 签名
-	params["sign"] = app.getSign(app.ApiKey, params)
-	switch method {
-	case http.MethodGet:
-		// 请求
-		get, err := gohttp.Get(url, params)
-		// 日志
-		go app.mongoLog(url, params, method, get)
-		return get.Body, err
-	case http.MethodPost:
-		// 请求
-		postJson, err := gohttp.PostForm(url, params)
-		// 日志
-		go app.mongoLog(url, params, method, postJson)
-		return postJson.Body, err
-	default:
-		return nil, errors.New("请求类型不支持")
+	params["sign"] = app.getSign(app.apiKey, params)
+
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置方式
+	client.SetMethod(method)
+
+	// 设置格式
+	client.SetContentTypeForm()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Request()
+	if err != nil {
+		return gorequest.Response{}, err
 	}
+
+	// 日志
+	if app.mongo != nil && app.mongo.Db != nil {
+		go app.mongoLog(request)
+	}
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
 }

service/eastiot/lot_api.query_user_balance.go

@@ -2,6 +2,7 @@ package eastiot
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -16,20 +17,21 @@ type IotApiQueryUserBalanceResponse struct {
 type IotApiQueryUserBalanceResult struct {
 	Result IotApiQueryUserBalanceResponse // 结果
 	Body   []byte                         // 内容
+	Http   gorequest.Response             // 请求
 	Err    error                          // 错误
 }
 
-func NewIotApiQueryUserBalanceResult(result IotApiQueryUserBalanceResponse, body []byte, err error) *IotApiQueryUserBalanceResult {
-	return &IotApiQueryUserBalanceResult{Result: result, Body: body, Err: err}
+func NewIotApiQueryUserBalanceResult(result IotApiQueryUserBalanceResponse, body []byte, http gorequest.Response, err error) *IotApiQueryUserBalanceResult {
+	return &IotApiQueryUserBalanceResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // IotApiQueryUserBalance 余额查询
 // https://www.showdoc.com.cn/916774523755909/4857910459512420
 func (app *App) IotApiQueryUserBalance() *IotApiQueryUserBalanceResult {
 	// 请求
-	body, err := app.request("http://m2m.eastiot.net/Api/IotApi/queryUserBalance", map[string]interface{}{}, http.MethodPost)
+	request, err := app.request("http://m2m.eastiot.net/Api/IotApi/queryUserBalance", map[string]interface{}{}, http.MethodPost)
 	// 定义
 	var response IotApiQueryUserBalanceResponse
-	err = json.Unmarshal(body, &response)
-	return NewIotApiQueryUserBalanceResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewIotApiQueryUserBalanceResult(response, request.ResponseBody, request, err)
 }

service/eastiot/mongo.go

@@ -0,0 +1,48 @@
+package eastiot
+
+import (
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gorequest"
+	"net/http"
+)
+
+// 日志
+type mongoZap struct {
+	RequestTime           gomongo.BsonTime       `json:"request_time" bson:"request_time"`                       //【请求】时间
+	RequestUri            string                 `json:"request_uri" bson:"request_uri"`                         //【请求】链接
+	RequestUrl            string                 `json:"request_url" bson:"request_url"`                         //【请求】链接
+	RequestApi            string                 `json:"request_api" bson:"request_api"`                         //【请求】接口
+	RequestMethod         string                 `json:"request_method" bson:"request_method"`                   //【请求】方式
+	RequestParams         gorequest.Params       `json:"request_params" bson:"request_params"`                   //【请求】参数
+	RequestHeader         gorequest.Headers      `json:"request_header" bson:"request_header"`                   //【请求】头部
+	ResponseHeader        http.Header            `json:"response_header" bson:"response_header"`                 //【返回】头部
+	ResponseStatusCode    int                    `json:"response_status_code" bson:"response_status_code"`       //【返回】状态码
+	ResponseBody          map[string]interface{} `json:"response_body" bson:"response_body"`                     //【返回】内容
+	ResponseContentLength int64                  `json:"response_content_length" bson:"response_content_length"` //【返回】大小
+	ResponseTime          gomongo.BsonTime       `json:"response_time" bson:"response_time"`                     //【返回】时间
+}
+
+func (m *mongoZap) Database() string {
+	return "zap_log"
+}
+
+func (m *mongoZap) TableName() string {
+	return "eastiot"
+}
+
+func (app *App) mongoLog(request gorequest.Response) {
+	_, _ = app.mongo.Model(&mongoZap{}).InsertOne(mongoZap{
+		RequestTime:           gomongo.BsonTime(request.RequestTime),           //【请求】时间
+		RequestUri:            request.RequestUri,                              //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,      //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,     //【请求】接口
+		RequestMethod:         request.RequestMethod,                           //【请求】方式
+		RequestParams:         request.RequestParams,                           //【请求】参数
+		RequestHeader:         request.RequestHeader,                           //【请求】头部
+		ResponseHeader:        request.ResponseHeader,                          //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                      //【返回】状态码
+		ResponseBody:          gomongo.JsonDecodeNoError(request.ResponseBody), //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                   //【返回】大小
+		ResponseTime:          gomongo.BsonTime(request.ResponseTime),          //【返回】时间
+	})
+}

service/eastiot/mongodb.go

@@ -1,47 +0,0 @@
-package eastiot
-
-import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "eastiot_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	var body map[string]interface{}
-	_ = json.Unmarshal(request.Body, &body)
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          body,
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}

service/eastiot/pgsql.go

@@ -0,0 +1,26 @@
+package eastiot
+
+import (
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gojson"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
+	})
+}

service/ejiaofei/app.go

@@ -1,42 +1,79 @@
 package ejiaofei
 
 import (
-	"errors"
 	"fmt"
-	"go.dtapp.net/library/utils/gohttp"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/gomongo"
 	"go.dtapp.net/library/utils/gomd5"
-	"go.dtapp.net/library/utils/gomongo"
-	"net/http"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
 )
 
 type App struct {
-	UserID  string
-	Pwd     string
-	Key     string
-	signStr string
-	Mongo   gomongo.App // 日志数据库
+	userId       string
+	pwd          string
+	key          string
+	signStr      string
+	mongo        *gomongo.Client // 日志数据库
+	pgsql        *gorm.DB        // pgsql数据库
+	client       *gorequest.App  // 请求客户端
+	log          *golog.Api      // 日志服务
+	logTableName string          // 日志表名
+	logStatus    bool            // 日志状态
 }
 
-func (app *App) request(url string, params map[string]interface{}, method string) ([]byte, error) {
+func NewApp(userId string, pwd string, key string, pgsql *gorm.DB) *App {
+	app := &App{userId: userId, pwd: pwd, key: key}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "ejiaofei"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
+	}
+	return app
+}
+
+func (app *App) request(url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
+
 	// 公共参数
-	params["userid"] = app.UserID
-	params["pwd"] = app.Pwd
+	params["userid"] = app.userId
+	params["pwd"] = app.pwd
+
 	// 签名
-	params["userkey"] = gomd5.ToUpper(fmt.Sprintf("%s%s", app.signStr, app.Key))
-	switch method {
-	case http.MethodGet:
-		// 请求
-		get, err := gohttp.Get(url, params)
-		// 日志
-		go app.mongoLog(url, params, method, get)
-		return get.Body, err
-	case http.MethodPost:
-		// 请求
-		postJson, err := gohttp.PostForm(url, params)
-		// 日志
-		go app.mongoLog(url, params, method, postJson)
-		return postJson.Body, err
-	default:
-		return nil, errors.New("请求类型不支持")
+	params["userkey"] = gomd5.ToUpper(fmt.Sprintf("%s%s", app.signStr, app.key))
+
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置方式
+	client.SetMethod(method)
+
+	// 设置格式
+	client.SetContentTypeForm()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Request()
+	if err != nil {
+		return gorequest.Response{}, err
 	}
+
+	// 日志
+	if app.mongo != nil && app.mongo.Db != nil {
+		go app.mongoLog(request)
+	}
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
 }

service/ejiaofei/check_cost.go

@@ -3,6 +3,7 @@ package ejiaofei
 import (
 	"encoding/xml"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -16,27 +17,28 @@ type CheckCostResponse struct {
 }
 
 type CheckCostResult struct {
-	Result CheckCostResponse // 结果
-	Body   []byte            // 内容
-	Err    error             // 错误
+	Result CheckCostResponse  // 结果
+	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
+	Err    error              // 错误
 }
 
-func NewCheckCostResult(result CheckCostResponse, body []byte, err error) *CheckCostResult {
-	return &CheckCostResult{Result: result, Body: body, Err: err}
+func NewCheckCostResult(result CheckCostResponse, body []byte, http gorequest.Response, err error) *CheckCostResult {
+	return &CheckCostResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // CheckCost 会员订单成本价查询接口
-func (app *App) CheckCost(orderID string) *CheckCostResult {
+func (app *App) CheckCost(orderId string) *CheckCostResult {
 	// 参数
 	param := NewParams()
-	param.Set("orderid", orderID)
+	param.Set("orderid", orderId)
 	params := app.NewParamsWith(param)
 	// 签名
-	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%v", app.UserID, app.Pwd, orderID)
+	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%v", app.userId, app.pwd, orderId)
 	// 请求
-	body, err := app.request("http://api.ejiaofei.net:11140/checkCost.do", params, http.MethodGet)
+	request, err := app.request("http://api.ejiaofei.net:11140/checkCost.do", params, http.MethodGet)
 	// 定义
 	var response CheckCostResponse
-	err = xml.Unmarshal(body, &response)
-	return NewCheckCostResult(response, body, err)
+	err = xml.Unmarshal(request.ResponseBody, &response)
+	return NewCheckCostResult(response, request.ResponseBody, request, err)
 }

service/ejiaofei/chongzhi_jkorders.go

@@ -3,6 +3,7 @@ package ejiaofei
 import (
 	"encoding/xml"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -23,11 +24,12 @@ type ChOngZhiJkOrdersResponse struct {
 type ChOngZhiJkOrdersResult struct {
 	Result ChOngZhiJkOrdersResponse // 结果
 	Body   []byte                   // 内容
+	Http   gorequest.Response       // 请求
 	Err    error                    // 错误
 }
 
-func NewChOngZhiJkOrdersResult(result ChOngZhiJkOrdersResponse, body []byte, err error) *ChOngZhiJkOrdersResult {
-	return &ChOngZhiJkOrdersResult{Result: result, Body: body, Err: err}
+func NewChOngZhiJkOrdersResult(result ChOngZhiJkOrdersResponse, body []byte, http gorequest.Response, err error) *ChOngZhiJkOrdersResult {
+	return &ChOngZhiJkOrdersResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ChOngZhiJkOrders 话费充值接口
@@ -43,11 +45,11 @@ func (app *App) ChOngZhiJkOrders(orderID string, face int, account string) *ChOn
 	param.Set("amount", 1)
 	params := app.NewParamsWith(param)
 	// 签名
-	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%vface%vaccount%vamount1", app.UserID, app.Pwd, orderID, face, account)
+	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%vface%vaccount%vamount1", app.userId, app.pwd, orderID, face, account)
 	// 请求
-	body, err := app.request("http://api.ejiaofei.net:11140/chongzhi_jkorders.do", params, http.MethodGet)
+	request, err := app.request("http://api.ejiaofei.net:11140/chongzhi_jkorders.do", params, http.MethodGet)
 	// 定义
 	var response ChOngZhiJkOrdersResponse
-	err = xml.Unmarshal(body, &response)
-	return NewChOngZhiJkOrdersResult(response, body, err)
+	err = xml.Unmarshal(request.ResponseBody, &response)
+	return NewChOngZhiJkOrdersResult(response, request.ResponseBody, request, err)
 }

service/ejiaofei/gprs_chongzhi_advance.go

@@ -1,9 +1,9 @@
 package ejiaofei
 
 import (
-	"encoding/json"
 	"encoding/xml"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -37,24 +37,24 @@ type GprsChOngZhiAdvanceResponse struct {
 type GprsChOngZhiAdvanceResult struct {
 	Result GprsChOngZhiAdvanceResponse // 结果
 	Body   []byte                      // 内容
+	Http   gorequest.Response          // 请求
 	Err    error                       // 错误
 }
 
-func NewGprsChOngZhiAdvanceResult(result GprsChOngZhiAdvanceResponse, body []byte, err error) *GprsChOngZhiAdvanceResult {
-	return &GprsChOngZhiAdvanceResult{Result: result, Body: body, Err: err}
+func NewGprsChOngZhiAdvanceResult(result GprsChOngZhiAdvanceResponse, body []byte, http gorequest.Response, err error) *GprsChOngZhiAdvanceResult {
+	return &GprsChOngZhiAdvanceResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // GprsChOngZhiAdvance 流量充值接口
-func (app *App) GprsChOngZhiAdvance(param GprsChOngZhiAdvanceParams) *GprsChOngZhiAdvanceResult {
+func (app *App) GprsChOngZhiAdvance(notMustParams ...Params) *GprsChOngZhiAdvanceResult {
+	// 参数
+	params := app.NewParamsWith(notMustParams...)
 	// 签名
-	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%vaccount%vgprs%varea%veffecttime%vvalidity%vtimes%v", app.UserID, app.Pwd, param.OrderID, param.Account, param.Gprs, param.Area, param.EffectTime, param.Validity, param.Times)
+	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%vaccount%vgprs%varea%veffecttime%vvalidity%vtimes%v", app.userId, app.pwd, params["orderid"], params["account"], params["gprs"], params["area"], params["effecttime"], params["validity"], params["times"])
 	// 请求
-	b, _ := json.Marshal(&param)
-	var params map[string]interface{}
-	_ = json.Unmarshal(b, &params)
-	body, err := app.request("http://api.ejiaofei.net:11140/gprsChongzhiAdvance.do", params, http.MethodGet)
+	request, err := app.request("http://api.ejiaofei.net:11140/gprsChongzhiAdvance.do", params, http.MethodGet)
 	// 定义
 	var response GprsChOngZhiAdvanceResponse
-	err = xml.Unmarshal(body, &response)
-	return NewGprsChOngZhiAdvanceResult(response, body, err)
+	err = xml.Unmarshal(request.ResponseBody, &response)
+	return NewGprsChOngZhiAdvanceResult(response, request.ResponseBody, request, err)
 }

service/ejiaofei/money_jkuser.go

@@ -3,6 +3,7 @@ package ejiaofei
 import (
 	"encoding/xml"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -16,21 +17,22 @@ type MoneyJkUserResponse struct {
 type MoneyJkUserResult struct {
 	Result MoneyJkUserResponse // 结果
 	Body   []byte              // 内容
+	Http   gorequest.Response  // 请求
 	Err    error               // 错误
 }
 
-func NewMoneyJkUserResult(result MoneyJkUserResponse, body []byte, err error) *MoneyJkUserResult {
-	return &MoneyJkUserResult{Result: result, Body: body, Err: err}
+func NewMoneyJkUserResult(result MoneyJkUserResponse, body []byte, http gorequest.Response, err error) *MoneyJkUserResult {
+	return &MoneyJkUserResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // MoneyJkUser 用户余额查询
 func (app *App) MoneyJkUser() *MoneyJkUserResult {
 	// 签名
-	app.signStr = fmt.Sprintf("userid%vpwd%v", app.UserID, app.Pwd)
+	app.signStr = fmt.Sprintf("userid%vpwd%v", app.userId, app.pwd)
 	// 请求
-	body, err := app.request("http://api.ejiaofei.net:11140/money_jkuser.do", map[string]interface{}{}, http.MethodGet)
+	request, err := app.request("http://api.ejiaofei.net:11140/money_jkuser.do", map[string]interface{}{}, http.MethodGet)
 	// 定义
 	var response MoneyJkUserResponse
-	err = xml.Unmarshal(body, &response)
-	return NewMoneyJkUserResult(response, body, err)
+	err = xml.Unmarshal(request.ResponseBody, &response)
+	return NewMoneyJkUserResult(response, request.ResponseBody, request, err)
 }

service/ejiaofei/mongo.go

@@ -0,0 +1,50 @@
+package ejiaofei
+
+import (
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gorequest"
+	"net/http"
+)
+
+// 日志
+type mongoZap struct {
+	RequestTime           gomongo.BsonTime       `json:"request_time" bson:"request_time"`                       //【请求】时间
+	RequestUri            string                 `json:"request_uri" bson:"request_uri"`                         //【请求】链接
+	RequestUrl            string                 `json:"request_url" bson:"request_url"`                         //【请求】链接
+	RequestApi            string                 `json:"request_api" bson:"request_api"`                         //【请求】接口
+	RequestMethod         string                 `json:"request_method" bson:"request_method"`                   //【请求】方式
+	RequestParams         gorequest.Params       `json:"request_params" bson:"request_params"`                   //【请求】参数
+	RequestHeader         gorequest.Headers      `json:"request_header" bson:"request_header"`                   //【请求】头部
+	ResponseHeader        http.Header            `json:"response_header" bson:"response_header"`                 //【返回】头部
+	ResponseStatusCode    int                    `json:"response_status_code" bson:"response_status_code"`       //【返回】状态码
+	ResponseBody          map[string]interface{} `json:"response_body" bson:"response_body"`                     //【返回】内容
+	ResponseXml           string                 `json:"response_xml" bson:"response_xml"`                       //【返回】内容
+	ResponseContentLength int64                  `json:"response_content_length" bson:"response_content_length"` //【返回】大小
+	ResponseTime          gomongo.BsonTime       `json:"response_time" bson:"response_time"`                     //【返回】时间
+}
+
+func (m *mongoZap) Database() string {
+	return "zap_log"
+}
+
+func (m *mongoZap) TableName() string {
+	return "ejiaofei"
+}
+
+func (app *App) mongoLog(request gorequest.Response) {
+	_, _ = app.mongo.Model(&mongoZap{}).InsertOne(mongoZap{
+		RequestTime:           gomongo.BsonTime(request.RequestTime),          //【请求】时间
+		RequestUri:            request.RequestUri,                             //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,     //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,    //【请求】接口
+		RequestMethod:         request.RequestMethod,                          //【请求】方式
+		RequestParams:         request.RequestParams,                          //【请求】参数
+		RequestHeader:         request.RequestHeader,                          //【请求】头部
+		ResponseHeader:        request.ResponseHeader,                         //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                     //【返回】状态码
+		ResponseBody:          gomongo.XmlDecodeNoError(request.ResponseBody), //【返回】内容
+		ResponseXml:           string(request.ResponseBody),                   //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                  //【返回】大小
+		ResponseTime:          gomongo.BsonTime(request.ResponseTime),         //【返回】时间
+	})
+}

service/ejiaofei/mongodb.go

@@ -1,44 +0,0 @@
-package ejiaofei
-
-import (
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "ejiaofei_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          string(request.Body),
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}

service/ejiaofei/pgsql.go

@@ -0,0 +1,27 @@
+package ejiaofei
+
+import (
+	"go.dtapp.net/golog"
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gojson"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                                              //【请求】时间
+		RequestUri:            request.RequestUri,                                                                       //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                                               //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                                              //【请求】接口
+		RequestMethod:         request.RequestMethod,                                                                    //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),                          //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),                          //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)),                         //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                                               //【返回】状态码
+		ResponseBody:          datatypes.JSON(gojson.JsonEncodeNoError(gomongo.XmlDecodeNoError(request.ResponseBody))), //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                                            //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                                             //【返回】时间
+	})
+}

service/ejiaofei/query_jkorders.go

@@ -3,6 +3,7 @@ package ejiaofei
 import (
 	"encoding/xml"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -23,26 +24,27 @@ type QueryJkOrdersResponse struct {
 type QueryJkOrdersResult struct {
 	Result QueryJkOrdersResponse // 结果
 	Body   []byte                // 内容
+	Http   gorequest.Response    // 请求
 	Err    error                 // 错误
 }
 
-func NewQueryJkOrdersResult(result QueryJkOrdersResponse, body []byte, err error) *QueryJkOrdersResult {
-	return &QueryJkOrdersResult{Result: result, Body: body, Err: err}
+func NewQueryJkOrdersResult(result QueryJkOrdersResponse, body []byte, http gorequest.Response, err error) *QueryJkOrdersResult {
+	return &QueryJkOrdersResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // QueryJkOrders 通用查询接口
 // orderid 用户提交的订单号 用户提交的订单号，最长32位（用户保证其唯一性）
-func (app *App) QueryJkOrders(orderID string) *QueryJkOrdersResult {
+func (app *App) QueryJkOrders(orderId string) *QueryJkOrdersResult {
 	// 参数
 	param := NewParams()
-	param.Set("orderid", orderID)
+	param.Set("orderid", orderId)
 	params := app.NewParamsWith(param)
 	// 签名
-	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%v", app.UserID, app.Pwd, orderID)
+	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%v", app.userId, app.pwd, orderId)
 	// 请求
-	body, err := app.request("http://api.ejiaofei.net:11140/query_jkorders.do", params, http.MethodGet)
+	request, err := app.request("http://api.ejiaofei.net:11140/query_jkorders.do", params, http.MethodGet)
 	// 定义
 	var response QueryJkOrdersResponse
-	err = xml.Unmarshal(body, &response)
-	return NewQueryJkOrdersResult(response, body, err)
+	err = xml.Unmarshal(request.ResponseBody, &response)
+	return NewQueryJkOrdersResult(response, request.ResponseBody, request, err)
 }

service/ejiaofei/query_txproduct.go

@@ -3,6 +3,7 @@ package ejiaofei
 import (
 	"encoding/xml"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -14,21 +15,22 @@ type QueryTxProductResponse struct {
 type QueryTxProductResult struct {
 	Result QueryTxProductResponse // 结果
 	Body   []byte                 // 内容
+	Http   gorequest.Response     // 请求
 	Err    error                  // 错误
 }
 
-func NewQueryTxProductResult(result QueryTxProductResponse, body []byte, err error) *QueryTxProductResult {
-	return &QueryTxProductResult{Result: result, Body: body, Err: err}
+func NewQueryTxProductResult(result QueryTxProductResponse, body []byte, http gorequest.Response, err error) *QueryTxProductResult {
+	return &QueryTxProductResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // QueryTxProduct 可充值腾讯产品查询
 func (app *App) QueryTxProduct() *QueryTxProductResult {
 	// 签名
-	app.signStr = fmt.Sprintf("userid%vpwd%v", app.UserID, app.Pwd)
+	app.signStr = fmt.Sprintf("userid%vpwd%v", app.userId, app.pwd)
 	// 请求
-	body, err := app.request("http://api.ejiaofei.net:11140/queryTXproduct.do", map[string]interface{}{}, http.MethodGet)
+	request, err := app.request("http://api.ejiaofei.net:11140/queryTXproduct.do", map[string]interface{}{}, http.MethodGet)
 	// 定义
 	var response QueryTxProductResponse
-	err = xml.Unmarshal(body, &response)
-	return NewQueryTxProductResult(response, body, err)
+	err = xml.Unmarshal(request.ResponseBody, &response)
+	return NewQueryTxProductResult(response, request.ResponseBody, request, err)
 }

service/ejiaofei/txchongzhi.go

@@ -1,9 +1,9 @@
 package ejiaofei
 
 import (
-	"encoding/json"
 	"encoding/xml"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -33,24 +33,24 @@ type TxChOngZhiResponse struct {
 type TxChOngZhiResult struct {
 	Result TxChOngZhiResponse // 结果
 	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
 	Err    error              // 错误
 }
 
-func NewTxChOngZhiResult(result TxChOngZhiResponse, body []byte, err error) *TxChOngZhiResult {
-	return &TxChOngZhiResult{Result: result, Body: body, Err: err}
+func NewTxChOngZhiResult(result TxChOngZhiResponse, body []byte, http gorequest.Response, err error) *TxChOngZhiResult {
+	return &TxChOngZhiResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // TxChOngZhi 流量充值接口
-func (app *App) TxChOngZhi(param TxChOngZhiParams) *TxChOngZhiResult {
+func (app *App) TxChOngZhi(notMustParams ...Params) *TxChOngZhiResult {
+	// 参数
+	params := app.NewParamsWith(notMustParams...)
 	// 签名
-	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%vaccount%vproductid%vamount%vip%vtimes%v", app.UserID, app.Pwd, param.OrderID, param.Account, param.ProductID, param.Amount, param.Ip, param.Times)
+	app.signStr = fmt.Sprintf("userid%vpwd%vorderid%vaccount%vproductid%vamount%vip%vtimes%v", app.userId, app.pwd, params["orderid"], params["account"], params["productid"], params["amount"], params["ip"], params["times"])
 	// 请求
-	b, _ := json.Marshal(&param)
-	var params map[string]interface{}
-	_ = json.Unmarshal(b, &params)
-	body, err := app.request("http://api.ejiaofei.net:11140/txchongzhi.do", params, http.MethodGet)
+	request, err := app.request("http://api.ejiaofei.net:11140/txchongzhi.do", params, http.MethodGet)
 	// 定义
 	var response TxChOngZhiResponse
-	err = xml.Unmarshal(body, &response)
-	return NewTxChOngZhiResult(response, body, err)
+	err = xml.Unmarshal(request.ResponseBody, &response)
+	return NewTxChOngZhiResult(response, request.ResponseBody, request, err)
 }

service/feishu/app.go

@@ -1,23 +1,59 @@
 package feishu
 
 import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gomongo"
-	"net/http"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
 )
 
 type App struct {
-	Key   string
-	Mongo gomongo.App // 日志数据库
+	key          string
+	pgsql        *gorm.DB       // pgsql数据库
+	client       *gorequest.App // 请求客户端
+	log          *golog.Api     // 日志服务
+	logTableName string         // 日志表名
+	logStatus    bool           // 日志状态
 }
 
-func (app *App) request(url string, params map[string]interface{}) (body []byte, err error) {
-	// 请求参数
-	paramsStr, err := json.Marshal(params)
-	// 请求
-	postJson, err := gohttp.PostJson(url, paramsStr)
+func NewApp(key string, pgsql *gorm.DB) *App {
+	app := &App{key: key}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "feishu"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
+	}
+	return app
+}
+
+func (app *App) request(url string, params map[string]interface{}) (resp gorequest.Response, err error) {
+
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置格式
+	client.SetContentTypeJson()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Post()
+	if err != nil {
+		return gorequest.Response{}, err
+	}
+
 	// 日志
-	go app.mongoLog(url, params, http.MethodPost, postJson)
-	return postJson.Body, err
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
 }

service/feishu/mongodb.go

@@ -1,47 +0,0 @@
-package feishu
-
-import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "feishu_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	var body map[string]interface{}
-	_ = json.Unmarshal(request.Body, &body)
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          body,
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}

service/feishu/pgsql.go

@@ -0,0 +1,26 @@
+package feishu
+
+import (
+	"go.dtapp.net/gojson"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
+	})
+}

service/feishu/webhook.go

@@ -3,6 +3,7 @@ package feishu
 import (
 	"encoding/json"
 	"fmt"
+	"go.dtapp.net/library/utils/gorequest"
 )
 
 type WebhookSendResponse struct {
@@ -16,11 +17,12 @@ type WebhookSendResponse struct {
 type WebhookSendResult struct {
 	Result WebhookSendResponse // 结果
 	Body   []byte              // 内容
+	Http   gorequest.Response  // 请求
 	Err    error               // 错误
 }
 
-func NewWebhookSendResult(result WebhookSendResponse, body []byte, err error) *WebhookSendResult {
-	return &WebhookSendResult{Result: result, Body: body, Err: err}
+func NewWebhookSendResult(result WebhookSendResponse, body []byte, http gorequest.Response, err error) *WebhookSendResult {
+	return &WebhookSendResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // WebhookSend https://open.feishu.cn/document/ukTMukTMukTM/ucTM5YjL3ETO24yNxkjN
@@ -28,9 +30,9 @@ func (app *App) WebhookSend(notMustParams ...Params) *WebhookSendResult {
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
-	body, err := app.request(fmt.Sprintf("https://open.feishu.cn/open-apis/bot/v2/hook/%s", app.Key), params)
+	request, err := app.request(fmt.Sprintf("https://open.feishu.cn/open-apis/bot/v2/hook/%s", app.key), params)
 	// 定义
 	var response WebhookSendResponse
-	err = json.Unmarshal(body, &response)
-	return NewWebhookSendResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewWebhookSendResult(response, request.ResponseBody, request, err)
 }

service/jd/app.go

@@ -1,28 +1,67 @@
 package jd
 
 import (
-	"fmt"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gomongo"
-	"net/http"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"go.dtapp.net/gostring"
+	"gorm.io/gorm"
 )
 
 type App struct {
-	AppKey     string      // 应用Key
-	SecretKey  string      // 密钥
-	SiteId     string      // 网站ID/APP ID
-	PositionId string      // 推广位id
-	Mongo      gomongo.App // 日志数据库
+	appKey       string         // 应用Key
+	secretKey    string         // 密钥
+	siteId       string         // 网站ID/APP ID
+	positionId   string         // 推广位id
+	pgsql        *gorm.DB       // pgsql数据库
+	client       *gorequest.App // 请求客户端
+	log          *golog.Api     // 日志服务
+	logTableName string         // 日志表名
+	logStatus    bool           // 日志状态
 }
 
-func (app *App) request(params map[string]interface{}) (resp []byte, err error) {
+func NewApp(appKey string, secretKey string, siteId string, positionId string, pgsql *gorm.DB) *App {
+	app := &App{appKey: appKey, secretKey: secretKey, siteId: siteId, positionId: positionId}
+	app.client = gorequest.NewHttp()
+	app.client.Uri = "https://api.jd.com/routerjson"
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "jd"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
+	}
+	return app
+}
+
+// 请求接口
+func (app *App) request(params map[string]interface{}) (resp gorequest.Response, err error) {
+
 	// 签名
 	app.Sign(params)
-	// 发送请求
-	get, err := gohttp.PostForm("https://api.jd.com/routerjson", params)
+
+	// 创建请求
+	client := app.client
+
+	// 设置格式
+	client.SetContentTypeForm()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Post()
+	if err != nil {
+		return gorequest.Response{}, err
+	}
+
 	// 日志
-	go app.mongoLog(fmt.Sprintf("https://api.jd.com/routerjson?method=%s", params["method"]), params, http.MethodPost, get)
-	return get.Body, err
+	if app.logStatus == true {
+		go app.postgresqlLog(gostring.ToString(params["method"]), request)
+	}
+
+	return request, err
 }
 
 // GoodsPriceToInt64 商品券后价
@@ -49,3 +88,11 @@ func (app *App) CouponAmountToInt64(Commission float64) int64 {
 func (app *App) CommissionIntegralToInt64(GoodsPrice, CouponProportion int64) int64 {
 	return (GoodsPrice * CouponProportion) / 1000
 }
+
+func (app *App) GetSiteId() string {
+	return app.siteId
+}
+
+func (app *App) GetPositionId() string {
+	return app.positionId
+}

service/jd/jd.union.open.activity.query.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenActivityQueryResultResponse struct {
 	JdUnionOpenActivityQueryResponce struct {
@@ -48,11 +51,12 @@ type UnionOpenActivityQueryResult struct {
 	Responce UnionOpenActivityQueryResultResponse // 结果
 	Result   UnionOpenActivityQueryQueryResult    // 结果
 	Body     []byte                               // 内容
+	Http     gorequest.Response                   // 请求
 	Err      error                                // 错误
 }
 
-func NewUnionOpenActivityQueryResult(responce UnionOpenActivityQueryResultResponse, result UnionOpenActivityQueryQueryResult, body []byte, err error) *UnionOpenActivityQueryResult {
-	return &UnionOpenActivityQueryResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenActivityQueryResult(responce UnionOpenActivityQueryResultResponse, result UnionOpenActivityQueryQueryResult, body []byte, http gorequest.Response, err error) *UnionOpenActivityQueryResult {
+	return &UnionOpenActivityQueryResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenActivityQuery 活动查询接口
@@ -61,11 +65,11 @@ func (app *App) UnionOpenActivityQuery(notMustParams ...Params) *UnionOpenActivi
 	// 参数
 	params := NewParamsWithType("jd.union.open.activity.query", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenActivityQueryResultResponse
 	var result UnionOpenActivityQueryQueryResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenActivityQueryResponce.QueryResult), &result)
-	return NewUnionOpenActivityQueryResult(responce, result, body, err)
+	return NewUnionOpenActivityQueryResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.category.goods.get.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenCategoryGoodsGetResultResponse struct {
 	JdUnionOpenCategoryGoodsGetResponce struct {
@@ -25,11 +28,12 @@ type UnionOpenCategoryGoodsGetResult struct {
 	Responce UnionOpenCategoryGoodsGetResultResponse // 结果
 	Result   UnionOpenCategoryGoodsGetQueryResult    // 结果
 	Body     []byte                                  // 内容
+	Http     gorequest.Response                      // 请求
 	Err      error                                   // 错误
 }
 
-func NewUnionOpenCategoryGoodsGetResult(responce UnionOpenCategoryGoodsGetResultResponse, result UnionOpenCategoryGoodsGetQueryResult, body []byte, err error) *UnionOpenCategoryGoodsGetResult {
-	return &UnionOpenCategoryGoodsGetResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenCategoryGoodsGetResult(responce UnionOpenCategoryGoodsGetResultResponse, result UnionOpenCategoryGoodsGetQueryResult, body []byte, http gorequest.Response, err error) *UnionOpenCategoryGoodsGetResult {
+	return &UnionOpenCategoryGoodsGetResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenCategoryGoodsGet 商品类目查询接口
@@ -38,11 +42,11 @@ func (app *App) UnionOpenCategoryGoodsGet(notMustParams ...Params) *UnionOpenCat
 	// 参数
 	params := NewParamsWithType("jd.union.open.category.goods.get", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenCategoryGoodsGetResultResponse
 	var result UnionOpenCategoryGoodsGetQueryResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenCategoryGoodsGetResponce.GetResult), &result)
-	return NewUnionOpenCategoryGoodsGetResult(responce, result, body, err)
+	return NewUnionOpenCategoryGoodsGetResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.goods.bigfield.query.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenGoodsBigfieldQueryResultResponse struct {
 	JdUnionOpenGoodsBigfieldQueryResponce struct {
@@ -45,11 +48,12 @@ type UnionOpenGoodsBigfieldQueryResult struct {
 	Responce UnionOpenGoodsBigfieldQueryResultResponse // 结果
 	Result   UnionOpenGoodsBigfieldQueryQueryResult    // 结果
 	Body     []byte                                    // 内容
+	Http     gorequest.Response                        // 请求
 	Err      error                                     // 错误
 }
 
-func NewUnionOpenGoodsBigfieldQueryResult(responce UnionOpenGoodsBigfieldQueryResultResponse, result UnionOpenGoodsBigfieldQueryQueryResult, body []byte, err error) *UnionOpenGoodsBigfieldQueryResult {
-	return &UnionOpenGoodsBigfieldQueryResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenGoodsBigfieldQueryResult(responce UnionOpenGoodsBigfieldQueryResultResponse, result UnionOpenGoodsBigfieldQueryQueryResult, body []byte, http gorequest.Response, err error) *UnionOpenGoodsBigfieldQueryResult {
+	return &UnionOpenGoodsBigfieldQueryResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenGoodsBigfieldQuery 商品详情查询接口
@@ -58,11 +62,11 @@ func (app *App) UnionOpenGoodsBigfieldQuery(notMustParams ...Params) *UnionOpenG
 	// 参数
 	params := NewParamsWithType("jd.union.open.goods.bigfield.query", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenGoodsBigfieldQueryResultResponse
 	var result UnionOpenGoodsBigfieldQueryQueryResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenGoodsBigfieldQueryResponce.QueryResult), &result)
-	return NewUnionOpenGoodsBigfieldQueryResult(responce, result, body, err)
+	return NewUnionOpenGoodsBigfieldQueryResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.goods.jingfen.query.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenGoodsJIngFenQueryResultResponse struct {
 	JdUnionOpenGoodsJingfenQueryResponce struct {
@@ -109,11 +112,12 @@ type UnionOpenGoodsJIngFenQueryResult struct {
 	Responce UnionOpenGoodsJIngFenQueryResultResponse // 结果
 	Result   UnionOpenGoodsJIngFenQueryQueryResult    // 结果
 	Body     []byte                                   // 内容
+	Http     gorequest.Response                       // 请求
 	Err      error                                    // 错误
 }
 
-func NewUnionOpenGoodsJIngFenQueryResult(responce UnionOpenGoodsJIngFenQueryResultResponse, result UnionOpenGoodsJIngFenQueryQueryResult, body []byte, err error) *UnionOpenGoodsJIngFenQueryResult {
-	return &UnionOpenGoodsJIngFenQueryResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenGoodsJIngFenQueryResult(responce UnionOpenGoodsJIngFenQueryResultResponse, result UnionOpenGoodsJIngFenQueryQueryResult, body []byte, http gorequest.Response, err error) *UnionOpenGoodsJIngFenQueryResult {
+	return &UnionOpenGoodsJIngFenQueryResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenGoodsJIngFenQuery 京粉精选商品查询接口
@@ -122,11 +126,11 @@ func (app *App) UnionOpenGoodsJIngFenQuery(notMustParams ...Params) *UnionOpenGo
 	// 参数
 	params := NewParamsWithType("jd.union.open.goods.jingfen.query", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenGoodsJIngFenQueryResultResponse
 	var result UnionOpenGoodsJIngFenQueryQueryResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenGoodsJingfenQueryResponce.QueryResult), &result)
-	return NewUnionOpenGoodsJIngFenQueryResult(responce, result, body, err)
+	return NewUnionOpenGoodsJIngFenQueryResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.goods.material.query.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenGoodsMaterialQueryResultResponse struct {
 	JdUnionOpenGoodsMaterialQueryResponce struct {
@@ -106,11 +109,12 @@ type UnionOpenGoodsMaterialQueryResult struct {
 	Responce UnionOpenGoodsMaterialQueryResultResponse // 结果
 	Result   UnionOpenGoodsMaterialQueryQueryResult    // 结果
 	Body     []byte                                    // 内容
+	Http     gorequest.Response                        // 请求
 	Err      error                                     // 错误
 }
 
-func NewUnionOpenGoodsMaterialQueryResult(responce UnionOpenGoodsMaterialQueryResultResponse, result UnionOpenGoodsMaterialQueryQueryResult, body []byte, err error) *UnionOpenGoodsMaterialQueryResult {
-	return &UnionOpenGoodsMaterialQueryResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenGoodsMaterialQueryResult(responce UnionOpenGoodsMaterialQueryResultResponse, result UnionOpenGoodsMaterialQueryQueryResult, body []byte, http gorequest.Response, err error) *UnionOpenGoodsMaterialQueryResult {
+	return &UnionOpenGoodsMaterialQueryResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenGoodsMaterialQuery 猜你喜欢商品推荐
@@ -119,11 +123,11 @@ func (app *App) UnionOpenGoodsMaterialQuery(notMustParams ...Params) *UnionOpenG
 	// 参数
 	params := NewParamsWithType("jd.union.open.goods.material.query", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenGoodsMaterialQueryResultResponse
 	var result UnionOpenGoodsMaterialQueryQueryResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenGoodsMaterialQueryResponce.QueryResult), &result)
-	return NewUnionOpenGoodsMaterialQueryResult(responce, result, body, err)
+	return NewUnionOpenGoodsMaterialQueryResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.goods.promotiongoodsinfo.query.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenGoodsPromotionGoodsInfoQueryResultResponse struct {
 	JdUnionOpenGoodsPromotiongoodsinfoQueryResponce struct {
@@ -44,11 +47,12 @@ type UnionOpenGoodsPromotionGoodsInfoQueryResult struct {
 	Responce UnionOpenGoodsPromotionGoodsInfoQueryResultResponse // 结果
 	Result   UnionOpenGoodsPromotionGoodsInfoQueryQueryResult    // 结果
 	Body     []byte                                              // 内容
+	Http     gorequest.Response                                  // 请求
 	Err      error                                               // 错误
 }
 
-func NewUnionOpenGoodsPromotionGoodsInfoQueryResult(responce UnionOpenGoodsPromotionGoodsInfoQueryResultResponse, result UnionOpenGoodsPromotionGoodsInfoQueryQueryResult, body []byte, err error) *UnionOpenGoodsPromotionGoodsInfoQueryResult {
-	return &UnionOpenGoodsPromotionGoodsInfoQueryResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenGoodsPromotionGoodsInfoQueryResult(responce UnionOpenGoodsPromotionGoodsInfoQueryResultResponse, result UnionOpenGoodsPromotionGoodsInfoQueryQueryResult, body []byte, http gorequest.Response, err error) *UnionOpenGoodsPromotionGoodsInfoQueryResult {
+	return &UnionOpenGoodsPromotionGoodsInfoQueryResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenGoodsPromotionGoodsInfoQuery 根据skuid查询商品信息接口
@@ -57,11 +61,11 @@ func (app *App) UnionOpenGoodsPromotionGoodsInfoQuery(notMustParams ...Params) *
 	// 参数
 	params := NewParamsWithType("jd.union.open.goods.promotiongoodsinfo.query", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenGoodsPromotionGoodsInfoQueryResultResponse
 	var result UnionOpenGoodsPromotionGoodsInfoQueryQueryResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenGoodsPromotiongoodsinfoQueryResponce.QueryResult), &result)
-	return NewUnionOpenGoodsPromotionGoodsInfoQueryResult(responce, result, body, err)
+	return NewUnionOpenGoodsPromotionGoodsInfoQueryResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.order.query.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenOrderQueryResultResponse struct {
 	JdUnionOpenOrderQueryResponce struct {
@@ -69,11 +72,12 @@ type UnionOpenOrderQueryResult struct {
 	Responce UnionOpenOrderQueryResultResponse // 结果
 	Result   UnionOpenOrderQueryQueryResult    // 结果
 	Body     []byte                            // 内容
+	Http     gorequest.Response                // 请求
 	Err      error                             // 错误
 }
 
-func NewUnionOpenOrderQueryResult(responce UnionOpenOrderQueryResultResponse, result UnionOpenOrderQueryQueryResult, body []byte, err error) *UnionOpenOrderQueryResult {
-	return &UnionOpenOrderQueryResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenOrderQueryResult(responce UnionOpenOrderQueryResultResponse, result UnionOpenOrderQueryQueryResult, body []byte, http gorequest.Response, err error) *UnionOpenOrderQueryResult {
+	return &UnionOpenOrderQueryResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenOrderQuery 订单查询接口
@@ -82,11 +86,11 @@ func (app *App) UnionOpenOrderQuery(notMustParams ...Params) *UnionOpenOrderQuer
 	// 参数
 	params := NewParamsWithType("jd.union.open.order.query", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenOrderQueryResultResponse
 	var result UnionOpenOrderQueryQueryResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenOrderQueryResponce.QueryResult), &result)
-	return NewUnionOpenOrderQueryResult(responce, result, body, err)
+	return NewUnionOpenOrderQueryResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.order.row.query.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenOrderRowQueryResultResponse struct {
 	JdUnionOpenOrderRowQueryResponce struct {
@@ -78,11 +81,12 @@ type UnionOpenOrderRowQueryResult struct {
 	Responce UnionOpenOrderRowQueryResultResponse // 结果
 	Result   UnionOpenOrderRowQueryQueryResult    // 结果
 	Body     []byte                               // 内容
+	Http     gorequest.Response                   // 请求
 	Err      error                                // 错误
 }
 
-func NewUnionOpenOrderRowQueryResult(responce UnionOpenOrderRowQueryResultResponse, result UnionOpenOrderRowQueryQueryResult, body []byte, err error) *UnionOpenOrderRowQueryResult {
-	return &UnionOpenOrderRowQueryResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenOrderRowQueryResult(responce UnionOpenOrderRowQueryResultResponse, result UnionOpenOrderRowQueryQueryResult, body []byte, http gorequest.Response, err error) *UnionOpenOrderRowQueryResult {
+	return &UnionOpenOrderRowQueryResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenOrderRowQuery 订单行查询接口
@@ -91,11 +95,11 @@ func (app *App) UnionOpenOrderRowQuery(notMustParams ...Params) *UnionOpenOrderR
 	// 参数
 	params := NewParamsWithType("jd.union.open.order.row.query", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenOrderRowQueryResultResponse
 	var result UnionOpenOrderRowQueryQueryResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenOrderRowQueryResponce.QueryResult), &result)
-	return NewUnionOpenOrderRowQueryResult(responce, result, body, err)
+	return NewUnionOpenOrderRowQueryResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.promotion.bysubunionid.get.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenPromotionBySubUnionIdGetResultResponse struct {
 	JdUnionOpenPromotionBySubUnionIdGetResponce struct {
@@ -23,11 +26,12 @@ type UnionOpenPromotionBySubUnionIdGetResult struct {
 	Responce UnionOpenPromotionBySubUnionIdGetResultResponse // 结果
 	Result   UnionOpenPromotionBySubUnionIdGetGetResult      // 结果
 	Body     []byte                                          // 内容
+	Http     gorequest.Response                              // 请求
 	Err      error                                           // 错误
 }
 
-func NewUnionOpenPromotionBySubUnionIdGetResult(responce UnionOpenPromotionBySubUnionIdGetResultResponse, result UnionOpenPromotionBySubUnionIdGetGetResult, body []byte, err error) *UnionOpenPromotionBySubUnionIdGetResult {
-	return &UnionOpenPromotionBySubUnionIdGetResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenPromotionBySubUnionIdGetResult(responce UnionOpenPromotionBySubUnionIdGetResultResponse, result UnionOpenPromotionBySubUnionIdGetGetResult, body []byte, http gorequest.Response, err error) *UnionOpenPromotionBySubUnionIdGetResult {
+	return &UnionOpenPromotionBySubUnionIdGetResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenPromotionBySubUnionIdGet 社交媒体获取推广链接接口【申请】
@@ -36,11 +40,11 @@ func (app *App) UnionOpenPromotionBySubUnionIdGet(notMustParams ...Params) *Unio
 	// 参数
 	params := NewParamsWithType("jd.union.open.promotion.bysubunionid.get", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenPromotionBySubUnionIdGetResultResponse
 	var result UnionOpenPromotionBySubUnionIdGetGetResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenPromotionBySubUnionIdGetResponce.GetResult), &result)
-	return NewUnionOpenPromotionBySubUnionIdGetResult(responce, result, body, err)
+	return NewUnionOpenPromotionBySubUnionIdGetResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/jd.union.open.promotion.common.get.go

@@ -1,6 +1,9 @@
 package jd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type UnionOpenPromotionCommonGetResultResponse struct {
 	JdUnionOpenPromotionCommonGetResponce struct {
@@ -23,11 +26,12 @@ type UnionOpenPromotionCommonGetResult struct {
 	Responce UnionOpenPromotionCommonGetResultResponse // 结果
 	Result   UnionOpenPromotionCommonGetGetResult      // 结果
 	Body     []byte                                    // 内容
+	Http     gorequest.Response                        // 请求
 	Err      error                                     // 错误
 }
 
-func NewUnionOpenPromotionCommonGetResult(responce UnionOpenPromotionCommonGetResultResponse, result UnionOpenPromotionCommonGetGetResult, body []byte, err error) *UnionOpenPromotionCommonGetResult {
-	return &UnionOpenPromotionCommonGetResult{Responce: responce, Result: result, Body: body, Err: err}
+func NewUnionOpenPromotionCommonGetResult(responce UnionOpenPromotionCommonGetResultResponse, result UnionOpenPromotionCommonGetGetResult, body []byte, http gorequest.Response, err error) *UnionOpenPromotionCommonGetResult {
+	return &UnionOpenPromotionCommonGetResult{Responce: responce, Result: result, Body: body, Http: http, Err: err}
 }
 
 // UnionOpenPromotionCommonGet 网站/APP获取推广链接接口
@@ -36,11 +40,11 @@ func (app *App) UnionOpenPromotionCommonGet(notMustParams ...Params) *UnionOpenP
 	// 参数
 	params := NewParamsWithType("jd.union.open.promotion.common.get", notMustParams...)
 	// 请求
-	body, err := app.request(params)
+	request, err := app.request(params)
 	// 定义
 	var responce UnionOpenPromotionCommonGetResultResponse
 	var result UnionOpenPromotionCommonGetGetResult
-	err = json.Unmarshal(body, &responce)
+	err = json.Unmarshal(request.ResponseBody, &responce)
 	err = json.Unmarshal([]byte(responce.JdUnionOpenPromotionCommonGetResponce.GetResult), &result)
-	return NewUnionOpenPromotionCommonGetResult(responce, result, body, err)
+	return NewUnionOpenPromotionCommonGetResult(responce, result, request.ResponseBody, request, err)
 }

service/jd/mongodb.go

@@ -1,47 +0,0 @@
-package jd
-
-import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "jd_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	var body map[string]interface{}
-	_ = json.Unmarshal(request.Body, &body)
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          body,
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}

service/jd/params.go

@@ -40,18 +40,18 @@ func NewParamsWithType(_method string, params ...Params) Params {
 }
 
 func (app *App) Sign(p Params) {
-	p["app_key"] = app.AppKey
+	p["app_key"] = app.appKey
 	// 排序所有的 key
 	var keys []string
 	for key := range p {
 		keys = append(keys, key)
 	}
 	sort.Strings(keys)
-	signStr := app.SecretKey
+	signStr := app.secretKey
 	for _, key := range keys {
 		signStr += key + getString(p[key])
 	}
-	signStr += app.SecretKey
+	signStr += app.secretKey
 	p["sign"] = createSign(signStr)
 }
 

service/jd/pgsql.go

@@ -0,0 +1,26 @@
+package jd
+
+import (
+	"go.dtapp.net/gojson"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(api string, request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            api,                                                              //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
+	})
+}

service/jobs/const.go

@@ -0,0 +1,70 @@
+package jobs
+
+import (
+	"fmt"
+	"net/http"
+)
+
+const (
+	CodeAbnormal = 0                              // 异常
+	CodeError    = http.StatusInternalServerError // 失败
+	CodeSuccess  = http.StatusOK                  // 成功
+	CodeEnd      = http.StatusCreated             // 结束
+)
+
+// 每隔n秒执行一次
+const specSeconds = "*/%d * * * * *"
+
+// GetSpecSeconds 每隔n秒执行一次
+var GetSpecSeconds = func(n int64) string {
+	if n < 0 && n > 59 {
+		return ""
+	}
+	return fmt.Sprintf(specSeconds, n)
+}
+
+// GetFrequencySeconds 每隔n秒执行一次
+var GetFrequencySeconds = func(n int64) int64 {
+	if n < 0 && n > 59 {
+		return -1
+	}
+	return n
+}
+
+// 每隔n分钟执行一次
+const specMinutes = "0 */%d * * * *"
+
+// GetSpecMinutes 每隔n分钟执行一次
+var GetSpecMinutes = func(n int64) string {
+	if n < 0 && n > 59 {
+		return ""
+	}
+	return fmt.Sprintf(specMinutes, n)
+}
+
+// GetFrequencyMinutes 每隔n分钟执行一次
+var GetFrequencyMinutes = func(n int64) int64 {
+	if n < 0 && n > 59 {
+		return -1
+	}
+	return n * 60
+}
+
+// 每天n点执行一次
+const specHour = "0 0 */%d * * *"
+
+// GetSpecHour 每天n点执行一次
+var GetSpecHour = func(n int64) string {
+	if n < 0 && n > 23 {
+		return ""
+	}
+	return fmt.Sprintf(specHour, n)
+}
+
+// GetFrequencyHour 每天n点执行一次
+var GetFrequencyHour = func(n int64) int64 {
+	if n < 0 && n > 23 {
+		return -1
+	}
+	return n * 60 * 60
+}

service/jobs/ip.go

@@ -2,135 +2,6 @@ package jobs
 
 import "go.dtapp.net/library/utils/goip"
 
-var TypeIp = map[string]string{
-	// 微信支付查询
-	TypeWechatPayPrepaidRefill: "",
-	TypeWechatPayPower:         "",
-	TypeWechatPayKashangwl:     "",
-	TypeWechatPayEastiot:       "",
-	TypeWechatPayEjiaofei:      "",
-	TypeWechatPayMovie:         "",
-
-	// 接口支付申请
-	TypeApiPaySubmitPrepaidRefill: "",
-	TypeApiPaySubmitPower:         "",
-	TypeApiPaySubmitKashangwl:     "",
-	TypeApiPaySubmitEastiot:       "47.112.146.193",
-	TypeApiPaySubmitEjiaofei:      "47.112.146.193",
-	TypeApiPaySubmitMovie:         "",
-
-	// 接口支付查询
-	TypeApiPayQueryPrepaidRefill: "",
-	TypeApiPayQueryPower:         "",
-	TypeApiPayQueryKashangwl:     "",
-	TypeApiPayQueryEastiot:       "47.112.146.193",
-	TypeApiPayQueryEjiaofei:      "",
-	TypeApiPayQueryMovie:         "",
-	TypeApiPayQueryPinduoduo:     "",
-	TypeApiPayQueryMeituan:       "",
-
-	// 微信支付退款申请
-	TypeWechatRefundsSubmitPrepaidRefill: "",
-	TypeWechatRefundsSubmitPower:         "",
-	TypeWechatRefundsSubmitKashangwl:     "",
-	TypeWechatRefundsSubmitEastiot:       "",
-	TypeWechatRefundsSubmitEjiaofei:      "",
-	TypeWechatRefundsSubmitMovie:         "",
-
-	// 微信支付退款查询
-	TypeWechatRefundsQueryPrepaidRefill: "",
-	TypeWechatRefundsQueryPower:         "",
-	TypeWechatRefundsQueryKashangwl:     "",
-	TypeWechatRefundsQueryEastiot:       "",
-	TypeWechatRefundsQueryEjiaofei:      "",
-	TypeWechatRefundsQueryMovie:         "",
-
-	// 返拥
-	TypeGoldenBeansIssuePrepaidRefill: "",
-	TypeGoldenBeansIssuePower:         "",
-	TypeGoldenBeansIssueKashangwl:     "",
-	TypeGoldenBeansIssueEastiot:       "",
-	TypeGoldenBeansIssueMovie:         "",
-	TypeGoldenBeansIssueRewardedvideo: "",
-
-	// 冻结返拥金豆
-	TypeGoldenBeansFrozenPinduoduo: "",
-	TypeGoldenBeansFrozenMeituan:   "",
-
-	// 解冻返拥金豆正常发放
-	TypeGoldenBeansThawSuccessPinduoduo: "",
-	TypeGoldenBeansThawSuccessMeituan:   "",
-
-	// 解冻返拥金豆扣款
-	TypeGoldenBeansThawErrorPinduoduo: "",
-	TypeGoldenBeansThawErrorMeituan:   "",
-
-	// 抵扣金豆退款
-	TypeGoldenBeansRefundsPrepaidRefill: "",
-	TypeGoldenBeansRefundsPower:         "",
-
-	// 金豆退款
-	TypeGoldenBeansRefundsEjiaofei: "",
-
-	// 客服进度
-	TypeCustomerAutoPrepaidRefill: "",
-	TypeCustomerAutoPower:         "",
-	TypeCustomerAutoKashangwl:     "",
-	TypeCustomerAutoEjiaofei:      "",
-	TypeCustomerAutoMovie:         "",
-
-	// 订单同步
-	TypeSyncOrderPinduoduo: "",
-	TypeSyncOrderMeituan:   "",
-
-	// 商品同步
-	TypeSyncGoodsEastiot:              "47.112.146.193",
-	TypeSyncGoodsTypeEastiot:          "47.112.146.193",
-	TypeSyncGoodsPriceAllKashangwl:    "",
-	TypeSyncGoodsPriceSingleKashangwl: "",
-	TypeCheckGoodsAllPinduoduo:        "",
-	TypeCheckGoodsSinglePinduoduo:     "",
-
-	// 微信更新
-	TypeSyncWechat: "119.3.235.113,119.3.132.197,47.112.146.193",
-
-	// 商家金豆转换
-	TypeGoldenBeanConversionUserGoldenBean:       "",
-	TypeGoldenBeanConversionUserDeductGoldenBean: "",
-
-	// 企业自定义
-	TypeNewServiceAgentIssue:     "",
-	TypeNewServiceAgentIssueNext: "",
-
-	// 团队
-	TypeTeamInv: "",
-
-	// 修复商家账号数量
-	TypeRepairMerchantAccountQuantityTesting: "",
-	TypeRepairMerchantAccountQuantityLevel:   "",
-
-	// 观察接口
-	TypeApiPayObservationPrepaidRefill:    "",
-	TypeApiPayObservationPower:            "",
-	TypeApiPayObservationKashangwl:        "",
-	TypeApiPayObservationEjiaofei:         "47.112.146.193",
-	TypeApiPayObservationMovie:            "",
-	TypeApiPayObservationPinduoduo:        "",
-	TypeApiPayObservationMeituan:          "",
-	TypeApiPayObservationWechat:           "",
-	TypeApiPayObservationWechatRefunds:    "",
-	TypeApiPayObservationWechatWithdrawal: "",
-
-	// 微信提现
-	TypeWechatPayWithdrawalSubmit:  "47.112.146.193",
-	TypeWechatPayWithdrawalQuery:   "",
-	TypeWechatPayWithdrawalRefunds: "",
-}
-
-func (app *App) Ip(Type string) string {
-	return TypeIp[Type]
-}
-
 func (app *App) RefreshIp() {
 	xip := goip.GetOutsideIp()
 	if app.OutsideIp == "" || app.OutsideIp == "0.0.0.0" {

service/jobs/jobs.go

@@ -1,28 +1,26 @@
 package jobs
 
 import (
-	"fmt"
 	"go.dtapp.net/library/utils/gojson"
 	"go.dtapp.net/library/utils/goredis"
 	"go.dtapp.net/library/utils/gotime"
 	"go.dtapp.net/library/utils/gouuid"
 	"gorm.io/gorm"
-	"net/http"
+	"log"
 )
 
 type App struct {
-	RunVersion   int         `json:"run_version"`    // 运行版本
-	Os           string      `json:"os"`             // 系统类型
-	Arch         string      `json:"arch"`           // 系统架构
-	MaxProCs     int         `json:"max_pro_cs"`     // CPU核数
-	Version      string      `json:"version"`        // GO版本
-	MacAddrS     string      `json:"mac_addr_s"`     // Mac地址
-	InsideIp     string      `json:"inside_ip"`      // 内网ip
-	OutsideIp    string      `json:"outside_ip"`     // 外网ip
-	MainService  int         `json:"main_service"`   // 主要服务
-	AddIpService int         `json:"add_ip_service"` // 添加IP
-	Db           *gorm.DB    // 数据库
-	Redis        goredis.App // 缓存数据库服务
+	RunVersion  int         `json:"run_version"`  // 运行版本
+	Os          string      `json:"os"`           // 系统类型
+	Arch        string      `json:"arch"`         // 系统架构
+	MaxProCs    int         `json:"max_pro_cs"`   // CPU核数
+	Version     string      `json:"version"`      // GO版本
+	MacAddrS    string      `json:"mac_addr_s"`   // Mac地址
+	InsideIp    string      `json:"inside_ip"`    // 内网ip
+	OutsideIp   string      `json:"outside_ip"`   // 外网ip
+	MainService int         `json:"main_service"` // 主要服务
+	Db          *gorm.DB    // 数据库
+	Redis       goredis.App // 缓存数据库服务
 }
 
 // Add 添加任务
@@ -142,32 +140,20 @@ func (app *App) AddInTeamInv(Type string, params interface{}, frequency int64) i
 	return app.AddIn(param, params)
 }
 
-// AddInNewService 添加企业自定义可执行任务
-func (app *App) AddInNewService(Type string, params interface{}, frequency int64) int64 {
+// AddInUserShareInvitation 邀请好友
+func (app *App) AddInUserShareInvitation(Type string, params interface{}, frequency int64) int64 {
 	var param TaskParams
 	param.Type = Type
 	param.Frequency = frequency
-	param.ParamsType = ParamsNewServiceType
 	return app.AddIn(param, params)
 }
 
-// AddInNewServiceNext 添加企业自定义下一步可执行任务
-func (app *App) AddInNewServiceNext(param TaskParams, params interface{}) int64 {
-	param.ParamsType = ParamsNewServiceNextType
-	return app.AddIn(param, params)
-}
-
-// AddInRepairMerchantAccountQuantity 添加可执行任务
-func (app *App) AddInRepairMerchantAccountQuantity() int64 {
+// AddInNewService 添加企业自定义可执行任务
+func (app *App) AddInNewService(Type string, params interface{}, frequency int64) int64 {
 	var param TaskParams
-	param.Type = TypeRepairMerchantAccountQuantityTesting
-	param.Frequency = 90000
-	return app.AddIn(param, map[string]interface{}{})
-}
-
-// AddInRepairMerchantAccountQuantityLevel 添加修复商家账号数量下一步可执行任务
-func (app *App) AddInRepairMerchantAccountQuantityLevel(param TaskParams, params interface{}) int64 {
-	param.ParamsType = ParamsRepairMerchantAccountQuantityLevelType
+	param.Type = Type
+	param.Frequency = frequency
+	param.ParamsType = ParamsNewServiceType
 	return app.AddIn(param, params)
 }
 
@@ -175,7 +161,7 @@ func (app *App) AddInRepairMerchantAccountQuantityLevel(param TaskParams, params
 func (app *App) AddInOrderCustomIdObservation(Type string, customId string) int64 {
 	query := app.TaskCustomIdTakeStatus(Type, customId, TASK_IN)
 	if query.Id != 0 {
-		return query.Id
+		return int64(query.Id)
 	}
 	var param TaskParams
 	param.Type = Type
@@ -217,7 +203,11 @@ func (app *App) AddIn(param TaskParams, params interface{}) int64 {
 	param.UpdatedIp = app.OutsideIp
 	param.CreatedAt = gotime.Current().Format()
 	param.UpdatedAt = gotime.Current().Format()
-	return app.Db.Create(&param).RowsAffected
+	status := app.Db.Create(&param)
+	if status.RowsAffected == 0 {
+		log.Println("AddIn：", status.Error)
+	}
+	return status.RowsAffected
 }
 
 // AddWaitNewServiceNext 添加企业自定义下一步等待执行任务
@@ -226,28 +216,6 @@ func (app *App) AddWaitNewServiceNext(param TaskParams, params interface{}) int6
 	return app.AddWait(param, params)
 }
 
-// AddWaitRepairMerchantAccountQuantityLevel 添加修复商家账号数量下一步等待执行任务
-func (app *App) AddWaitRepairMerchantAccountQuantityLevel(param TaskParams, params interface{}) int64 {
-	param.ParamsType = ParamsRepairMerchantAccountQuantityLevelType
-	return app.AddWait(param, params)
-}
-
-// AddInKashangwlPriceCustomId 添加刷新卡商网价格任务
-func (app *App) AddInKashangwlPriceCustomId(productId int64) int64 {
-	query := app.TaskCustomIdTakeStatus(TypeSyncGoodsPriceSingleKashangwl, fmt.Sprintf("%v", productId), TASK_IN)
-	if query.Id != 0 {
-		return query.Id
-	}
-	var param TaskParams
-	param.Type = TypeSyncGoodsPriceSingleKashangwl
-	param.Frequency = 1800
-	param.CustomId = fmt.Sprintf("%v", productId)
-	param.ParamsType = ParamsKashangwlType
-	return app.AddIn(param, ParamsKashangwlId{
-		ProductID: productId,
-	})
-}
-
 // AddWait 添加等待执行任务
 // params.Type 任务类型
 // params.Frequency 任务频率
@@ -267,12 +235,12 @@ func (app *App) AddWait(param TaskParams, params interface{}) int64 {
 }
 
 // Edit 任务修改
-func (app *App) Edit(id int64) *gorm.DB {
+func (app *App) Edit(id uint) *gorm.DB {
 	return app.Db.Model(&Task{}).Where("id = ?", id)
 }
 
 // UpdateFrequency 更新任务频率
-func (app *App) UpdateFrequency(id, frequency int64) *gorm.DB {
+func (app *App) UpdateFrequency(id uint, frequency int64) *gorm.DB {
 	return app.Edit(id).Updates(map[string]interface{}{
 		"frequency": frequency,
 	})
@@ -293,7 +261,7 @@ func (app *App) Start(customId string, customSequence int64) int64 {
 }
 
 // RunAddLog 任务执行日志
-func (app *App) RunAddLog(id int64, runId string) int64 {
+func (app *App) RunAddLog(id uint, runId string) *gorm.DB {
 	return app.Db.Create(&TaskLogRun{
 		TaskId:     id,
 		RunId:      runId,
@@ -305,39 +273,35 @@ func (app *App) RunAddLog(id int64, runId string) int64 {
 		GoVersion:  app.Version,
 		MacAddrs:   app.MacAddrS,
 		CreatedAt:  gotime.Current().Format(),
-	}).RowsAffected
-}
-
-type CronParamsResp struct {
-	ParamsOrderId
-	ParamsMerchantUserIdOpenid
-	ParamsTaskId
-	ParamsTaskIdNext
-	ParamsWechat
-	ParamsTeamInv
-	ParamsRepairMerchantAccountQuantityLevel
+	})
 }
 
 // Run 任务执行
 func (app *App) Run(info Task, status int, desc string) {
 	// 请求函数记录
-	app.Db.Create(&TaskLog{
+	statusCreate := app.Db.Create(&TaskLog{
 		TaskId:     info.Id,
 		StatusCode: status,
 		Desc:       desc,
 		Version:    app.RunVersion,
 		CreatedAt:  gotime.Current().Format(),
 	})
+	if statusCreate.RowsAffected == 0 {
+		log.Println("statusCreate", statusCreate.Error)
+	}
 	if status == 0 {
-		app.Edit(info.Id).Select("run_id").Updates(Task{
+		statusEdit := app.Edit(info.Id).Select("run_id").Updates(Task{
 			RunId: gouuid.GetUuId(),
 		})
+		if statusEdit.RowsAffected == 0 {
+			log.Println("statusEdit", statusEdit.Error)
+		}
 		return
 	}
 	// 任务
-	if status == http.StatusOK {
+	if status == CodeSuccess {
 		// 执行成功
-		app.Edit(info.Id).Select("status_desc", "number", "run_id", "updated_ip", "updated_at", "result").Updates(Task{
+		statusEdit := app.Edit(info.Id).Select("status_desc", "number", "run_id", "updated_ip", "updated_at", "result").Updates(Task{
 			StatusDesc: "执行成功",
 			Number:     info.Number + 1,
 			RunId:      gouuid.GetUuId(),
@@ -345,10 +309,13 @@ func (app *App) Run(info Task, status int, desc string) {
 			UpdatedAt:  gotime.Current().Format(),
 			Result:     desc,
 		})
+		if statusEdit.RowsAffected == 0 {
+			log.Println("statusEdit", statusEdit.Error)
+		}
 	}
-	if status == http.StatusCreated {
+	if status == CodeEnd {
 		// 执行成功、提前结束
-		app.Edit(info.Id).Select("status", "status_desc", "number", "updated_ip", "updated_at", "result").Updates(Task{
+		statusEdit := app.Edit(info.Id).Select("status", "status_desc", "number", "updated_ip", "updated_at", "result").Updates(Task{
 			Status:     TASK_SUCCESS,
 			StatusDesc: "结束执行",
 			Number:     info.Number + 1,
@@ -356,10 +323,13 @@ func (app *App) Run(info Task, status int, desc string) {
 			UpdatedAt:  gotime.Current().Format(),
 			Result:     desc,
 		})
+		if statusEdit.RowsAffected == 0 {
+			log.Println("statusEdit", statusEdit.Error)
+		}
 	}
-	if status == http.StatusInternalServerError {
+	if status == CodeError {
 		// 执行失败
-		app.Edit(info.Id).Select("status_desc", "number", "run_id", "updated_ip", "updated_at", "result").Updates(Task{
+		statusEdit := app.Edit(info.Id).Select("status_desc", "number", "run_id", "updated_ip", "updated_at", "result").Updates(Task{
 			StatusDesc: "执行失败",
 			Number:     info.Number + 1,
 			RunId:      gouuid.GetUuId(),
@@ -367,13 +337,19 @@ func (app *App) Run(info Task, status int, desc string) {
 			UpdatedAt:  gotime.Current().Format(),
 			Result:     desc,
 		})
+		if statusEdit.RowsAffected == 0 {
+			log.Println("statusEdit", statusEdit.Error)
+		}
 	}
 	if info.MaxNumber != 0 {
 		if info.Number+1 >= info.MaxNumber {
 			// 关闭执行
-			app.Edit(info.Id).Select("status").Updates(Task{
+			statusEdit := app.Edit(info.Id).Select("status").Updates(Task{
 				Status: TASK_TIMEOUT,
 			})
+			if statusEdit.RowsAffected == 0 {
+				log.Println("statusEdit", statusEdit.Error)
+			}
 		}
 	}
 }

service/jobs/model.go

@@ -1,6 +1,7 @@
 package jobs
 
 import (
+	"log"
 	"strings"
 )
 
@@ -14,24 +15,24 @@ const (
 
 // Task 任务
 type Task struct {
-	Id             int64
-	Status         string `gorm:"type:text" json:"status"`            // 状态码
-	Params         string `gorm:"type:text" json:"params"`            // 参数
-	ParamsType     string `gorm:"type:text" json:"params_type"`       // 参数类型
-	StatusDesc     string `gorm:"type:text" json:"status_desc"`       // 状态描述
-	Frequency      int64  `gorm:"type:bigint" json:"frequency"`       // 频率（秒单位）
-	Number         int64  `gorm:"type:bigint" json:"number"`          // 当前次数
-	MaxNumber      int64  `gorm:"type:bigint" json:"max_number"`      // 最大次数
-	RunId          string `gorm:"type:text" json:"run_id"`            // 执行编号
-	CustomId       string `gorm:"type:text" json:"custom_id"`         // 自定义编号
-	CustomSequence int64  `gorm:"type:bigint" json:"custom_sequence"` // 自定义顺序
-	Type           string `gorm:"type:text" json:"type"`              // 类型
-	CreatedIp      string `gorm:"type:text" json:"created_ip"`        // 创建外网IP
-	SpecifyIp      string `gorm:"type:text" json:"specify_ip"`        // 指定外网IP
-	UpdatedIp      string `gorm:"type:text" json:"updated_ip"`        // 更新外网IP
-	Result         string `gorm:"type:text" json:"result"`            // 结果
-	CreatedAt      string `gorm:"type:text" json:"created_at"`        // 创建时间
-	UpdatedAt      string `gorm:"type:text" json:"updated_at"`        // 更新时间
+	Id             uint   `gorm:"primaryKey" json:"id"`        // 记录编号
+	Status         string `json:"status"`                      // 状态码
+	Params         string `json:"params"`                      // 参数
+	ParamsType     string `json:"params_type"`                 // 参数类型
+	StatusDesc     string `json:"status_desc"`                 // 状态描述
+	Frequency      int64  `json:"frequency"`                   // 频率（秒单位）
+	Number         int64  `json:"number"`                      // 当前次数
+	MaxNumber      int64  `json:"max_number"`                  // 最大次数
+	RunId          string `json:"run_id"`                      // 执行编号
+	CustomId       string `json:"custom_id"`                   // 自定义编号
+	CustomSequence int64  `json:"custom_sequence"`             // 自定义顺序
+	Type           string `json:"type"`                        // 类型
+	CreatedIp      string `json:"created_ip"`                  // 创建外网IP
+	SpecifyIp      string `json:"specify_ip"`                  // 指定外网IP
+	UpdatedIp      string `json:"updated_ip"`                  // 更新外网IP
+	Result         string `json:"result"`                      // 结果
+	CreatedAt      string `gorm:"type:text" json:"created_at"` // 创建时间
+	UpdatedAt      string `gorm:"type:text" json:"updated_at"` // 更新时间
 }
 
 func (m *Task) TableName() string {
@@ -57,11 +58,17 @@ func (app *App) TaskCustomIdTakeStatus(Type, customId, status string) (result Ta
 }
 
 // TaskFind 查询任务
-func (app *App) TaskFind(frequency int) (results []Task) {
+func (app *App) TaskFind(frequency int64) (results []Task) {
 	app.Db.Table("task").Select("task.*").Where("task.frequency = ?", frequency).Where("task.status = ?", TASK_IN).Where("task_ip.ips = ?", app.OutsideIp).Order("task.id asc").Joins("left join task_ip on task_ip.task_type = task.type").Find(&results)
 	return app.taskFindCheck(results)
 }
 
+// TaskFindAll 查询任务
+func (app *App) TaskFindAll(frequency int64) (results []Task) {
+	app.Db.Where("frequency = ?", frequency).Where("status = ?", TASK_IN).Order("id asc").Find(&results)
+	return results
+}
+
 // 检查任务
 func (app *App) taskFindCheck(lists []Task) (results []Task) {
 	for _, v := range lists {
@@ -78,12 +85,12 @@ func (app *App) taskFindCheck(lists []Task) (results []Task) {
 
 // TaskLog 任务日志
 type TaskLog struct {
-	Id         int64
-	TaskId     int64  `gorm:"type:bigint" json:"task_id"`     // 任务编号
-	StatusCode int    `gorm:"type:bigint" json:"status_code"` // 状态码
-	Desc       string `gorm:"type:text" json:"desc"`          // 结果
-	Version    int    `gorm:"type:bigint" json:"version"`     // 版本
-	CreatedAt  string `gorm:"type:text" json:"created_at"`    // 创建时间
+	Id         uint   `gorm:"primaryKey" json:"id"`        // 记录编号
+	TaskId     uint   `json:"task_id"`                     // 任务编号
+	StatusCode int    `json:"status_code"`                 // 状态码
+	Desc       string `json:"desc"`                        // 结果
+	Version    int    `json:"version"`                     // 版本
+	CreatedAt  string `gorm:"type:text" json:"created_at"` // 创建时间
 }
 
 func (m *TaskLog) TableName() string {
@@ -92,17 +99,17 @@ func (m *TaskLog) TableName() string {
 
 // TaskLogRun 任务执行日志
 type TaskLogRun struct {
-	Id         int64
-	TaskId     int64  `gorm:"type:bigint" json:"task_id"`    // 任务编号
-	RunId      string `gorm:"type:text" json:"run_id"`       // 执行编号
-	OutsideIp  string `gorm:"type:text" json:"outside_ip"`   // 外网ip
-	InsideIp   string `gorm:"type:text" json:"inside_ip"`    // 内网ip
-	Os         string `gorm:"type:text" json:"os"`           // 系统类型
-	Arch       string `gorm:"type:text" json:"arch"`         // 系统架构
-	Gomaxprocs int    `gorm:"type:bigint" json:"gomaxprocs"` // CPU核数
-	GoVersion  string `gorm:"type:text" json:"go_version"`   // GO版本
-	MacAddrs   string `gorm:"type:text" json:"mac_addrs"`    // Mac地址
-	CreatedAt  string `gorm:"type:text" json:"created_at"`   // 创建时间
+	Id         uint   `gorm:"primaryKey" json:"id"`        // 记录编号
+	TaskId     uint   `json:"task_id"`                     // 任务编号
+	RunId      string `json:"run_id"`                      // 执行编号
+	OutsideIp  string `json:"outside_ip"`                  // 外网ip
+	InsideIp   string `json:"inside_ip"`                   // 内网ip
+	Os         string `json:"os"`                          // 系统类型
+	Arch       string `json:"arch"`                        // 系统架构
+	Gomaxprocs int    `json:"gomaxprocs"`                  // CPU核数
+	GoVersion  string `json:"go_version"`                  // GO版本
+	MacAddrs   string `json:"mac_addrs"`                   // Mac地址
+	CreatedAt  string `gorm:"type:text" json:"created_at"` // 创建时间
 }
 
 func (m *TaskLogRun) TableName() string {
@@ -110,7 +117,7 @@ func (m *TaskLogRun) TableName() string {
 }
 
 // TaskLogRunTake 查询任务执行日志
-func (app *App) TaskLogRunTake(taskId int64, runId string) (result TaskLogRun) {
+func (app *App) TaskLogRunTake(taskId uint, runId string) (result TaskLogRun) {
 	app.Db.Select("id", "os", "arch", "outside_ip", "created_at").Where("task_id = ?", taskId).Where("run_id = ?", runId).Take(&result)
 	return result
 }
@@ -118,8 +125,8 @@ func (app *App) TaskLogRunTake(taskId int64, runId string) (result TaskLogRun) {
 // TaskIp 任务Ip
 type TaskIp struct {
 	Id       int64
-	TaskType string `gorm:"type:text" json:"task_type"` // 任务编号
-	Ips      string `gorm:"type:text" json:"ips"`       // 任务IP
+	TaskType string `json:"task_type"` // 任务编号
+	Ips      string `json:"ips"`       // 任务IP
 }
 
 func (m *TaskIp) TableName() string {
@@ -132,10 +139,14 @@ func (app *App) TaskIpUpdate(taskType, ips string) int64 {
 	if query.Id != 0 {
 		return query.Id
 	}
-	return app.Db.Create(&TaskIp{
+	updateStatus := app.Db.Create(&TaskIp{
 		TaskType: taskType,
 		Ips:      ips,
-	}).RowsAffected
+	})
+	if updateStatus.RowsAffected == 0 {
+		log.Println("任务更新失败：", updateStatus.Error)
+	}
+	return updateStatus.RowsAffected
 }
 
 // TaskIpInit 实例任务ip

service/jobs/params.go

@@ -1,11 +1,5 @@
 package jobs
 
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-)
-
 var ParamsOrderType = "order"
 
 // ParamsOrderId 订单任务
@@ -15,12 +9,6 @@ type ParamsOrderId struct {
 
 var ParamsMerchantGoldenBeanType = "merchant.golden_bean"
 
-// ParamsMerchantUserIdOpenid 商家金豆任务
-type ParamsMerchantUserIdOpenid struct {
-	MerchantUserId int64  `json:"merchant_user_id,omitempty"`
-	Openid         string `json:"openid,omitempty"`
-}
-
 var ParamsNewServiceType = "new_service"
 
 // ParamsTaskId 企业自定义任务
@@ -38,131 +26,4 @@ type ParamsTaskIdNext struct {
 	MaxNumber      int   `json:"max_number,omitempty"`
 }
 
-var ParamsWechatType = "wechat"
-
-// ParamsWechat 微信任务
-type ParamsWechat struct {
-	Appid string `json:"appid,omitempty"`
-	Type  string `json:"type,omitempty"`
-}
-
 var ParamsTeamInvType = "team.inv"
-
-// ParamsTeamInv 团队邀请任务
-type ParamsTeamInv struct {
-	MerchantUserId int64  `json:"merchant_user_id,omitempty"`
-	Openid         string `json:"openid,omitempty"`
-	ShareOpenid    string `json:"share_openid,omitempty"`
-}
-
-var ParamsRepairMerchantAccountQuantityLevelType = "repair.merchant.account.quantity.level"
-
-// ParamsRepairMerchantAccountQuantityLevel 修复商家账号数量下一步任务
-type ParamsRepairMerchantAccountQuantityLevel struct {
-	Level int `json:"level,omitempty"`
-}
-
-var ParamsKashangwlType = "kashangwl"
-
-type ParamsKashangwlId struct {
-	ProductID int64 `json:"product_id"`
-}
-
-// Params 任务参数
-func Params(v Task) (response CronParamsResp, err error) {
-	switch v.ParamsType {
-	case ParamsOrderType:
-		// 订单任务
-		var resp ParamsOrderId
-		err = json.Unmarshal([]byte(v.Params), &resp)
-		if err != nil {
-			return response, errors.New(fmt.Sprintf("解析失败，%v", err))
-		}
-		if resp.OrderId == "" {
-			return response, errors.New("参数不存在")
-		}
-		response.ParamsOrderId.OrderId = resp.OrderId
-		return response, nil
-	case ParamsMerchantGoldenBeanType:
-		// 商家金豆任务
-		var resp ParamsMerchantUserIdOpenid
-		err = json.Unmarshal([]byte(v.Params), &resp)
-		if err != nil {
-			return response, errors.New(fmt.Sprintf("解析失败，%v", err))
-		}
-		if resp.MerchantUserId == 0 || resp.Openid == "" {
-			return response, errors.New("参数不存在")
-		}
-		response.ParamsMerchantUserIdOpenid.MerchantUserId = resp.MerchantUserId
-		response.ParamsMerchantUserIdOpenid.Openid = resp.Openid
-		return response, nil
-	case ParamsNewServiceType:
-		// 企业自定义任务
-		var resp ParamsTaskId
-		err = json.Unmarshal([]byte(v.Params), &resp)
-		if err != nil {
-			return response, errors.New(fmt.Sprintf("解析失败，%v", err))
-		}
-		if resp.TaskId == 0 {
-			return response, errors.New("参数不存在")
-		}
-		response.ParamsTaskId.TaskId = resp.TaskId
-		return response, nil
-	case ParamsNewServiceNextType:
-		// 企业自定义下一步任务
-		var resp ParamsTaskIdNext
-		err = json.Unmarshal([]byte(v.Params), &resp)
-		if err != nil {
-			return response, errors.New(fmt.Sprintf("解析失败，%v", err))
-		}
-		if resp.TaskId == 0 || resp.MerchantUserId == 0 || resp.CurrentNumber == 0 || resp.MaxNumber == 0 {
-			return response, errors.New("参数不存在")
-		}
-		response.ParamsTaskIdNext.TaskId = resp.TaskId
-		response.ParamsTaskIdNext.MerchantUserId = resp.MerchantUserId
-		response.ParamsTaskIdNext.CurrentNumber = resp.CurrentNumber
-		response.ParamsTaskIdNext.MaxNumber = resp.MaxNumber
-		return response, nil
-	case ParamsWechatType:
-		// 微信任务
-		var resp ParamsWechat
-		err = json.Unmarshal([]byte(v.Params), &resp)
-		if err != nil {
-			return response, errors.New(fmt.Sprintf("解析失败，%v", err))
-		}
-		if resp.Appid == "" || resp.Type == "" {
-			return response, errors.New("参数不存在")
-		}
-		response.ParamsWechat.Appid = resp.Appid
-		response.ParamsWechat.Type = resp.Type
-		return response, nil
-	case ParamsTeamInvType:
-		// 团队邀请任务
-		var resp ParamsTeamInv
-		err = json.Unmarshal([]byte(v.Params), &resp)
-		if err != nil {
-			return response, errors.New(fmt.Sprintf("解析失败，%v", err))
-		}
-		if resp.MerchantUserId == 0 || resp.Openid == "" || resp.ShareOpenid == "" {
-			return response, errors.New("参数不存在")
-		}
-		response.ParamsTeamInv.MerchantUserId = resp.MerchantUserId
-		response.ParamsTeamInv.Openid = resp.Openid
-		response.ParamsTeamInv.ShareOpenid = resp.ShareOpenid
-		return response, nil
-	case ParamsRepairMerchantAccountQuantityLevelType:
-		// 修复商家账号数量下一步任务
-		var resp ParamsRepairMerchantAccountQuantityLevel
-		err = json.Unmarshal([]byte(v.Params), &resp)
-		if err != nil {
-			return response, errors.New(fmt.Sprintf("解析失败，%v", err))
-		}
-		if resp.Level == 0 {
-			return response, errors.New("参数不存在")
-		}
-		response.ParamsRepairMerchantAccountQuantityLevel.Level = resp.Level
-		return response, nil
-	default:
-		return response, nil
-	}
-}

service/jobs/type.go

@@ -1,145 +1,9 @@
 package jobs
 
-const (
-	// 微信支付查询
-	TypeWechatPayPrepaidRefill = "wechat.pay.prepaid_refill" //【话费充值】
-	TypeWechatPayPower         = "wechat.pay.power"          //【电费充值】
-	TypeWechatPayKashangwl     = "wechat.pay.kashangwl"      //【特惠充值】
-	TypeWechatPayEastiot       = "wechat.pay.eastiot"        //【东方物联】
-	TypeWechatPayEjiaofei      = "wechat.pay.ejiaofei"       //【易缴费】
-	TypeWechatPayMovie         = "wechat.pay.movie"          //【守兔】
-
-	// 接口支付申请
-	TypeApiPaySubmitPrepaidRefill = "api.pay.submit.prepaid_refill" //【话费充值】
-	TypeApiPaySubmitPower         = "api.pay.submit.power"          //【电费充值】
-	TypeApiPaySubmitKashangwl     = "api.pay.submit.kashangwl"      //【特惠充值】
-	TypeApiPaySubmitEastiot       = "api.pay.submit.eastiot"        //【东方物联】
-	TypeApiPaySubmitEjiaofei      = "api.pay.submit.ejiaofei"       //【易缴费】
-	TypeApiPaySubmitMovie         = "api.pay.submit.movie"          //【守兔】
-
-	// 接口支付查询
-	TypeApiPayQueryPrepaidRefill = "api.pay.query.prepaid_refill" //【话费充值】
-	TypeApiPayQueryPower         = "api.pay.query.power"          //【电费充值】
-	TypeApiPayQueryKashangwl     = "api.pay.query.kashangwl"      //【特惠充值】
-	TypeApiPayQueryEastiot       = "api.pay.query.eastiot"        //【东方物联】
-	TypeApiPayQueryEjiaofei      = "api.pay.query.ejiaofei"       //【易缴费】
-	TypeApiPayQueryMovie         = "api.pay.query.movie"          //【守兔】
-	TypeApiPayQueryPinduoduo     = "api.pay.query.pinduoduo"      //【拼多多】
-	TypeApiPayQueryMeituan       = "api.pay.query.meituan"        //【美团】
-
-	// 微信支付退款申请
-	TypeWechatRefundsSubmitPrepaidRefill = "wechat.refunds.submit.prepaid_refill" //【话费充值】
-	TypeWechatRefundsSubmitPower         = "wechat.refunds.submit.power"          //【电费充值】
-	TypeWechatRefundsSubmitKashangwl     = "wechat.refunds.submit.kashangwl"      //【特惠充值】
-	TypeWechatRefundsSubmitEastiot       = "wechat.refunds.submit.eastiot"        //【东方物联】
-	TypeWechatRefundsSubmitEjiaofei      = "wechat.refunds.submit.ejiaofei"       //【易缴费】
-	TypeWechatRefundsSubmitMovie         = "wechat.refunds.submit.movie"          //【守兔】
-
-	// 微信支付退款查询
-	TypeWechatRefundsQueryPrepaidRefill = "wechat.refunds.query.prepaid_refill" //【话费充值】
-	TypeWechatRefundsQueryPower         = "wechat.refunds.query.power"          //【电费充值】
-	TypeWechatRefundsQueryKashangwl     = "wechat.refunds.query.kashangwl"      //【特惠充值】
-	TypeWechatRefundsQueryEastiot       = "wechat.refunds.query.eastiot"        //【东方物联】
-	TypeWechatRefundsQueryEjiaofei      = "wechat.refunds.query.ejiaofei"       //【易缴费】
-	TypeWechatRefundsQueryMovie         = "wechat.refunds.query.movie"          //【守兔】
-
-	// 返拥
-	TypeGoldenBeansIssuePrepaidRefill = "golden_beans.issue.prepaid_refill" //【话费充值】
-	TypeGoldenBeansIssuePower         = "golden_beans.issue.power"          //【电费充值】
-	TypeGoldenBeansIssueKashangwl     = "golden_beans.issue.kashangwl"      //【特惠充值】
-	TypeGoldenBeansIssueEastiot       = "golden_beans.issue.eastiot"        //【东方物联】
-	TypeGoldenBeansIssueMovie         = "golden_beans.issue.movie"          //【守兔】
-	TypeGoldenBeansIssueRewardedvideo = "golden_beans.issue.rewardedvideo"  //【激励视频】
-
-	// TypeGoldenBeansFrozenPinduoduo 【拼多多】冻结返拥金豆
-	TypeGoldenBeansFrozenPinduoduo = "golden_beans.frozen.pinduoduo"
-	// TypeGoldenBeansFrozenMeituan 【美团】冻结返拥金豆
-	TypeGoldenBeansFrozenMeituan = "golden_beans.frozen.meituan"
-
-	// TypeGoldenBeansThawSuccessPinduoduo 【拼多多】解冻返拥金豆正常发放
-	TypeGoldenBeansThawSuccessPinduoduo = "golden_beans.thaw.success.pinduoduo"
-	// TypeGoldenBeansThawSuccessMeituan 【美团】解冻返拥金豆正常发放
-	TypeGoldenBeansThawSuccessMeituan = "golden_beans.thaw.success.meituan"
-
-	// TypeGoldenBeansThawErrorPinduoduo 【拼多多】解冻返拥金豆扣款
-	TypeGoldenBeansThawErrorPinduoduo = "golden_beans.thaw.error.pinduoduo"
-	// TypeGoldenBeansThawErrorMeituan 【美团】解冻返拥金豆扣款
-	TypeGoldenBeansThawErrorMeituan = "golden_beans.thaw.error.meituan"
-
-	// 抵扣金豆退款
-	TypeGoldenBeansRefundsPrepaidRefill = "golden_beans.refunds.prepaid_refill" //【话费充值】
-	TypeGoldenBeansRefundsPower         = "golden_beans.refunds.power"          //【电费充值】
-
-	// 金豆退款
-	TypeGoldenBeansRefundsEjiaofei = "golden_beans.refunds.ejiaofei" //【易缴费】
-
-	// 客服进度
-	TypeCustomerAutoPrepaidRefill = "customer.auto.prepaid_refill" //【话费充值】
-	TypeCustomerAutoPower         = "customer.auto.power"          //【电费充值】
-	TypeCustomerAutoKashangwl     = "customer.auto.kashangwl"      //【特惠充值】
-	TypeCustomerAutoEjiaofei      = "customer.auto.ejiaofei"       //【易缴费】
-	TypeCustomerAutoMovie         = "customer.auto.movie"          //【守兔】
-
-	// 订单同步
-	TypeSyncOrderPinduoduo = "sync.order.pinduoduo" //【拼多多】
-	TypeSyncOrderMeituan   = "sync.order.meituan"   //【美团】
-
-	// 商品同步
-	TypeSyncGoodsEastiot              = "sync.goods.eastiot"                //【东方物联】
-	TypeSyncGoodsTypeEastiot          = "sync.goods.type.eastiot"           //【东方物联】
-	TypeSyncGoodsPriceAllKashangwl    = "sync.goods.price.all.kashangwl"    //【特惠充值】
-	TypeSyncGoodsPriceSingleKashangwl = "sync.goods.price.single.kashangwl" //【特惠充值】
-	TypeCheckGoodsAllPinduoduo        = "check.goods.all.pinduoduo"         //【拼多多】
-	TypeCheckGoodsSinglePinduoduo     = "check.goods.single.pinduoduo"      //【拼多多】
-
-	// 微信更新
-	TypeSyncWechat = "sync.wechat" //【微信】token/ticket同步
-
-	// 商家金豆转换
-	TypeGoldenBeanConversionUserGoldenBean       = "admin.golden_bean.conversion.user.golden_bean"        //【商家金豆】转用户金豆
-	TypeGoldenBeanConversionUserDeductGoldenBean = "admin.golden_bean.conversion.user.deduct.golden_bean" //【商家金豆】转用户抵扣金豆
-
-	// 企业自定义
-	TypeNewServiceAgentIssue     = "new_service.agent.issue"      //【企业自定义】【代理商】下发检查
-	TypeNewServiceAgentIssueNext = "new_service.agent.issue.next" //【企业自定义】【代理商】下发到商家
-
-	// 团队
-	TypeTeamInv = "team.inv" //【团队邀请】
-
-	// 修复商家账号数量
-	TypeRepairMerchantAccountQuantityTesting = "repair_merchant.account.quantity.testing" //【修复】【商家账号】【数量】查询出等级进行下一步
-	TypeRepairMerchantAccountQuantityLevel   = "repair_merchant.account.quantity.level"   //【修复】【商家账号】【数量】通过等级来修复
-
-	// 观察接口
-	TypeApiPayObservationPrepaidRefill    = "api.pay.observation.prepaid_refill"    //{600}【话费充值】
-	TypeApiPayObservationPower            = "api.pay.observation.power"             //{600}【电费充值】
-	TypeApiPayObservationKashangwl        = "api.pay.observation.kashangwl"         //{600}【特惠充值】
-	TypeApiPayObservationEjiaofei         = "api.pay.observation.ejiaofei"          //{600}【易缴费】
-	TypeApiPayObservationMovie            = "api.pay.observation.movie"             //{600}【守兔】
-	TypeApiPayObservationPinduoduo        = "api.pay.observation.pinduoduo"         //{600}【拼多多】
-	TypeApiPayObservationMeituan          = "api.pay.observation.meituan"           //{600}【美团】
-	TypeApiPayObservationWechat           = "api.pay.observation.wechat"            //{600}【微信支付】
-	TypeApiPayObservationWechatRefunds    = "api.pay.observation.wechat.refunds"    //{600}【微信支付退款】
-	TypeApiPayObservationWechatWithdrawal = "api.pay.observation.wechat.withdrawal" //{600}【微信支付提现】
-
-	// 微信提现
-	TypeWechatPayWithdrawalSubmit  = "wechat.pay.withdrawal.submit"  // 微信支付提现申请
-	TypeWechatPayWithdrawalQuery   = "wechat.pay.withdrawal.query"   // 微信支付提现查询
-	TypeWechatPayWithdrawalRefunds = "wechat.pay.withdrawal.refunds" // 微信支付提现退款
-)
-
-func GetTypeWechatPay(Type string) string {
-	return "wechat.pay." + Type
-}
-
 func GetTypeApiPaySubmit(Type string) string {
 	return "api.pay.submit." + Type
 }
 
-func GetTypeApiPayQuery(Type string) string {
-	return "api.pay.query." + Type
-}
-
 func GetTypeWechatRefundsSubmit(Type string) string {
 	return "wechat.refunds.submit." + Type
 }

service/kashangwl/api.buy.go

@@ -1,6 +1,9 @@
 package kashangwl
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type ApiBuyResponse struct {
 	Code    string `json:"code"`
@@ -23,13 +26,14 @@ type ApiBuyResponse struct {
 }
 
 type ApiBuyResult struct {
-	Result ApiBuyResponse // 结果
-	Body   []byte         // 内容
-	Err    error          // 错误
+	Result ApiBuyResponse     // 结果
+	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
+	Err    error              // 错误
 }
 
-func NewApiBuyResult(result ApiBuyResponse, body []byte, err error) *ApiBuyResult {
-	return &ApiBuyResult{Result: result, Body: body, Err: err}
+func NewApiBuyResult(result ApiBuyResponse, body []byte, http gorequest.Response, err error) *ApiBuyResult {
+	return &ApiBuyResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiBuy 购买商品
@@ -38,9 +42,9 @@ func (app *App) ApiBuy(notMustParams ...Params) *ApiBuyResult {
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
-	body, err := app.request("http://www.kashangwl.com/api/buy", params)
+	request, err := app.request("http://www.kashangwl.com/api/buy", params)
 	// 定义
 	var response ApiBuyResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiBuyResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiBuyResult(response, request.ResponseBody, request, err)
 }

service/kashangwl/api.customer.go

@@ -1,6 +1,9 @@
 package kashangwl
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type ApiCustomerResponse struct {
 	Code    string `json:"code"`
@@ -15,20 +18,21 @@ type ApiCustomerResponse struct {
 type ApiCustomerResult struct {
 	Result ApiCustomerResponse // 结果
 	Body   []byte              // 内容
+	Http   gorequest.Response  // 请求
 	Err    error               // 错误
 }
 
-func NewApiCustomerResult(result ApiCustomerResponse, body []byte, err error) *ApiCustomerResult {
-	return &ApiCustomerResult{Result: result, Body: body, Err: err}
+func NewApiCustomerResult(result ApiCustomerResponse, body []byte, http gorequest.Response, err error) *ApiCustomerResult {
+	return &ApiCustomerResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiCustomer 获取商家信息
 // http://doc.cqmeihu.cn/sales/merchant-info.html
 func (app *App) ApiCustomer() *ApiCustomerResult {
 	// 请求
-	body, err := app.request("http://www.kashangwl.com/api/customer", map[string]interface{}{})
+	request, err := app.request("http://www.kashangwl.com/api/customer", map[string]interface{}{})
 	// 定义
 	var response ApiCustomerResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiCustomerResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiCustomerResult(response, request.ResponseBody, request, err)
 }

service/kashangwl/api.order.go

@@ -2,6 +2,7 @@ package kashangwl
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 )
 
 type ApiOrderResponse struct {
@@ -38,13 +39,14 @@ type ApiOrderResponse struct {
 }
 
 type ApiOrderResult struct {
-	Result ApiOrderResponse // 结果
-	Body   []byte           // 内容
-	Err    error            // 错误
+	Result ApiOrderResponse   // 结果
+	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
+	Err    error              // 错误
 }
 
-func NewApiOrderResult(result ApiOrderResponse, body []byte, err error) *ApiOrderResult {
-	return &ApiOrderResult{Result: result, Body: body, Err: err}
+func NewApiOrderResult(result ApiOrderResponse, body []byte, http gorequest.Response, err error) *ApiOrderResult {
+	return &ApiOrderResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiOrder 获取单个订单信息。
@@ -56,9 +58,9 @@ func (app App) ApiOrder(orderId string) *ApiOrderResult {
 	param.Set("order_id", orderId)
 	params := app.NewParamsWith(param)
 	// 请求
-	body, err := app.request("http://www.kashangwl.com/api/order", params)
+	request, err := app.request("http://www.kashangwl.com/api/order", params)
 	// 定义
 	var response ApiOrderResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiOrderResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiOrderResult(response, request.ResponseBody, request, err)
 }

service/kashangwl/api.outer-order.go

@@ -2,6 +2,7 @@ package kashangwl
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 )
 
 type ApiOuterOrderResponse struct {
@@ -40,11 +41,12 @@ type ApiOuterOrderResponse struct {
 type ApiOuterOrderResult struct {
 	Result ApiOuterOrderResponse // 结果
 	Body   []byte                // 内容
+	Http   gorequest.Response    // 请求
 	Err    error                 // 错误
 }
 
-func NewApiOuterOrderResult(result ApiOuterOrderResponse, body []byte, err error) *ApiOuterOrderResult {
-	return &ApiOuterOrderResult{Result: result, Body: body, Err: err}
+func NewApiOuterOrderResult(result ApiOuterOrderResponse, body []byte, http gorequest.Response, err error) *ApiOuterOrderResult {
+	return &ApiOuterOrderResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiOuterOrder 使用外部订单号获取单个订单信息
@@ -56,9 +58,9 @@ func (app App) ApiOuterOrder(orderId string) *ApiOuterOrderResult {
 	param.Set("outer_order_id", orderId)
 	params := app.NewParamsWith(param)
 	// 请求
-	body, err := app.request("http://www.kashangwl.com/api/outer-order", params)
+	request, err := app.request("http://www.kashangwl.com/api/outer-order", params)
 	// 定义
 	var response ApiOuterOrderResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiOuterOrderResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiOuterOrderResult(response, request.ResponseBody, request, err)
 }

service/kashangwl/api.product.go

@@ -1,6 +1,9 @@
 package kashangwl
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type ApiProductResponse struct {
 	Code    string `json:"code"`
@@ -23,11 +26,12 @@ type ApiProductResponse struct {
 type ApiProductResult struct {
 	Result ApiProductResponse // 结果
 	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
 	Err    error              // 错误
 }
 
-func NewApiProductResult(result ApiProductResponse, body []byte, err error) *ApiProductResult {
-	return &ApiProductResult{Result: result, Body: body, Err: err}
+func NewApiProductResult(result ApiProductResponse, body []byte, http gorequest.Response, err error) *ApiProductResult {
+	return &ApiProductResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiProduct 获取单个商品信息
@@ -37,9 +41,9 @@ func (app App) ApiProduct(productId int64) *ApiProductResult {
 	params := NewParams()
 	params.Set("product_id", productId)
 	// 请求
-	body, err := app.request("http://www.kashangwl.com/api/product", params)
+	request, err := app.request("http://www.kashangwl.com/api/product", params)
 	// 定义
 	var response ApiProductResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiProductResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiProductResult(response, request.ResponseBody, request, err)
 }

service/kashangwl/api.product.recharge-params.go

@@ -1,6 +1,9 @@
 package kashangwl
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
+)
 
 type ApiProductRechargeParamsResponse struct {
 	Code    string `json:"code"`
@@ -18,11 +21,12 @@ type ApiProductRechargeParamsResponse struct {
 type ApiProductRechargeParamsResult struct {
 	Result ApiProductRechargeParamsResponse // 结果
 	Body   []byte                           // 内容
+	Http   gorequest.Response               // 请求
 	Err    error                            // 错误
 }
 
-func NewApiProductRechargeParamsResult(result ApiProductRechargeParamsResponse, body []byte, err error) *ApiProductRechargeParamsResult {
-	return &ApiProductRechargeParamsResult{Result: result, Body: body, Err: err}
+func NewApiProductRechargeParamsResult(result ApiProductRechargeParamsResponse, body []byte, http gorequest.Response, err error) *ApiProductRechargeParamsResult {
+	return &ApiProductRechargeParamsResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiProductRechargeParams 接口说明
@@ -32,9 +36,9 @@ func (app App) ApiProductRechargeParams(notMustParams ...Params) *ApiProductRech
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
-	body, err := app.request("http://www.kashangwl.com/api/product/recharge-params", params)
+	request, err := app.request("http://www.kashangwl.com/api/product/recharge-params", params)
 	// 定义
 	var response ApiProductRechargeParamsResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiProductRechargeParamsResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiProductRechargeParamsResult(response, request.ResponseBody, request, err)
 }

service/kashangwl/app.go

@@ -1,31 +1,69 @@
 package kashangwl
 
 import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gomongo"
-	"net/http"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
 	"time"
 )
 
 // App 卡商网服务
 type App struct {
-	CustomerId  int         // 商家编号
-	CustomerKey string      // 商家密钥
-	Mongo       gomongo.App // 日志数据库
+	customerId   int            // 商家编号
+	customerKey  string         // 商家密钥
+	pgsql        *gorm.DB       // pgsql数据库
+	client       *gorequest.App // 请求客户端
+	log          *golog.Api     // 日志服务
+	logTableName string         // 日志表名
+	logStatus    bool           // 日志状态
 }
 
-func (app *App) request(url string, params map[string]interface{}) ([]byte, error) {
+func NewApp(customerId int, customerKey string, pgsql *gorm.DB) *App {
+	app := &App{customerId: customerId, customerKey: customerKey}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "kashangwl"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
+	}
+	return app
+}
+
+func (app *App) request(url string, params map[string]interface{}) (resp gorequest.Response, err error) {
+
 	// 公共参数
 	params["timestamp"] = time.Now().UnixNano() / 1e6
-	params["customer_id"] = app.CustomerId
+	params["customer_id"] = app.customerId
+
 	// 签名参数
-	params["sign"] = app.getSign(app.CustomerKey, params)
-	// 请求参数
-	paramsStr, err := json.Marshal(params)
-	// 请求
-	postJson, err := gohttp.PostJson(url, paramsStr)
+	params["sign"] = app.getSign(app.customerKey, params)
+
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置格式
+	client.SetContentTypeJson()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Post()
+	if err != nil {
+		return gorequest.Response{}, err
+	}
+
 	// 日志
-	go app.mongoLog(url, params, http.MethodPost, postJson)
-	return postJson.Body, err
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
 }

service/kashangwl/mongodb.go

@@ -1,47 +0,0 @@
-package kashangwl
-
-import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "kashangwl_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	var body map[string]interface{}
-	_ = json.Unmarshal(request.Body, &body)
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          body,
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}

service/kashangwl/pgsql.go

@@ -0,0 +1,26 @@
+package kashangwl
+
+import (
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"go.dtapp.net/library/utils/gojson"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
+	})
+}

service/kashangwl/sign.go

@@ -5,7 +5,7 @@ import (
 	"crypto/md5"
 	"encoding/hex"
 	"encoding/json"
-	"go.dtapp.net/library/utils/goparams"
+	"go.dtapp.net/library/utils/gorequest"
 	"io"
 	"net/url"
 	"sort"
@@ -25,7 +25,7 @@ func (app *App) getSign(customerKey string, params map[string]interface{}) strin
 	query := bytes.NewBufferString(customerKey)
 	for _, k := range keys {
 		query.WriteString(k)
-		query.WriteString(goparams.GetParamsString(params[k]))
+		query.WriteString(gorequest.GetParamsString(params[k]))
 	}
 	// MD5加密
 	h := md5.New()

service/kuaishou/api.go

@@ -0,0 +1,64 @@
+package kuaishou
+
+import (
+	"errors"
+	"github.com/mvdan/xurls"
+	"strings"
+)
+
+type AnalysisResponse struct {
+	VideoLink     string   `json:"video_link"`
+	ImageLinkList []string `json:"image_link_list"`
+}
+
+type AnalysisResult struct {
+	Result AnalysisResponse // 结果
+	Err    error            // 错误
+}
+
+func NewAnalysisResult(result AnalysisResponse, err error) *AnalysisResult {
+	return &AnalysisResult{Result: result, Err: err}
+}
+
+// Analysis 快手解析
+func (app *App) Analysis(content string) *AnalysisResult {
+
+	// 定义
+	var response AnalysisResponse
+
+	// 提取url
+	var url string
+	if strings.Contains(content, "kuaishou.com") {
+		url = xurls.Relaxed.FindString(content)
+	} else if strings.Contains(content, "gifshow.com") {
+		url = xurls.Relaxed.FindString(content)
+	} else {
+		return NewAnalysisResult(response, errors.New("url为空"))
+	}
+
+	// 获取重定向链接
+	result := app.GetVideoLink(url)
+	if result.Err != nil {
+		return NewAnalysisResult(response, result.Err)
+	}
+
+	// 获取重定向内容
+	html, err := app.GetVideoHtml(result.Link, result.Cookies)
+	if err != nil {
+		return NewAnalysisResult(response, result.Err)
+	}
+
+	// 判断
+	imageLinks := app.ExtractImageLink(html)
+	videoLink := app.ExtractVideoLink(html)
+
+	// 0 是视频，1是图集
+	if len(imageLinks) > 0 {
+		response.ImageLinkList = imageLinks
+
+	} else if len(videoLink) > 0 {
+		response.VideoLink = videoLink
+	}
+
+	return NewAnalysisResult(response, err)
+}

service/kuaishou/app.go

@@ -0,0 +1,33 @@
+package kuaishou
+
+import (
+	"go.dtapp.net/golog"
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
+)
+
+type App struct {
+	ua           string
+	mongo        *gomongo.Client // 日志数据库
+	pgsql        *gorm.DB        // pgsql数据库
+	client       *gorequest.App  // 请求客户端
+	log          *golog.Api      // 日志服务
+	logTableName string          // 日志表名
+	logStatus    bool            // 日志状态
+}
+
+func NewApp(pgsql *gorm.DB) *App {
+	app := &App{ua: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.131 Safari/537.36"}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "kuaishou"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
+	}
+	return app
+}

service/kuaishou/extract_image_link.go

@@ -0,0 +1,22 @@
+package kuaishou
+
+import "regexp"
+
+func (app *App) ExtractImageLink(content string) []string {
+
+	//解析正则表达式，如果成功返回解释器
+	reg := regexp.MustCompile(`\{"path":"(.*?)","width":\d+,"height":\d*}`)
+
+	//根据规则提取关键信息
+	result := reg.FindAllStringSubmatch(content, -1)
+	var imageLinks []string
+
+	if len(result) > 0 {
+		for _, link := range result {
+			imageLinks = append(imageLinks, "https://tx2.a.yximgs.com"+link[1])
+		}
+
+	}
+
+	return imageLinks
+}

service/kuaishou/extract_video_link.go

@@ -0,0 +1,20 @@
+package kuaishou
+
+import "regexp"
+
+func (app *App) ExtractVideoLink(content string) string {
+
+	//解析正则表达式，如果成功返回解释器
+	reg := regexp.MustCompile(`"srcNoMark":"(.*?)"`)
+
+	//根据规则提取关键信息
+	result := reg.FindAllStringSubmatch(content, -1)
+	var videoLink string
+
+	if len(result) > 0 {
+		videoLink = result[0][1]
+		return videoLink
+	}
+
+	return ""
+}

service/kuaishou/get_video_html.go

@@ -0,0 +1,37 @@
+package kuaishou
+
+import (
+	"io/ioutil"
+	"log"
+	"net/http"
+)
+
+func (app *App) GetVideoHtml(url string, cookieStr string) (string, error) {
+
+	client := &http.Client{}
+	request, err := http.NewRequest("GET", url, nil)
+
+	request.Header.Add("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1")
+	request.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9")
+	request.Header.Add("Accept-Language", "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3")
+	// request.Header.Add("Host", "c.kuaishou.com")
+	request.Header.Add("Cookie", cookieStr)
+
+	if err != nil {
+		log.Fatal(err)
+		return "", err
+	}
+
+	response, _ := client.Do(request)
+
+	body, err := ioutil.ReadAll(response.Body)
+
+	if err != nil {
+		log.Fatal(err)
+		return "", nil
+	}
+
+	defer response.Body.Close()
+
+	return string(body), nil
+}

service/kuaishou/get_video_link.go

@@ -0,0 +1,63 @@
+package kuaishou
+
+import (
+	"errors"
+	"log"
+	"net/http"
+	"net/http/cookiejar"
+	"strings"
+)
+
+type Response struct {
+	Link    string
+	Cookies string
+	Err     error
+}
+
+func (app *App) GetVideoLink(url string) Response {
+
+	result := Response{}
+
+	jar, err := cookiejar.New(&cookiejar.Options{})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	client := &http.Client{
+		Jar: jar,
+	}
+	request, err := http.NewRequest("GET", url, nil)
+
+	request.Header.Add("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1")
+	request.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9")
+	request.Header.Add("Accept-Language", "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3")
+	// request.Header.Add("Host", "c.kuaishou.com")
+	// request.Header.Add("Host", "v.kuaishouapp.com")
+
+	result.Err = err
+	var cookieList []string
+
+	client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+
+		if len(via) > 10 {
+			return errors.New("too many redirects")
+		}
+
+		result.Link = req.URL.String()
+
+		return nil
+	}
+
+	response, _ := client.Do(request)
+
+	cookies := jar.Cookies(request.URL)
+	for _, cookie := range cookies {
+		cookieList = append(cookieList, cookie.String())
+	}
+
+	result.Cookies = strings.Join(cookieList, ";")
+
+	defer response.Body.Close()
+
+	return result
+}

service/kuaishou/mongo.go

@@ -0,0 +1,48 @@
+package kuaishou
+
+import (
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gorequest"
+	"net/http"
+)
+
+// 日志
+type mongoZap struct {
+	RequestTime           gomongo.BsonTime       `json:"request_time" bson:"request_time"`                       //【请求】时间
+	RequestUri            string                 `json:"request_uri" bson:"request_uri"`                         //【请求】链接
+	RequestUrl            string                 `json:"request_url" bson:"request_url"`                         //【请求】链接
+	RequestApi            string                 `json:"request_api" bson:"request_api"`                         //【请求】接口
+	RequestMethod         string                 `json:"request_method" bson:"request_method"`                   //【请求】方式
+	RequestParams         gorequest.Params       `json:"request_params" bson:"request_params"`                   //【请求】参数
+	RequestHeader         gorequest.Headers      `json:"request_header" bson:"request_header"`                   //【请求】头部
+	ResponseHeader        http.Header            `json:"response_header" bson:"response_header"`                 //【返回】头部
+	ResponseStatusCode    int                    `json:"response_status_code" bson:"response_status_code"`       //【返回】状态码
+	ResponseBody          map[string]interface{} `json:"response_body" bson:"response_body"`                     //【返回】内容
+	ResponseContentLength int64                  `json:"response_content_length" bson:"response_content_length"` //【返回】大小
+	ResponseTime          gomongo.BsonTime       `json:"response_time" bson:"response_time"`                     //【返回】时间
+}
+
+func (m *mongoZap) Database() string {
+	return "zap_log"
+}
+
+func (m *mongoZap) TableName() string {
+	return "kuaishou"
+}
+
+func (app *App) mongoLog(request gorequest.Response) {
+	_, _ = app.mongo.Model(&mongoZap{}).InsertOne(mongoZap{
+		RequestTime:           gomongo.BsonTime(request.RequestTime),           //【请求】时间
+		RequestUri:            request.RequestUri,                              //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,      //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,     //【请求】接口
+		RequestMethod:         request.RequestMethod,                           //【请求】方式
+		RequestParams:         request.RequestParams,                           //【请求】参数
+		RequestHeader:         request.RequestHeader,                           //【请求】头部
+		ResponseHeader:        request.ResponseHeader,                          //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                      //【返回】状态码
+		ResponseBody:          gomongo.JsonDecodeNoError(request.ResponseBody), //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                   //【返回】大小
+		ResponseTime:          gomongo.BsonTime(request.ResponseTime),          //【返回】时间
+	})
+}

service/kuaishou/pgsql.go

@@ -0,0 +1,26 @@
+package kuaishou
+
+import (
+	"go.dtapp.net/gojson"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Record(golog.ApiPostgresqlLog{
+		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
+	})
+}

service/leshuazf/apiv2.merchant.updateAuthority.go

@@ -2,6 +2,7 @@ package leshuazf
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -11,11 +12,12 @@ type ApiV2MerchantUpdateAuthorityResponse struct {
 type ApiV2MerchantUpdateAuthorityResult struct {
 	Result ApiV2MerchantUpdateAuthorityResponse // 结果
 	Body   []byte                               // 内容
+	Http   gorequest.Response                   // 请求
 	Err    error                                // 错误
 }
 
-func NewApiV2MerchantUpdateAuthorityResult(result ApiV2MerchantUpdateAuthorityResponse, body []byte, err error) *ApiV2MerchantUpdateAuthorityResult {
-	return &ApiV2MerchantUpdateAuthorityResult{Result: result, Body: body, Err: err}
+func NewApiV2MerchantUpdateAuthorityResult(result ApiV2MerchantUpdateAuthorityResponse, body []byte, http gorequest.Response, err error) *ApiV2MerchantUpdateAuthorityResult {
+	return &ApiV2MerchantUpdateAuthorityResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiV2MerchantUpdateAuthority 给商户开通D0交易/结算权限接口。其中D0交易影响交易接口内t0字段能否标1，D0结算影响商户该种支付方式的秒到
@@ -24,9 +26,9 @@ func (app *App) ApiV2MerchantUpdateAuthority(notMustParams ...Params) *ApiV2Merc
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
-	body, err := app.request("apiv2/merchant/updateAuthority", params, http.MethodPost)
+	request, err := app.request("apiv2/merchant/updateAuthority", params, http.MethodPost)
 	// 定义
 	var response ApiV2MerchantUpdateAuthorityResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiV2MerchantUpdateAuthorityResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiV2MerchantUpdateAuthorityResult(response, request.ResponseBody, request, err)
 }

service/leshuazf/app.go

@@ -1,51 +1,82 @@
 package leshuazf
 
 import (
-	"errors"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gomongo"
-	"go.dtapp.net/library/utils/gopostgresql"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gorequest"
 	"go.dtapp.net/library/utils/gorandom"
 	"go.dtapp.net/library/utils/gotime"
-	"log"
-	"net/http"
+	"gorm.io/gorm"
 )
 
 // App 乐刷
 type App struct {
-	AgentId     string // 服务商编号，由乐刷分配的接入方唯一标识，明文传输。
-	Environment string //  环境
-	KeyAgent    string
-	Pgsql       gopostgresql.App // 日志数据库
-	Mongo       gomongo.App      // 日志数据库
+	agentId      string // 服务商编号，由乐刷分配的接入方唯一标识，明文传输。
+	Environment  string //  环境
+	KeyAgent     string
+	mongo        *gomongo.Client // 日志数据库
+	pgsql        *gorm.DB        // pgsql数据库
+	client       *gorequest.App  // 请求客户端
+	log          *golog.Client   // 日志服务
+	logTableName string          // 日志表名
+	logStatus    bool            // 日志状态
 }
 
-func (app *App) request(url string, params map[string]interface{}, method string) (resp []byte, err error) {
+func NewApp(agentId string, environment string, keyAgent string, pgsql *gorm.DB) *App {
+	app := &App{agentId: agentId, Environment: environment, KeyAgent: keyAgent}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "leshuazf"
+		app.log = golog.NewClientApi(pgsql, app.logTableName)
+	}
+	return app
+}
+
+func (app *App) request(url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
+
 	// 环境
 	if app.Environment == "test" {
 		url = "http://t-saas-mch.lepass.cn/" + url
 	} else {
 		url = "https://saas-mch.leshuazf.com/" + url
 	}
+
 	// 参数
-	params["agentId"] = app.AgentId                                                            // 服务商编号，由乐刷分配的接入方唯一标识，明文传输。
+	params["agentId"] = app.agentId                                                            // 服务商编号，由乐刷分配的接入方唯一标识，明文传输。
 	params["version"] = "2.0"                                                                  // 目前固定值2.0
 	params["reqSerialNo"] = gotime.Current().SetFormat("20060102150405") + gorandom.Numeric(5) // 请求流水号(yyyyMMddHHmmssSSSXXXXX，其中 XXXXX为5位顺序号,禁止使用UUID等无意义数据)
 	params["sign"] = app.getSign(params)
 
-	log.Println(app)
-	log.Println(url)
-	log.Println(params)
-
-	switch method {
-	case http.MethodGet:
-		// 请求
-		get, err := gohttp.Get(url, params)
-		return get.Body, err
-	case http.MethodPost:
-		postJson, err := gohttp.PostForm(url, params)
-		return postJson.Body, err
-	default:
-		return nil, errors.New("请求类型不支持")
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置方式
+	client.SetMethod(method)
+
+	// 设置格式
+	client.SetContentTypeForm()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Request()
+	if err != nil {
+		return gorequest.Response{}, err
 	}
+
+	// 日志
+	if app.mongo != nil && app.mongo.Db != nil {
+		go app.mongoLog(request)
+	}
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
 }

service/leshuazf/data.area.go

@@ -2,6 +2,7 @@ package leshuazf
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -17,13 +18,14 @@ type DataAreaResponse struct {
 }
 
 type DataAreaResult struct {
-	Result DataAreaResponse // 结果
-	Body   []byte           // 内容
-	Err    error            // 错误
+	Result DataAreaResponse   // 结果
+	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
+	Err    error              // 错误
 }
 
-func NewDataAreaResult(result DataAreaResponse, body []byte, err error) *DataAreaResult {
-	return &DataAreaResult{Result: result, Body: body, Err: err}
+func NewDataAreaResult(result DataAreaResponse, body []byte, http gorequest.Response, err error) *DataAreaResult {
+	return &DataAreaResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // DataArea 代理商通过地区信息来查地区详细信息
@@ -32,9 +34,9 @@ func (app *App) DataArea(notMustParams ...Params) *DataAreaResult {
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
-	body, err := app.request("data/area", params, http.MethodPost)
+	request, err := app.request("data/area", params, http.MethodPost)
 	// 定义
 	var response DataAreaResponse
-	err = json.Unmarshal(body, &response)
-	return NewDataAreaResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewDataAreaResult(response, request.ResponseBody, request, err)
 }

service/leshuazf/data.bankbranch2.go

@@ -2,6 +2,7 @@ package leshuazf
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -32,11 +33,12 @@ type DataBankBranch2Response struct {
 type DataBankBranch2Result struct {
 	Result DataBankBranch2Response // 结果
 	Body   []byte                  // 内容
+	Http   gorequest.Response      // 请求
 	Err    error                   // 错误
 }
 
-func NewDataBankBranch2Result(result DataBankBranch2Response, body []byte, err error) *DataBankBranch2Result {
-	return &DataBankBranch2Result{Result: result, Body: body, Err: err}
+func NewDataBankBranch2Result(result DataBankBranch2Response, body []byte, http gorequest.Response, err error) *DataBankBranch2Result {
+	return &DataBankBranch2Result{Result: result, Body: body, Http: http, Err: err}
 }
 
 // DataBankBranch2 代理商通过联行号来查支行信息
@@ -45,9 +47,9 @@ func (app *App) DataBankBranch2(notMustParams ...Params) *DataBankBranch2Result
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
-	body, err := app.request("data/bankbranch2", params, http.MethodPost)
+	request, err := app.request("data/bankbranch2", params, http.MethodPost)
 	// 定义
 	var response DataBankBranch2Response
-	err = json.Unmarshal(body, &response)
-	return NewDataBankBranch2Result(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewDataBankBranch2Result(response, request.ResponseBody, request, err)
 }

service/leshuazf/data.mcc.go

@@ -2,6 +2,7 @@ package leshuazf
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -16,13 +17,14 @@ type DataMccResponse struct {
 }
 
 type DataMccResult struct {
-	Result DataMccResponse // 结果
-	Body   []byte          // 内容
-	Err    error           // 错误
+	Result DataMccResponse    // 结果
+	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
+	Err    error              // 错误
 }
 
-func NewDataMccResult(result DataMccResponse, body []byte, err error) *DataMccResult {
-	return &DataMccResult{Result: result, Body: body, Err: err}
+func NewDataMccResult(result DataMccResponse, body []byte, http gorequest.Response, err error) *DataMccResult {
+	return &DataMccResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // DataMcc 代理商通过MccCode来查商户类别明细
@@ -31,9 +33,9 @@ func (app *App) DataMcc(notMustParams ...Params) *DataMccResult {
 	// 参数
 	params := app.NewParamsWith(notMustParams...)
 	// 请求
-	body, err := app.request("data/mcc", params, http.MethodPost)
+	request, err := app.request("data/mcc", params, http.MethodPost)
 	// 定义
 	var response DataMccResponse
-	err = json.Unmarshal(body, &response)
-	return NewDataMccResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewDataMccResult(response, request.ResponseBody, request, err)
 }

service/leshuazf/mongo.go

@@ -0,0 +1,48 @@
+package leshuazf
+
+import (
+	"go.dtapp.net/gomongo"
+	"go.dtapp.net/library/utils/gorequest"
+	"net/http"
+)
+
+// 日志
+type mongoZap struct {
+	RequestTime           gomongo.BsonTime       `json:"request_time" bson:"request_time"`                       //【请求】时间
+	RequestUri            string                 `json:"request_uri" bson:"request_uri"`                         //【请求】链接
+	RequestUrl            string                 `json:"request_url" bson:"request_url"`                         //【请求】链接
+	RequestApi            string                 `json:"request_api" bson:"request_api"`                         //【请求】接口
+	RequestMethod         string                 `json:"request_method" bson:"request_method"`                   //【请求】方式
+	RequestParams         gorequest.Params       `json:"request_params" bson:"request_params"`                   //【请求】参数
+	RequestHeader         gorequest.Headers      `json:"request_header" bson:"request_header"`                   //【请求】头部
+	ResponseHeader        http.Header            `json:"response_header" bson:"response_header"`                 //【返回】头部
+	ResponseStatusCode    int                    `json:"response_status_code" bson:"response_status_code"`       //【返回】状态码
+	ResponseBody          map[string]interface{} `json:"response_body" bson:"response_body"`                     //【返回】内容
+	ResponseContentLength int64                  `json:"response_content_length" bson:"response_content_length"` //【返回】大小
+	ResponseTime          gomongo.BsonTime       `json:"response_time" bson:"response_time"`                     //【返回】时间
+}
+
+func (m *mongoZap) Database() string {
+	return "zap_log"
+}
+
+func (m *mongoZap) TableName() string {
+	return "leshuazf"
+}
+
+func (app *App) mongoLog(request gorequest.Response) {
+	_, _ = app.mongo.Model(&mongoZap{}).InsertOne(mongoZap{
+		RequestTime:           gomongo.BsonTime(request.RequestTime),           //【请求】时间
+		RequestUri:            request.RequestUri,                              //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,      //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,     //【请求】接口
+		RequestMethod:         request.RequestMethod,                           //【请求】方式
+		RequestParams:         request.RequestParams,                           //【请求】参数
+		RequestHeader:         request.RequestHeader,                           //【请求】头部
+		ResponseHeader:        request.ResponseHeader,                          //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                      //【返回】状态码
+		ResponseBody:          gomongo.JsonDecodeNoError(request.ResponseBody), //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                   //【返回】大小
+		ResponseTime:          gomongo.BsonTime(request.ResponseTime),          //【返回】时间
+	})
+}

service/leshuazf/mongodb.go

@@ -1,47 +0,0 @@
-package leshuazf
-
-import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "leshuazf_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	var body map[string]interface{}
-	_ = json.Unmarshal(request.Body, &body)
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          body,
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}

service/leshuazf/pgsql.go

@@ -0,0 +1,26 @@
+package leshuazf
+
+import (
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gojson"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/datatypes"
+)
+
+// 记录日志
+func (app *App) postgresqlLog(request gorequest.Response) {
+	app.log.Api.Record(golog.ApiPostgresqlLog{
+		RequestTime:           request.RequestTime,                                              //【请求】时间
+		RequestUri:            request.RequestUri,                                               //【请求】链接
+		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
+		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
+		RequestMethod:         request.RequestMethod,                                            //【请求】方式
+		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
+		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
+		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
+		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
+		ResponseBody:          request.ResponseBody,                                             //【返回】内容
+		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
+		ResponseTime:          request.ResponseTime,                                             //【返回】时间
+	})
+}

service/meituan/api.generate_link.go

@@ -2,6 +2,7 @@ package meituan
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -14,30 +15,31 @@ type ApiGenerateLinkResponse struct {
 type ApiGenerateLinkResult struct {
 	Result ApiGenerateLinkResponse // 结果
 	Body   []byte                  // 内容
+	Http   gorequest.Response      // 请求
 	Err    error                   // 错误
 }
 
-func NewApiGenerateLinkResult(result ApiGenerateLinkResponse, body []byte, err error) *ApiGenerateLinkResult {
-	return &ApiGenerateLinkResult{Result: result, Body: body, Err: err}
+func NewApiGenerateLinkResult(result ApiGenerateLinkResponse, body []byte, http gorequest.Response, err error) *ApiGenerateLinkResult {
+	return &ApiGenerateLinkResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiGenerateLink 自助取链接口（新版）
 // https://union.meituan.com/v2/apiDetail?id=25
 func (app *App) ApiGenerateLink(actId int64, sid string, linkType, shortLink int) *ApiGenerateLinkResult {
 	// 参数
-	param := NewParams()
+	param := gorequest.NewParams()
 	param.Set("actId", actId)         // 活动id，可以在联盟活动列表中查看获取
-	param.Set("appkey", app.AppKey)   // 媒体名称，可在推广者备案-媒体管理中查询
+	param.Set("appkey", app.appKey)   // 媒体名称，可在推广者备案-媒体管理中查询
 	param.Set("sid", sid)             // 推广位sid，支持通过接口自定义创建，不受平台200个上限限制，长度不能超过64个字符，支持小写字母和数字，历史已创建的推广位不受这个约束
 	param.Set("linkType", linkType)   // 投放链接的类型
 	param.Set("shortLink", shortLink) // 获取长链还是短链
 	// 转换
-	params := app.NewParamsWith(param)
-	params["sign"] = app.getSign(app.Secret, params)
+	params := gorequest.NewParamsWith(param)
+	params["sign"] = app.getSign(app.secret, params)
 	// 请求
-	body, err := app.request("https://openapi.meituan.com/api/generateLink", params, http.MethodGet)
+	request, err := app.request("https://openapi.meituan.com/api/generateLink", params, http.MethodGet)
 	// 定义
 	var response ApiGenerateLinkResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiGenerateLinkResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiGenerateLinkResult(response, request.ResponseBody, request, err)
 }

service/meituan/api.getqualityscorebysid.go

@@ -2,6 +2,7 @@ package meituan
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"go.dtapp.net/library/utils/gotime"
 	"net/http"
 )
@@ -23,26 +24,27 @@ type ApiGetQuaLitYsCoreBySidResponse struct {
 type ApiGetQuaLitYsCoreBySidResult struct {
 	Result ApiGetQuaLitYsCoreBySidResponse // 结果
 	Body   []byte                          // 内容
+	Http   gorequest.Response              // 请求
 	Err    error                           // 错误
 }
 
-func NewApiGetQuaLitYsCoreBySidResult(result ApiGetQuaLitYsCoreBySidResponse, body []byte, err error) *ApiGetQuaLitYsCoreBySidResult {
-	return &ApiGetQuaLitYsCoreBySidResult{Result: result, Body: body, Err: err}
+func NewApiGetQuaLitYsCoreBySidResult(result ApiGetQuaLitYsCoreBySidResponse, body []byte, http gorequest.Response, err error) *ApiGetQuaLitYsCoreBySidResult {
+	return &ApiGetQuaLitYsCoreBySidResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiGetQuaLitYsCoreBySid 优选sid质量分&复购率查询
 // https://union.meituan.com/v2/apiDetail?id=28
-func (app *App) ApiGetQuaLitYsCoreBySid(notMustParams ...Params) *ApiGetQuaLitYsCoreBySidResult {
+func (app *App) ApiGetQuaLitYsCoreBySid(notMustParams ...gorequest.Params) *ApiGetQuaLitYsCoreBySidResult {
 	// 参数
-	params := app.NewParamsWith(notMustParams...)
+	params := gorequest.NewParamsWith(notMustParams...)
 	// 请求时刻10位时间戳(秒级)，有效期60s
 	params["ts"] = gotime.Current().Timestamp()
-	params["appkey"] = app.AppKey
-	params["sign"] = app.getSign(app.Secret, params)
+	params["appkey"] = app.appKey
+	params["sign"] = app.getSign(app.secret, params)
 	// 请求
-	body, err := app.request("https://openapi.meituan.com/api/getqualityscorebysid", params, http.MethodGet)
+	request, err := app.request("https://openapi.meituan.com/api/getqualityscorebysid", params, http.MethodGet)
 	// 定义
 	var response ApiGetQuaLitYsCoreBySidResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiGetQuaLitYsCoreBySidResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiGetQuaLitYsCoreBySidResult(response, request.ResponseBody, request, err)
 }

service/meituan/api.mini_code.go

@@ -2,6 +2,7 @@ package meituan
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -14,28 +15,29 @@ type ApiMiniCodeResponse struct {
 type ApiMiniCodeResult struct {
 	Result ApiMiniCodeResponse // 结果
 	Body   []byte              // 内容
+	Http   gorequest.Response  // 请求
 	Err    error               // 错误
 }
 
-func NewApiMiniCodeResult(result ApiMiniCodeResponse, body []byte, err error) *ApiMiniCodeResult {
-	return &ApiMiniCodeResult{Result: result, Body: body, Err: err}
+func NewApiMiniCodeResult(result ApiMiniCodeResponse, body []byte, http gorequest.Response, err error) *ApiMiniCodeResult {
+	return &ApiMiniCodeResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiMiniCode 小程序生成二维码（新版）
 // https://union.meituan.com/v2/apiDetail?id=26
 func (app *App) ApiMiniCode(actId int64, sid string) *ApiMiniCodeResult {
 	// 参数
-	param := NewParams()
-	param.Set("appkey", app.AppKey)
+	param := gorequest.NewParams()
+	param.Set("appkey", app.appKey)
 	param.Set("sid", sid)
 	param.Set("actId", actId)
 	// 转换
-	params := app.NewParamsWith(param)
-	params["sign"] = app.getSign(app.Secret, params)
+	params := gorequest.NewParamsWith(param)
+	params["sign"] = app.getSign(app.secret, params)
 	// 请求
-	body, err := app.request("https://openapi.meituan.com/api/miniCode", params, http.MethodGet)
+	request, err := app.request("https://openapi.meituan.com/api/miniCode", params, http.MethodGet)
 	// 定义
 	var response ApiMiniCodeResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiMiniCodeResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiMiniCodeResult(response, request.ResponseBody, request, err)
 }

service/meituan/api.order.go

@@ -2,6 +2,7 @@ package meituan
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"net/http"
 )
 
@@ -34,27 +35,28 @@ type ApiOrderResponse struct {
 }
 
 type ApiOrderResult struct {
-	Result ApiOrderResponse // 结果
-	Body   []byte           // 内容
-	Err    error            // 错误
+	Result ApiOrderResponse   // 结果
+	Body   []byte             // 内容
+	Http   gorequest.Response // 请求
+	Err    error              // 错误
 }
 
-func NewApiOrderResult(result ApiOrderResponse, body []byte, err error) *ApiOrderResult {
-	return &ApiOrderResult{Result: result, Body: body, Err: err}
+func NewApiOrderResult(result ApiOrderResponse, body []byte, http gorequest.Response, err error) *ApiOrderResult {
+	return &ApiOrderResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiOrder 单订单查询接口（新版）
 // https://union.meituan.com/v2/apiDetail?id=24
-func (app *App) ApiOrder(notMustParams ...Params) *ApiOrderResult {
+func (app *App) ApiOrder(notMustParams ...gorequest.Params) *ApiOrderResult {
 	// 参数
-	params := app.NewParamsWith(notMustParams...)
+	params := gorequest.NewParamsWith(notMustParams...)
 	// 请求时刻10位时间戳(秒级)，有效期60s
-	params["appkey"] = app.AppKey
-	params["sign"] = app.getSign(app.Secret, params)
+	params["appkey"] = app.appKey
+	params["sign"] = app.getSign(app.secret, params)
 	// 请求
-	body, err := app.request("https://openapi.meituan.com/api/order", params, http.MethodGet)
+	request, err := app.request("https://openapi.meituan.com/api/order", params, http.MethodGet)
 	// 定义
 	var response ApiOrderResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiOrderResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiOrderResult(response, request.ResponseBody, request, err)
 }

service/meituan/api.order_list.go

@@ -2,6 +2,7 @@ package meituan
 
 import (
 	"encoding/json"
+	"go.dtapp.net/library/utils/gorequest"
 	"go.dtapp.net/library/utils/gotime"
 	"net/http"
 )
@@ -35,26 +36,27 @@ type ApiOrderListResponse struct {
 type ApiOrderListResult struct {
 	Result ApiOrderListResponse // 结果
 	Body   []byte               // 内容
+	Http   gorequest.Response   // 请求
 	Err    error                // 错误
 }
 
-func NewApiOrderListResult(result ApiOrderListResponse, body []byte, err error) *ApiOrderListResult {
-	return &ApiOrderListResult{Result: result, Body: body, Err: err}
+func NewApiOrderListResult(result ApiOrderListResponse, body []byte, http gorequest.Response, err error) *ApiOrderListResult {
+	return &ApiOrderListResult{Result: result, Body: body, Http: http, Err: err}
 }
 
 // ApiOrderList 订单列表查询接口（新版）
 // https://union.meituan.com/v2/apiDetail?id=23
-func (app *App) ApiOrderList(notMustParams ...Params) *ApiOrderListResult {
+func (app *App) ApiOrderList(notMustParams ...gorequest.Params) *ApiOrderListResult {
 	// 参数
-	params := app.NewParamsWith(notMustParams...)
+	params := gorequest.NewParamsWith(notMustParams...)
 	// 请求时刻10位时间戳(秒级)，有效期60s
 	params["ts"] = gotime.Current().Timestamp()
-	params["appkey"] = app.AppKey
-	params["sign"] = app.getSign(app.Secret, params)
+	params["appkey"] = app.appKey
+	params["sign"] = app.getSign(app.secret, params)
 	// 请求
-	body, err := app.request("https://openapi.meituan.com/api/orderList", params, http.MethodGet)
+	request, err := app.request("https://openapi.meituan.com/api/orderList", params, http.MethodGet)
 	// 定义
 	var response ApiOrderListResponse
-	err = json.Unmarshal(body, &response)
-	return NewApiOrderListResult(response, body, err)
+	err = json.Unmarshal(request.ResponseBody, &response)
+	return NewApiOrderListResult(response, request.ResponseBody, request, err)
 }

service/meituan/app.go

@@ -1,36 +1,68 @@
 package meituan
 
 import (
-	"encoding/json"
-	"errors"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gomongo"
-	"net/http"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/library/utils/gorequest"
+	"gorm.io/gorm"
 )
 
 // App 美团联盟
 type App struct {
-	Secret string      // 秘钥
-	AppKey string      // 渠道标记
-	Mongo  gomongo.App // 日志数据库
+	secret       string         // 秘钥
+	appKey       string         // 渠道标记
+	pgsql        *gorm.DB       // pgsql数据库
+	client       *gorequest.App // 请求客户端
+	log          *golog.Api     // 日志服务
+	logTableName string         // 日志表名
+	logStatus    bool           // 日志状态
 }
 
-func (app *App) request(url string, params map[string]interface{}, method string) (resp []byte, err error) {
-	switch method {
-	case http.MethodGet:
-		// 请求
-		get, err := gohttp.Get(url, params)
-		// 日志
-		go app.mongoLog(url, params, method, get)
-		return get.Body, err
-	case http.MethodPost:
-		// 请求
-		paramsStr, err := json.Marshal(params)
-		postJson, err := gohttp.PostJson(url, paramsStr)
-		// 日志
-		go app.mongoLog(url, params, method, postJson)
-		return postJson.Body, err
-	default:
-		return nil, errors.New("请求类型不支持")
+func NewApp(secret string, appKey string, pgsql *gorm.DB) *App {
+	app := &App{secret: secret, appKey: appKey}
+	app.client = gorequest.NewHttp()
+	if pgsql != nil {
+		app.pgsql = pgsql
+		app.logStatus = true
+		app.logTableName = "meituan"
+		app.log = golog.NewApi(&golog.ApiConfig{
+			Db:        pgsql,
+			TableName: app.logTableName,
+		})
 	}
+	return app
+}
+
+func (app *App) request(url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
+
+	// 创建请求
+	client := app.client
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置方式
+	client.SetMethod(method)
+
+	// 设置格式
+	client.SetContentTypeJson()
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Request()
+	if err != nil {
+		return gorequest.Response{}, err
+	}
+
+	// 日志
+	if app.logStatus == true {
+		go app.postgresqlLog(request)
+	}
+
+	return request, err
+}
+
+func (app *App) GetAppKey() string {
+	return app.appKey
 }

service/meituan/mongodb.go

@@ -1,47 +0,0 @@
-package meituan
-
-import (
-	"encoding/json"
-	"go.dtapp.net/library/utils/gohttp"
-	"go.dtapp.net/library/utils/gotime"
-)
-
-// 日志
-type mongoZap struct {
-	Url           string      `json:"url" bson:"url"`
-	Params        interface{} `json:"params" bson:"params"`
-	Method        string      `json:"method" bson:"method"`
-	Header        interface{} `json:"header" bson:"header"`
-	Status        string      `json:"status" bson:"status"`
-	StatusCode    int         `json:"status_code" bson:"status_code"`
-	Body          interface{} `json:"body" bson:"body"`
-	ContentLength int64       `json:"content_length" bson:"content_length"`
-	CreateTime    string      `json:"create_time" bson:"create_time"`
-}
-
-func (m *mongoZap) Database() string {
-	return "zap_logs"
-}
-
-func (m *mongoZap) TableName() string {
-	return "meituan_" + gotime.Current().SetFormat("200601")
-}
-
-func (app *App) mongoLog(url string, params map[string]interface{}, method string, request gohttp.Response) {
-	if app.Mongo.Db == nil {
-		return
-	}
-	var body map[string]interface{}
-	_ = json.Unmarshal(request.Body, &body)
-	app.Mongo.Model(&mongoZap{}).InsertOne(mongoZap{
-		Url:           url,
-		Params:        params,
-		Method:        method,
-		Header:        request.Header,
-		Status:        request.Status,
-		StatusCode:    request.StatusCode,
-		Body:          body,
-		ContentLength: request.ContentLength,
-		CreateTime:    gotime.Current().Format(),
-	})
-}