dtapps
/
go-library
1
0
Fork 0
Code Issues Pull Requests Projects Releases 40 Wiki Activity

- update mongo

Browse Source
master
李光春 2 years ago
parent 0f8d77c5de
commit bc1a991f60
26 changed files with 215 additions and 248 deletions
Show Stats Download Patch File Download Diff File

6
service/eastiot/client.go
Unescape View File

@ -1,8 +1,8 @@
package eastiot
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
)
@ -10,8 +10,8 @@ import (
type ConfigClient struct {
AppId string
ApiKey string
Mongo *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
Mongo *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
type Client struct {

6
service/ejiaofei/client.go
Unescape View File

@ -1,8 +1,8 @@
package ejiaofei
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
)
@ -11,8 +11,8 @@ type ConfigClient struct {
UserId string
Pwd string
Key string
MongoDb *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
MongoDb *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
type Client struct {

26
service/ejiaofei/pgsql.go
Unescape View File

@ -1,9 +1,9 @@
package ejiaofei
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/gojson"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/datatypes"
)
@ -11,17 +11,17 @@ import (
// 记录日志
func (c *Client) postgresqlLog(request gorequest.Response) {
c.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}, //【返回】时间
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(dorm.XmlDecodeNoError(request.ResponseBody))), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: golog.TimeString{Time: request.ResponseTime}, //【返回】时间
})
}

6
service/kuaishou/client.go
Unescape View File

@ -1,15 +1,15 @@
package kuaishou
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
)
type ConfigClient struct {
MongoDb *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
MongoDb *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
type Client struct {

30
service/kuaishou/mongo.go
Unescape View File

@ -1,14 +1,14 @@
package kuaishou
import (
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/gorequest"
"net/http"
)
// 日志
type mongoZap struct {
RequestTime gomongo.BsonTime `json:"request_time" bson:"request_time"` //【请求】时间
RequestTime dorm.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"` //【请求】接口
@ -19,7 +19,7 @@ type mongoZap struct {
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"` //【返回】时间
ResponseTime dorm.BsonTime `json:"response_time" bson:"response_time"` //【返回】时间
}
func (m *mongoZap) Database() string {
@ -32,17 +32,17 @@ func (m *mongoZap) TableName() string {
func (c *Client) mongoLog(request gorequest.Response) {
_, _ = c.config.MongoDb.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), //【返回】时间
RequestTime: dorm.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: dorm.JsonDecodeNoError(request.ResponseBody), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: dorm.BsonTime(request.ResponseTime), //【返回】时间
})
}

6
service/leshuazf/client.go
Unescape View File

@ -1,8 +1,8 @@
package leshuazf
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
)
@ -11,8 +11,8 @@ type ConfigClient struct {
AgentId string // 服务商编号，由乐刷分配的接入方唯一标识，明文传输。
Environment string // 环境
KeyAgent string
MongoDb *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
MongoDb *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
// Client 乐刷

30
service/leshuazf/mongo.go
Unescape View File

@ -1,14 +1,14 @@
package leshuazf
import (
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/gorequest"
"net/http"
)
// 日志
type mongoZap struct {
RequestTime gomongo.BsonTime `json:"request_time" bson:"request_time"` //【请求】时间
RequestTime dorm.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"` //【请求】接口
@ -19,7 +19,7 @@ type mongoZap struct {
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"` //【返回】时间
ResponseTime dorm.BsonTime `json:"response_time" bson:"response_time"` //【返回】时间
}
func (m *mongoZap) Database() string {
@ -32,17 +32,17 @@ func (m *mongoZap) TableName() string {
func (c *Client) mongoLog(request gorequest.Response) {
_, _ = c.config.MongoDb.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), //【返回】时间
RequestTime: dorm.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: dorm.JsonDecodeNoError(request.ResponseBody), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: dorm.BsonTime(request.ResponseTime), //【返回】时间
})
}

6
service/pconline/client.go
Unescape View File

@ -1,15 +1,15 @@
package pconline
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
)
type ConfigClient struct {
MongoDb *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
MongoDb *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
type Client struct {

30
service/pconline/mongo.go
Unescape View File

@ -1,14 +1,14 @@
package pconline
import (
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/gorequest"
"net/http"
)
// 日志
type mongoZap struct {
RequestTime gomongo.BsonTime `json:"request_time" bson:"request_time"` //【请求】时间
RequestTime dorm.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"` //【请求】接口
@ -19,7 +19,7 @@ type mongoZap struct {
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"` //【返回】时间
ResponseTime dorm.BsonTime `json:"response_time" bson:"response_time"` //【返回】时间
}
func (m *mongoZap) Database() string {
@ -32,17 +32,17 @@ func (m *mongoZap) TableName() string {
func (c *Client) mongoLog(request gorequest.Response) {
_, _ = c.config.MongoDb.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), //【返回】时间
RequestTime: dorm.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: dorm.JsonDecodeNoError(request.ResponseBody), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: dorm.BsonTime(request.ResponseTime), //【返回】时间
})
}

6
service/pintoto/client.go
Unescape View File

@ -1,8 +1,8 @@
package pintoto
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
"math"
@ -12,8 +12,8 @@ import (
type ConfigClient struct {
AppKey string
AppSecret string
MongoDb *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
MongoDb *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
// Client 电影票服务

10
service/sendcloud/client.go
Unescape View File

@ -1,17 +1,17 @@
package sendcloud
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
)
type ConfigClient struct {
ApiUser string // API_USER
ApiKey string // API_KEY
MongoDb *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
ApiUser string // API_USER
ApiKey string // API_KEY
MongoDb *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
type Client struct {

6
service/wechatpayapiv2/client.go
Unescape View File

@ -1,8 +1,8 @@
package wechatpayapiv2
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
)
@ -14,8 +14,8 @@ type ConfigClient struct {
MchKey string // 私钥
CertString string
KeyString string
MongoDb *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
MongoDb *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
// Client 微信支付服务

26
service/wechatpayapiv2/pgsql.go
Unescape View File

@ -1,9 +1,9 @@
package wechatpayapiv2
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/gojson"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/datatypes"
)
@ -11,17 +11,17 @@ import (
// 记录日志
func (c *Client) postgresqlLog(request gorequest.Response) {
c.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}, //【返回】时间
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(dorm.XmlDecodeNoError(request.ResponseBody))), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: golog.TimeString{Time: request.ResponseTime}, //【返回】时间
})
}

20
service/wechatpayapiv3/client.go
Unescape View File

@ -1,22 +1,22 @@
package wechatpayapiv3
import (
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/golog"
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/gorequest"
"gorm.io/gorm"
)
type ConfigClient struct {
AppId string // 小程序或者公众号唯一凭证
AppSecret string // 小程序或者公众号唯一凭证密钥
MchId string // 微信支付的商户id
AesKey string // 私钥
ApiV3 string // API v3密钥
MchSslSerialNo string // pem 证书号
MchSslKey string // pem key 内容
MongoDb *gomongo.Client // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
AppId string // 小程序或者公众号唯一凭证
AppSecret string // 小程序或者公众号唯一凭证密钥
MchId string // 微信支付的商户id
AesKey string // 私钥
ApiV3 string // API v3密钥
MchSslSerialNo string // pem 证书号
MchSslKey string // pem key 内容
MongoDb *dorm.MongoClient // 日志数据库
PgsqlDb *gorm.DB // pgsql数据库
}
// Client 微信支付直连商户

30
service/wechatpayapiv3/mongo.go
Unescape View File

@ -1,14 +1,14 @@
package wechatpayapiv3
import (
"go.dtapp.net/library/utils/gomongo"
"go.dtapp.net/library/utils/dorm"
"go.dtapp.net/library/utils/gorequest"
"net/http"
)
// 日志
type mongoZap struct {
RequestTime gomongo.BsonTime `json:"request_time" bson:"request_time"` //【请求】时间
RequestTime dorm.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"` //【请求】接口
@ -19,7 +19,7 @@ type mongoZap struct {
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"` //【返回】时间
ResponseTime dorm.BsonTime `json:"response_time" bson:"response_time"` //【返回】时间
}
func (m *mongoZap) Database() string {
@ -32,17 +32,17 @@ func (m *mongoZap) TableName() string {
func (c *Client) mongoLog(request gorequest.Response) {
_, _ = c.config.MongoDb.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), //【返回】时间
RequestTime: dorm.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: dorm.JsonDecodeNoError(request.ResponseBody), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: dorm.BsonTime(request.ResponseTime), //【返回】时间
})
}

18
utils/dorm/mongo.go
Unescape View File

@ -4,23 +4,27 @@ import (
"context"
"errors"
"fmt"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
type ConfigMongoClient struct {
Dns string // 地址
Dns string // 地址
DatabaseName string // 库名
}
type MongoClient struct {
Db *mongo.Client // 驱动
config *ConfigMongoClient // 配置
Db *mongo.Client // 驱动
config *ConfigMongoClient // 配置
collectionName string // 表名
filterArr []queryFilter // 查询条件数组
filter bson.D // 查询条件
}
func NewMongoClient(config *ConfigMongoClient) (*MongoClient, error) {
c := &MongoClient{}
c.config = config
c := &MongoClient{config: config}
// 连接到MongoDB
db, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(c.config.Dns))
@ -37,10 +41,6 @@ func NewMongoClient(config *ConfigMongoClient) (*MongoClient, error) {
return c, nil
}
func (c *MongoClient) GetDb() *mongo.Client {
return c.Db
}
// Close 关闭
func (c *MongoClient) Close() error {
err := c.Db.Disconnect(context.TODO())

1
utils/dorm/mongo_bson.go
Unescape View File

@ -0,0 +1 @@
package dorm

34
utils/gomongo/curd.go → utils/dorm/mongo_curd.go
Unescape View File

@ -1,4 +1,4 @@
package gomongo
package dorm
import (
"context"
@ -9,26 +9,26 @@ import (
)
// Database 设置库名
func (c *Client) Database(database string) *Client {
c.DatabaseName = database
func (c *MongoClient) Database(databaseName string) *MongoClient {
c.setDatabaseName(databaseName)
return c
}
// Collection 设置表名
func (c *Client) Collection(collection string) *Client {
c.collectionName = collection
func (c *MongoClient) Collection(collectionName string) *MongoClient {
c.setCollectionName(collectionName)
return c
}
// Model 传入模型自动获取库名和表名
func (c *Client) Model(value interface{}) *Client {
func (c *MongoClient) Model(value interface{}) *MongoClient {
// https://studygolang.com/articles/896
val := reflect.ValueOf(value)
if methodValue := val.MethodByName("Database"); methodValue.IsValid() {
c.DatabaseName = methodValue.Call(nil)[0].String()
c.setDatabaseName(methodValue.Call(nil)[0].String())
}
if methodValue := val.MethodByName("TableName"); methodValue.IsValid() {
c.collectionName = methodValue.Call(nil)[0].String()
c.setCollectionName(methodValue.Call(nil)[0].String())
}
return c
}
@ -40,8 +40,8 @@ type CreateResult struct {
}
// Create 创建数据
func (c *Client) Create(values ...interface{}) (CreateResult, error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) Create(values ...interface{}) (CreateResult, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
const (
insertTypeOne = "one"
@ -95,7 +95,7 @@ type queryFilter struct {
}
// Where 条件
func (c *Client) Where(key string, value interface{}) *Client {
func (c *MongoClient) Where(key string, value interface{}) *MongoClient {
log.Println("key", key)
log.Println("value", value)
c.filterArr = append(c.filterArr, queryFilter{key, value})
@ -110,13 +110,13 @@ type QueryResult struct {
}
// First 获取第一条记录（主键升序）
func (c *Client) First() *QueryResult {
func (c *MongoClient) First() *QueryResult {
return &QueryResult{}
}
// Take 获取一条记录，没有指定排序字段
func (c *Client) Take(v interface{}) *QueryResult {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) Take(v interface{}) *QueryResult {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
//log.Printf("c.filterArr：%s\n", c.filterArr)
//log.Printf("c.filterArr：%v\n", c.filterArr)
//log.Printf("c.filterArr：%+v\n", c.filterArr)
@ -128,13 +128,13 @@ func (c *Client) Take(v interface{}) *QueryResult {
}
// Last 获取最后一条记录（主键降序）
func (c *Client) Last() *QueryResult {
func (c *MongoClient) Last() *QueryResult {
return &QueryResult{}
}
// Find 获取多条记录
func (c *Client) Find(v interface{}) *QueryResult {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) Find(v interface{}) *QueryResult {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
log.Printf("c.filterArr：%s\n", c.filterArr)
log.Printf("c.filterArr：%v\n", c.filterArr)
log.Printf("c.filterArr：%+v\n", c.filterArr)

15
utils/dorm/mongo_get.go
Unescape View File

@ -0,0 +1,15 @@
package dorm
import "go.mongodb.org/mongo-driver/mongo"
func (c *MongoClient) GetDb() *mongo.Client {
return c.Db
}
func (c *MongoClient) getDatabaseName() string {
return c.config.DatabaseName
}
func (c *MongoClient) getCollectionName() string {
return c.collectionName
}

2
utils/gomongo/json.go → utils/dorm/mongo_json.go
Unescape View File

@ -1,4 +1,4 @@
package gomongo
package dorm
import "encoding/json"

78
utils/gomongo/official.go → utils/dorm/mongo_official.go
Unescape View File

@ -1,4 +1,4 @@
package gomongo
package dorm
import (
"context"
@ -7,35 +7,35 @@ import (
"go.mongodb.org/mongo-driver/mongo/options"
)
func (c *Client) Session() (session mongo.Session, err error) {
session, err = c.db.StartSession()
func (c *MongoClient) Session() (session mongo.Session, err error) {
session, err = c.Db.StartSession()
return
}
// InsertOne 插入单个文档
func (c *Client) InsertOne(value interface{}) (result *mongo.InsertOneResult, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) InsertOne(value interface{}) (result *mongo.InsertOneResult, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.InsertOne(context.TODO(), value)
return result, err
}
// InsertMany 插入多个文档
func (c *Client) InsertMany(values []interface{}) (result *mongo.InsertManyResult, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) InsertMany(values []interface{}) (result *mongo.InsertManyResult, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.InsertMany(context.TODO(), values)
return result, err
}
// Delete 删除文档
func (c *Client) Delete(filter interface{}) (int64, error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) Delete(filter interface{}) (int64, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
count, err := collection.DeleteOne(context.TODO(), filter, nil)
return count.DeletedCount, err
}
// DeleteMany 删除多个文档
func (c *Client) DeleteMany(key string, value interface{}) (int64, error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) DeleteMany(key string, value interface{}) (int64, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
filter := bson.D{{key, value}}
count, err := collection.DeleteMany(context.TODO(), filter)
return count.DeletedCount, err
@ -46,8 +46,8 @@ func (c *Client) DeleteMany(key string, value interface{}) (int64, error) {
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (c *Client) UpdateOne(filter, update interface{}) (int64, error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) UpdateOne(filter, update interface{}) (int64, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err := collection.UpdateOne(context.TODO(), filter, update)
return result.UpsertedCount, err
}
@ -57,43 +57,43 @@ func (c *Client) UpdateOne(filter, update interface{}) (int64, error) {
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (c *Client) UpdateMany(filter, update interface{}) (int64, error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) UpdateMany(filter, update interface{}) (int64, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err := collection.UpdateMany(context.TODO(), filter, update)
return result.UpsertedCount, err
}
// Find 查询
//func (c *Client) Find(filter interface{}, opts ...*options.FindOptions) (result *mongo.Cursor, err error) {
// collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
//func (c *MongoClient) Find(filter interface{}, opts ...*options.FindOptions) (result *mongo.Cursor, err error) {
// collection := c.Db.Database(c.DatabaseName).Collection(c.collectionName)
// result, err = collection.Find(context.TODO(), filter, opts...)
// return result, err
//}
// FindOne 查询单个文档
func (c *Client) FindOne(filter interface{}) (result *mongo.SingleResult) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) FindOne(filter interface{}) (result *mongo.SingleResult) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result = collection.FindOne(context.TODO(), filter)
return result
}
// FindMany 查询多个文档
func (c *Client) FindMany(filter interface{}) (result *mongo.Cursor, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) FindMany(filter interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.Find(context.TODO(), filter)
return result, err
}
// FindManyByFilters 多条件查询
func (c *Client) FindManyByFilters(filter interface{}) (result *mongo.Cursor, err error) {
collection, err := c.db.Database(c.DatabaseName).Collection(c.collectionName).Clone()
func (c *MongoClient) FindManyByFilters(filter interface{}) (result *mongo.Cursor, err error) {
collection, err := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName).Clone()
result, err = collection.Find(context.TODO(), bson.M{"$and": filter})
return result, err
}
// FindManyByFiltersSort 多条件查询支持排序
func (c *Client) FindManyByFiltersSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection, err := c.db.Database(c.DatabaseName).Collection(c.collectionName).Clone()
func (c *MongoClient) FindManyByFiltersSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection, err := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName).Clone()
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(context.TODO(), filter, findOptions)
@ -101,8 +101,8 @@ func (c *Client) FindManyByFiltersSort(filter interface{}, Sort interface{}) (re
}
// FindCollection 查询集合文档
func (c *Client) FindCollection(Limit int64) (result *mongo.Cursor, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) FindCollection(Limit int64) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
findOptions := options.Find()
findOptions.SetLimit(Limit)
result, err = collection.Find(context.TODO(), bson.D{{}}, findOptions)
@ -110,8 +110,8 @@ func (c *Client) FindCollection(Limit int64) (result *mongo.Cursor, err error) {
}
// FindCollectionSort 查询集合文档支持排序
func (c *Client) FindCollectionSort(Sort interface{}, Limit int64) (result *mongo.Cursor, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) FindCollectionSort(Sort interface{}, Limit int64) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
findOptions.SetLimit(Limit)
@ -120,8 +120,8 @@ func (c *Client) FindCollectionSort(Sort interface{}, Limit int64) (result *mong
}
// FindManyCollectionSort 查询集合文档支持排序支持条件
func (c *Client) FindManyCollectionSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) FindManyCollectionSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(context.TODO(), filter, findOptions)
@ -129,8 +129,8 @@ func (c *Client) FindManyCollectionSort(filter interface{}, Sort interface{}) (r
}
// CollectionCount 查询集合里有多少数据
func (c *Client) CollectionCount() (name string, size int64) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) CollectionCount() (name string, size int64) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
name = collection.Name()
size, _ = collection.EstimatedDocumentCount(context.TODO())
return name, size
@ -140,8 +140,8 @@ func (c *Client) CollectionCount() (name string, size int64) {
// Skip 跳过
// Limit 读取数量
// sort 1 ，-1 . 1 为升序 ， -1 为降序
func (c *Client) CollectionDocuments(Skip, Limit int64, sort int, key string, value interface{}) (result *mongo.Cursor, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) CollectionDocuments(Skip, Limit int64, sort int, key string, value interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
SORT := bson.D{{"_id", sort}}
filter := bson.D{{key, value}}
findOptions := options.Find().SetSort(SORT).SetLimit(Limit).SetSkip(Skip)
@ -150,15 +150,15 @@ func (c *Client) CollectionDocuments(Skip, Limit int64, sort int, key string, va
}
// AggregateByFiltersSort 统计分析
func (c *Client) AggregateByFiltersSort(pipeline interface{}, opts ...*options.AggregateOptions) (result *mongo.Cursor, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) AggregateByFiltersSort(pipeline interface{}, opts ...*options.AggregateOptions) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.Aggregate(context.TODO(), pipeline, opts...)
return result, err
}
// CountDocumentsByFilters 统计数量
func (c *Client) CountDocumentsByFilters(filter interface{}) (count int64, err error) {
collection := c.db.Database(c.DatabaseName).Collection(c.collectionName)
func (c *MongoClient) CountDocumentsByFilters(filter interface{}) (count int64, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
count, err = collection.CountDocuments(context.TODO(), filter)
return count, err
}

9
utils/dorm/mongo_set.go
Unescape View File

@ -0,0 +1,9 @@
package dorm
func (c *MongoClient) setDatabaseName(databaseName string) {
c.config.DatabaseName = databaseName
}
func (c *MongoClient) setCollectionName(collectionName string) {
c.collectionName = collectionName
}

2
utils/gomongo/time.go → utils/dorm/mongo_time.go
Unescape View File

@ -1,4 +1,4 @@
package gomongo
package dorm
import (
"go.dtapp.net/library/utils/gotime"

2
utils/gomongo/xml.go → utils/dorm/mongo_xml.go
Unescape View File

@ -1,4 +1,4 @@
package gomongo
package dorm
import (
"encoding/json"

1
utils/gomongo/bson.go
Unescape View File

@ -1 +0,0 @@
package gomongo

57
utils/gomongo/client.go
Unescape View File

@ -1,57 +0,0 @@
package gomongo
import (
"context"
"errors"
"fmt"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
// Client 实例
type Client struct {
db *mongo.Client // MongoDB驱动
ctx context.Context // 上下文
DatabaseName string // 库名
collectionName string // 表名
filterArr []queryFilter // 查询条件数组
filter bson.D // 查询条件
}
// NewClient 实例化并链接数据库
func NewClient(dns string) *Client {
// 连接到MongoDB
db, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(dns))
if err != nil {
panic(fmt.Sprintf("连接失败：%v", err))
}
// 检查连接
err = db.Ping(context.TODO(), nil)
if err != nil {
panic(fmt.Sprintf("检查连接失败：%v", err))
}
return &Client{db: db, ctx: context.TODO()}
}
// NewClientDb 实例化并传入链接
func NewClientDb(db *mongo.Client) *Client {
return &Client{db: db, ctx: context.TODO()}
}
// Close 关闭
func (c *Client) Close() {
err := c.db.Disconnect(context.TODO())
if err != nil {
panic(errors.New(fmt.Sprintf("关闭失败：%v", err)))
}
return
}
// GetDbDriver 获取驱动
func (c *Client) GetDbDriver() *mongo.Client {
return c.db
}
Write Preview
Loading…
Cancel
Save