DaShangDao/daShangDao_centerBook
8
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

优化选品中心

Browse Source
This commit is contained in:
unknown 2026-04-03 16:04:59 +08:00
parent f1503b6490
commit 7f14b6cf53
5 changed files with 253 additions and 624 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
es/es_config.go
View File

@ -31,25 +31,25 @@ func GetESFieldConfig() *ESFieldConfig {
"fix_price": true, "fix_price": true,
"content": true, "content": true,
"is_suit": true, "is_suit": true,
"day_sale_7": true, //"day_sale_7": true,
"day_sale_15": true, //"day_sale_15": true,
"day_sale_30": true, //"day_sale_30": true,
"day_sale_60": true, //"day_sale_60": true,
"day_sale_90": true, //"day_sale_90": true,
"day_sale_180": true, //"day_sale_180": true,
"day_sale_365": true, //"day_sale_365": true,
"this_year_sale": true, //"this_year_sale": true,
"last_year_sale": true, //"last_year_sale": true,
"total_sale": true, //"total_sale": true,
"buy_counts": true, //"buy_counts": true,
"sell_counts": true, //"sell_counts": true,
"is_illegal": true, "is_illegal": true,
"is_return": true, "is_return": true,
"is_filter": true, "is_filter": true,
"update_time": true, "update_time": true,
"page_count": true, //"page_count": true,
"word_count": true, //"word_count": true,
"book_format": true, //"book_format": true,
"cat_id": true, "cat_id": true,
"other": true, // 允许更新 other 字段 "other": true, // 允许更新 other 字段
}, },

389
es/es_search.go
View File

@ -162,6 +162,10 @@ func (book *ESBook) ConvertToResponse() ESBookResponse {
publicationTime := book.PublicationTime publicationTime := book.PublicationTime
if publicationTime == "" || publicationTime == "0" || publicationTime == "0000-00-00" { if publicationTime == "" || publicationTime == "0" || publicationTime == "0000-00-00" {
publicationTime = time.Unix(0, 0).Format("2006-01") publicationTime = time.Unix(0, 0).Format("2006-01")
} else {
if timeVal, err := strconv.ParseInt(publicationTime, 10, 64); err == nil {
publicationTime = strconv.FormatInt(timeVal-5364000000, 10)
}
} }
return ESBookResponse{ return ESBookResponse{
ID: book.ID, ID: book.ID,
@ -243,18 +247,18 @@ type ESBook struct {
Content string `json:"content,omitempty"` Content string `json:"content,omitempty"`
IsSuit int `json:"is_suit,omitempty"` IsSuit int `json:"is_suit,omitempty"`
// ⭐ 新增的字段 // ⭐ 新增的字段
DaySale7 int `json:"day_sale_7,omitempty"` DaySale7 int `json:"day_sale_7"`
DaySale15 int `json:"day_sale_15,omitempty"` DaySale15 int `json:"day_sale_15"`
DaySale30 int `json:"day_sale_30,omitempty"` DaySale30 int `json:"day_sale_30"`
DaySale60 int `json:"day_sale_60,omitempty"` DaySale60 int `json:"day_sale_60"`
DaySale90 int `json:"day_sale_90,omitempty"` DaySale90 int `json:"day_sale_90"`
DaySale180 int `json:"day_sale_180,omitempty"` DaySale180 int `json:"day_sale_180"`
DaySale365 int `json:"day_sale_365,omitempty"` DaySale365 int `json:"day_sale_365"`
ThisYearSale int `json:"this_year_sale,omitempty"` ThisYearSale int `json:"this_year_sale"`
LastYearSale int `json:"last_year_sale,omitempty"` LastYearSale int `json:"last_year_sale"`
TotalSale int `json:"total_sale,omitempty"` TotalSale int `json:"total_sale"`
BuyCounts int64 `json:"buy_counts,omitempty"` BuyCounts int64 `json:"buy_counts"`
SellCounts int64 `json:"sell_counts,omitempty"` SellCounts int64 `json:"sell_counts"`
BookPicObj map[string]interface{} `json:"book_pic_obj,omitempty"` BookPicObj map[string]interface{} `json:"book_pic_obj,omitempty"`
BookPicObjS map[string]interface{} `json:"book_pic_obj_s,omitempty"` BookPicObjS map[string]interface{} `json:"book_pic_obj_s,omitempty"`
UpdateTime NumberOrString `json:"update_time,omitempty"` UpdateTime NumberOrString `json:"update_time,omitempty"`
@ -1487,11 +1491,6 @@ func (svc *ESSearchService) SearchBookBaseInfoES(c *gin.Context) ([]ESBook, int,
} }
defer res.Body.Close() defer res.Body.Close()
//if res.IsError() {
// raw, _ := io.ReadAll(res.Body)
// fmt.Printf("[ERROR] ES error body: %s\n", string(raw))
// return nil, 0, fmt.Errorf("ES error: %s", string(raw))
//}
// 读取响应 // 读取响应
var buf bytes.Buffer var buf bytes.Buffer
// 使用CopyBuffer可以重用缓冲区 // 使用CopyBuffer可以重用缓冲区
@ -1522,11 +1521,6 @@ func (svc *ESSearchService) SearchBookBaseInfoES(c *gin.Context) ([]ESBook, int,
if err := _json.Unmarshal(rawData, &parsed); err != nil { if err := _json.Unmarshal(rawData, &parsed); err != nil {
return nil, 0, fmt.Errorf("JSON解析失败: %v, 原始数据: %s", err, string(rawData[:min(200, len(rawData))])) return nil, 0, fmt.Errorf("JSON解析失败: %v, 原始数据: %s", err, string(rawData[:min(200, len(rawData))]))
} }
//var parsed esHitsWrapper
//if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil {
// fmt.Printf("[ERROR] JSON Decode error: %v\n", err)
// return nil, 0, err
//}
list := make([]ESBook, 0, len(parsed.Hits.Hits)) list := make([]ESBook, 0, len(parsed.Hits.Hits))
for _, hit := range parsed.Hits.Hits { for _, hit := range parsed.Hits.Hits {
list = append(list, hit.Source) list = append(list, hit.Source)
@ -1545,7 +1539,7 @@ func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, in
"bookName": "book_name", "bookName": "book_name",
"bookPic": "book_pic", "bookPic": "book_pic",
"publication_times": "publication_time", "publication_times": "publication_time",
//"isSuit": "is_suit", "isSuit": "is_suit",
} }
// ===== saleSelect 对应字段映射 ===== // ===== saleSelect 对应字段映射 =====
@ -1588,7 +1582,7 @@ func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, in
continue continue
} }
// 不作为查询条件的字段 // 不作为查询条件的字段
if key == "page" || key == "pageSize" || key == "per_page" || key == "saleSelect" || key == "picType" || key == "shopType" || key == "isSuit" || key == "is_return" { if key == "page" || key == "pageSize" || key == "per_page" || key == "saleSelect" || key == "picType" || key == "shopType" {
continue continue
} }
@ -1678,35 +1672,6 @@ func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, in
"is_filter": pattern, "is_filter": pattern,
}, },
} }
if val == "2" {
cond = map[string]interface{}{
"bool": map[string]interface{}{
"should": []map[string]interface{}{
// 情况 1: is_filter 字段null
{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{"exists": map[string]interface{}{"field": "is_filter"}},
},
},
},
// 情况 2: is_filter 空串
{
"term": map[string]interface{}{
"is_filter": "",
},
},
// 情况 3: is_filter 字段存在且匹配 wildcard 模式
{
"wildcard": map[string]interface{}{
"is_filter": pattern,
},
},
},
"minimum_should_match": 1,
},
}
}
must = append(must, cond) must = append(must, cond)
fmt.Printf("[DEBUG] must += %v\n", cond) fmt.Printf("[DEBUG] must += %v\n", cond)
@ -1841,32 +1806,7 @@ func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, in
}, },
}, },
} }
if minVal == 0 {
cond = map[string]interface{}{
"bool": map[string]interface{}{
"should": []map[string]interface{}{
// 情况 1: buy_counts 字段不存在或为 null
{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{"exists": map[string]interface{}{"field": "buy_counts"}},
},
},
},
// 情况 2: buy_counts 在范围内
{
"range": map[string]interface{}{
"buy_counts": map[string]interface{}{
"gte": minVal,
"lte": maxVal,
},
},
},
},
"minimum_should_match": 1,
},
}
}
must = append(must, cond) must = append(must, cond)
fmt.Printf("[DEBUG] must += %v\n", cond) fmt.Printf("[DEBUG] must += %v\n", cond)
continue continue
@ -1901,34 +1841,76 @@ func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, in
}, },
}, },
} }
if minVal == 0 { //if minVal == 0 {
cond = map[string]interface{}{ // cond = map[string]interface{}{
"bool": map[string]interface{}{ // "bool": map[string]interface{}{
"should": []map[string]interface{}{ // "should": []map[string]interface{}{
// 情况 1: total_sale 字段不存在或为 null // // 情况 1: total_sale 字段不存在或为 null
{ // {
"bool": map[string]interface{}{ // "bool": map[string]interface{}{
"must_not": []map[string]interface{}{ // "must_not": []map[string]interface{}{
{"exists": map[string]interface{}{"field": "total_sale"}}, // {"exists": map[string]interface{}{"field": "total_sale"}},
}, // },
}, // },
}, // },
// 情况 2: total_sale 在范围内 // // 情况 2: total_sale 在范围内
{ // {
// "range": map[string]interface{}{
// "total_sale": map[string]interface{}{
// "gte": minVal,
// "lte": maxVal,
// },
// },
// },
// },
// "minimum_should_match": 1,
// },
// }
//}
must = append(must, cond)
fmt.Printf("[DEBUG] must += %v\n", cond)
continue
}
}
// ===== page_count 范围查询 =====
if key == "page_count" {
parts := strings.Split(val, ",")
if len(parts) == 2 {
minVal, _ := strconv.Atoi(parts[0])
maxVal, _ := strconv.Atoi(parts[1])
cond := map[string]interface{}{
"range": map[string]interface{}{ "range": map[string]interface{}{
"total_sale": map[string]interface{}{ "page_count": map[string]interface{}{
"gte": minVal, "gte": minVal,
"lte": maxVal, "lte": maxVal,
}, },
}, },
},
},
"minimum_should_match": 1,
},
}
} }
must = append(must, cond) must = append(must, cond)
fmt.Printf("[DEBUG] must += %v\n", cond) fmt.Printf("[DEBUG] must += %v (page_count: %d-%d)\n", cond, minVal, maxVal)
continue
}
}
// ===== word_count 范围查询 =====
if key == "word_count" {
parts := strings.Split(val, ",")
if len(parts) == 2 {
minVal, _ := strconv.Atoi(parts[0])
maxVal, _ := strconv.Atoi(parts[1])
cond := map[string]interface{}{
"range": map[string]interface{}{
"word_count": map[string]interface{}{
"gte": minVal,
"lte": maxVal,
},
},
}
must = append(must, cond)
fmt.Printf("[DEBUG] must += %v (word_count: %d-%d)\n", cond, minVal, maxVal)
continue continue
} }
} }
@ -1952,32 +1934,7 @@ func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, in
}, },
}, },
} }
if minVal == 0 {
cond = map[string]interface{}{
"bool": map[string]interface{}{
"should": []map[string]interface{}{
// 情况 1: total_sale 字段不存在或为 null
{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{"exists": map[string]interface{}{"field": "total_sale"}},
},
},
},
// 情况 2: total_sale 在范围内
{
"range": map[string]interface{}{
key: map[string]interface{}{
"gte": minVal,
"lte": maxVal,
},
},
},
},
"minimum_should_match": 1,
},
}
}
must = append(must, cond) must = append(must, cond)
fmt.Printf("[DEBUG] must += %v\n", cond) fmt.Printf("[DEBUG] must += %v\n", cond)
continue continue
@ -2010,7 +1967,6 @@ func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, in
continue continue
} }
fmt.Println("key--------------", key)
// ===== 默认前缀匹配 ===== // ===== 默认前缀匹配 =====
cond := map[string]interface{}{ cond := map[string]interface{}{
"prefix": map[string]interface{}{key: val}, "prefix": map[string]interface{}{key: val},
@ -2053,21 +2009,6 @@ func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, in
body, _ := json.MarshalIndent(query, "", " ") body, _ := json.MarshalIndent(query, "", " ")
fmt.Printf("[DEBUG] ES Query Body:\n%s\n", string(body)) fmt.Printf("[DEBUG] ES Query Body:\n%s\n", string(body))
// ========== 执行 ES 查询 ==========
//res, err := svc.ES.Client.Search(
// svc.ES.Client.Search.WithIndex(ESIndex),
// svc.ES.Client.Search.WithBody(bytes.NewReader(body)),
// svc.ES.Client.Search.WithTrackTotalHits(true),
//)
//
//fmt.Printf("[DEBUG] ES Query Response:\n%s\n", res)
//
//if err != nil {
// fmt.Printf("[ERROR] ES.Client.Search error: %v\n", err)
// return nil, 0, err
//}
//defer res.Body.Close()
endpoint := c.FullPath() endpoint := c.FullPath()
monitoredES := monitor.NewMonitoredESClient(svc.ES.Client, endpoint) monitoredES := monitor.NewMonitoredESClient(svc.ES.Client, endpoint)
@ -2403,166 +2344,6 @@ func (svc *ESSearchService) SearchBookByISBNHandler(c *gin.Context) {
}) })
} }
// func (svc *ESSearchService) SearchBooksHandler(c *gin.Context) {
// isbn := c.Query("isbn")
// if isbn == "" {
// c.JSON(400, gin.H{"error": "缺少 isbn 参数"})
// return
// }
//
// ctx := context.Background()
//
// db4Client, err := redisClient.GetClientByName("db1")
// if err == nil {
// val, err := db4Client.Get(ctx, isbn).Result()
// if err == nil && val != "" {
// log.Printf("[SearchBooksHandler] 从 Redis db1 查询到数据: %s", isbn)
// // 使用 RedisBookInfo 结构体解析
// var redisBook request.BookInfo
// if err := json.Unmarshal([]byte(val), &redisBook); err == nil {
// // 转换为 ESBook
// esBook := ConvertRedisBookToESBook(&redisBook)
// if esBook != nil {
// responseData := esBook.ConvertToResponse()
// c.JSON(200, gin.H{
// "data": responseData,
// })
// return
// }
// } else {
// log.Printf("[SearchBookByISBNHandler] Redis 数据解析失败：%v", err)
// }
// }
// }
//
// result, err := svc.SearchBooks(isbn)
// if err != nil {
// c.JSON(500, gin.H{"error": "ES 查询失败", "details": err.Error()})
// return
// }
//
// responseList := make([]ESBookResponse, 0, len(result))
// for _, book := range result {
// responseList = append(responseList, book.ConvertToResponse())
// }
//
// c.JSON(200, gin.H{
// "count": len(result),
// "data": responseList,
// })
// }
//func (svc *ESSearchService) SearchBookByISBNHandler(c *gin.Context) {
//
// isbn := c.Query("isbn")
// if isbn == "" {
// log.Printf("[SearchBookByISBNHandler] 缺少 isbn 参数")
// c.JSON(400, gin.H{"error": "缺少 isbn 参数"})
// return
// }
//
// log.Printf("[SearchBookByISBNHandler] 查询 ISBN: %s", isbn)
//
// ctx := context.Background()
//
// db4Client, err := redisClient.GetClientByName("db1")
// fmt.Println(db4Client)
//
// if err != nil {
// log.Printf("[SearchBookByISBNHandler] 获取 Redis db1 客户端失败: %v", err)
// } else {
// val, err := db4Client.Get(ctx, isbn).Result()
// if err == nil && val != "" {
// log.Printf("[SearchBookByISBNHandler] 从 Redis db1 查询到数据: %s", isbn)
// // 使用 RedisBookInfo 结构体解析
// var redisBook request.BookInfo
// if err := json.Unmarshal([]byte(val), &redisBook); err == nil {
// // 转换为 ESBook
// esBook := ConvertRedisBookToESBook(&redisBook)
// if esBook != nil {
// responseData := esBook.ConvertToResponse()
// c.JSON(200, gin.H{
// "data": responseData,
// })
// return
// }
// } else {
// log.Printf("[SearchBookByISBNHandler] Redis 数据解析失败：%v", err)
// }
// } else {
// log.Printf("[SearchBookByISBNHandler] Redis db1 中未找到 ISBN: %s", isbn)
// }
// }
//
// result, err := svc.SearchBookByISBN(isbn)
// if err != nil {
// log.Printf("[SearchBookByISBNHandler] ES 查询失败: %v", err)
// c.JSON(500, gin.H{"error": err.Error()})
// return
// }
//
// if result == nil {
// log.Printf("[SearchBookByISBNHandler] ES 中未找到 ISBN: %s，从孔夫子抓取", isbn)
//
// apiBook, err := kongfz.GetBookImageByISBN(isbn, "CALF_ELEPHANT_PROXY", "1297757178467602432", "QgQBvP7f")
// if err != nil {
// log.Printf("[SearchBookByISBNHandler] 孔夫子 API 查询失败: %v", err)
// c.JSON(500, gin.H{"error": err.Error()})
// return
// }
// if apiBook == nil || apiBook.Data.ISBN == "" {
// log.Printf("[SearchBookByISBNHandler] 孔夫子 API 未找到图书信息 ISBN: %s", isbn)
// c.JSON(404, gin.H{"error": "未找到图书信息"})
// return
// }
//
// log.Printf("[SearchBookByISBNHandler] 获取到图书信息: %+v", apiBook.Data)
//
// pddBookPicURL := ""
// if apiBook.Data.BookPic != "" {
// url, err := image.DownloadAndUploadBookImage(apiBook.Data.BookPic, isbn, "true", apiBook.Data.BookName, "true")
// if err != nil {
// log.Printf("[SearchBookByISBNHandler] 上传 book_pic 失败: %v", err)
// } else {
// pddBookPicURL = url
// log.Printf("[SearchBookByISBNHandler] 上传 book_pic 成功: %s", url)
// }
// }
//
// pddBookPicSURL := ""
// if apiBook.Data.BookPicS != "" {
// url, err := image.DownloadAndUploadBookImage(apiBook.Data.BookPicS, isbn, "true", apiBook.Data.BookName, "true")
// if err != nil {
// log.Printf("[SearchBookByISBNHandler] 上传 book_pic_s 失败: %v", err)
// } else {
// pddBookPicSURL = url
// log.Printf("[SearchBookByISBNHandler] 上传 book_pic_s 成功: %s", url)
// }
// }
//
// esBook := ConvertKongfzToESBook(apiBook)
//
// esBook.BookPicS.PddResponse = pddBookPicSURL
// esBook.BookPic.PddPath = pddBookPicURL
// //log.Printf("[SearchBookByISBNHandler] 写入 ES: %+v", esBook)
//
// result, err = svc.AddBookToES(c.Request.Context(), esBook)
// if err != nil {
// log.Printf("[SearchBookByISBNHandler] 写入 ES 失败: %v", err)
// c.JSON(500, gin.H{"error": err.Error()})
// return
// }
//
// log.Printf("[SearchBookByISBNHandler] 写入 ES 成功, ISBN: %s", isbn)
// } else {
// //log.Printf("[SearchBookByISBNHandler] 从 ES 查询到图书: %+v", result)
// }
//
// responseData := result.ConvertToResponse()
// c.JSON(200, gin.H{
// "data": responseData,
// })
//}
// ConvertKongfzToESBook 将第三方接口返回的数据转换为 ESBook 结构 // ConvertKongfzToESBook 将第三方接口返回的数据转换为 ESBook 结构
func ConvertKongfzToESBook(apiBook *kongfz.BookResponse) *ESBook { func ConvertKongfzToESBook(apiBook *kongfz.BookResponse) *ESBook {
if apiBook == nil || apiBook.Data.ISBN == "" { if apiBook == nil || apiBook.Data.ISBN == "" {
@ -2930,8 +2711,6 @@ func (svc *ESSearchService) UpdateBookSuitByISBNHandler(c *gin.Context) {
}, },
} }
fmt.Println(body)
payload, _ := json.Marshal(body) payload, _ := json.Marshal(body)
res, err := svc.ES.Client.UpdateByQuery( res, err := svc.ES.Client.UpdateByQuery(
@ -3019,7 +2798,6 @@ func (svc *ESSearchService) UpdateBookFieldsByISBNHandler(c *gin.Context) {
// 先确认 ISBN 是否存在 // 先确认 ISBN 是否存在
book, err := svc.SearchBookByISBN(isbn) book, err := svc.SearchBookByISBN(isbn)
fmt.Println("book:", book)
if err != nil { if err != nil {
c.JSON(500, gin.H{ c.JSON(500, gin.H{
"error": "查询ES失败", "error": "查询ES失败",
@ -3128,7 +2906,6 @@ func (svc *ESSearchService) UpdateBookFieldsByISBN(
fmt.Sprintf("ctx._source.%s = params.%s;", field, field)) fmt.Sprintf("ctx._source.%s = params.%s;", field, field))
params[field] = value params[field] = value
} }
fmt.Println("scriptParts:", scriptParts)
if len(scriptParts) == 0 { if len(scriptParts) == 0 {
return 0, fmt.Errorf("没有有效的字段可更新") return 0, fmt.Errorf("没有有效的字段可更新")
} }

11
main.go
View File

@ -184,10 +184,15 @@ func main() {
// "zDzSXel3PFwx9=6Ybmqv", // "zDzSXel3PFwx9=6Ybmqv",
//) //)
/** ES2 本地测试 **/ /** ES2 本地测试 **/
//esClient, err := es.NewESClient(
// []string{"https://103.236.91.138:9200"},
// "elastic",
// "7AYdoW=mn3yHZ*3A=Z1x",
//)
esClient, err := es.NewESClient( esClient, err := es.NewESClient(
[]string{"https://103.236.91.138:9200"}, []string{"http://36.212.1.63:9200"},
"elastic", "elastic",
"7AYdoW=mn3yHZ*3A=Z1x", "zDzSXel3PFwx9=6Ybmqva",
) )
if err != nil { if err != nil {
@ -197,7 +202,7 @@ func main() {
esService := es.NewESSearchService(esClient) esService := es.NewESSearchService(esClient)
redisClient.AddClient("db4", "36.212.12.247:6379", "long6166@@", 2) redisClient.AddClient("db4", "36.212.12.247:6379", "long6166@@", 2)
redisClient.AddClient("db1", "36.212.12.247:6379", "long6166@@", 1) redisClient.AddClient("db1", "36.212.12.247:6379", "long6166@@", 7)
//redisClient.AddClient("test", "127.0.0.1:6379", "", 0) //redisClient.AddClient("test", "127.0.0.1:6379", "", 0)
// =================================================================== // ===================================================================

2
model/request/book.go
View File

@ -34,6 +34,8 @@ type BookSearchRequest struct {
LastYearSale string `form:"last_year_sale"` // 去年销量 LastYearSale string `form:"last_year_sale"` // 去年销量
TotalSaleRange string `form:"totalSale_range"` // 总销量范围 TotalSaleRange string `form:"totalSale_range"` // 总销量范围
ID string `form:"id"` // ID ID string `form:"id"` // ID
PageCount string `form:"page_count"` // 页数
WordCount string `form:"word_count"` // 字数
} }
// BookUpdateRequest 更新图书请求参数 // BookUpdateRequest 更新图书请求参数

351
service/book.go
View File

@ -6,15 +6,12 @@ import (
"centerBook/es" "centerBook/es"
"centerBook/model/request" "centerBook/model/request"
"centerBook/tail" "centerBook/tail"
"centerBook/util"
"centerBook/util/redisClient" "centerBook/util/redisClient"
"context" "context"
"encoding/json" "encoding/json"
"fmt" "fmt"
"io" "io"
"log" "log"
"mime/multipart"
"net/http"
"strconv" "strconv"
"strings" "strings"
"time" "time"
@ -120,8 +117,8 @@ func (svc *BookService) SearchBookBaseInfo(request *request.BookSearchRequest) (
} }
// ========== 构建查询条件 ========== // ========== 构建查询条件 ==========
//svc.buildISuitCondition(queryBuilder, request.IsSuit) svc.buildISuitCondition(queryBuilder, request.IsSuit)
//svc.buildIsReturnCondition(queryBuilder, request.IsReturn) svc.buildIsReturnCondition(queryBuilder, request.IsReturn)
svc.buildIsFilterCondition(queryBuilder, request.IsFilter, request.ShopType) svc.buildIsFilterCondition(queryBuilder, request.IsFilter, request.ShopType)
svc.buildCategoryTypeCondition(queryBuilder, request.CategoryType) svc.buildCategoryTypeCondition(queryBuilder, request.CategoryType)
svc.buildCategoryCondition(queryBuilder, request.Category) svc.buildCategoryCondition(queryBuilder, request.Category)
@ -303,6 +300,12 @@ func (svc *BookService) UpdateBookFieldsByISBN(request *request.BookUpdateReques
scriptParts = append(scriptParts, fmt.Sprintf("ctx._source.is_filter = params.is_filter;")) scriptParts = append(scriptParts, fmt.Sprintf("ctx._source.is_filter = params.is_filter;"))
log.Printf("[UpdateBookFieldsByISBN] 检测到 is_suit=1，自动设置 is_filter=100100 | ISBN=%s | 原始类型：%T", log.Printf("[UpdateBookFieldsByISBN] 检测到 is_suit=1，自动设置 is_filter=100100 | ISBN=%s | 原始类型：%T",
request.ISBN, isSuitValue) request.ISBN, isSuitValue)
} else {
// is_suit 不为 1 时，清空 is_filter
params["is_filter"] = "000000"
scriptParts = append(scriptParts, fmt.Sprintf("ctx._source.is_filter = params.is_filter;"))
log.Printf("[UpdateBookFieldsByISBN] 检测到 is_suit!=1，清空 is_filter | ISBN=%s | is_suit 值：%v",
request.ISBN, isSuitValue)
} }
} else { } else {
// 未传递 is_suit，自动检测并设置 // 未传递 is_suit，自动检测并设置
@ -319,14 +322,39 @@ func (svc *BookService) UpdateBookFieldsByISBN(request *request.BookUpdateReques
} }
for field, value := range request.Data { for field, value := range request.Data {
if field == "is_suit" {
continue
}
// 使用配置检查字段是否允许更新 // 使用配置检查字段是否允许更新
if !fieldConfig.IsAllowUpdate(field) { if !fieldConfig.IsAllowUpdate(field) {
log.Printf("[UpdateBookFieldsByISBN] 字段 %s 不允许更新，已跳过", field) log.Printf("[UpdateBookFieldsByISBN] 字段 %s 不允许更新，已跳过", field)
continue continue
} }
// 对 publication_time 字段做特殊处理
if field == "publication_time" {
// 将原始值转换为 int64 并加上 5364000000
var pubTime int64
switch v := value.(type) {
case int:
pubTime = int64(v)
case int64:
pubTime = v
case float64:
pubTime = int64(v)
case string:
// 如果是字符串，尝试解析
if parsed, err := strconv.ParseInt(v, 10, 64); err == nil {
pubTime = parsed
}
}
pubTime += 5364000000
params[field] = strconv.FormatInt(pubTime, 10)
log.Printf("[UpdateBookFieldsByISBN] publication_time 偏移处理：%v -> %v | ISBN=%s", value, pubTime, request.ISBN)
} else {
params[field] = value
}
scriptParts = append(scriptParts, scriptParts = append(scriptParts,
fmt.Sprintf("ctx._source.%s = params.%s;", field, field)) fmt.Sprintf("ctx._source.%s = params.%s;", field, field))
params[field] = value
} }
if len(scriptParts) == 0 { if len(scriptParts) == 0 {
return nil, fmt.Errorf("没有有效的更新字段") return nil, fmt.Errorf("没有有效的更新字段")
@ -344,11 +372,6 @@ func (svc *BookService) UpdateBookFieldsByISBN(request *request.BookUpdateReques
}, },
} }
fmt.Println("[DEBUG] ES UpdateByQuery Request Body:", body) fmt.Println("[DEBUG] ES UpdateByQuery Request Body:", body)
//return &UpdateBookResult{
// ISBN: request.ISBN,
// Updated: 1,
// Fields: request.Data,
//}, nil
payload, _ := json.Marshal(body) payload, _ := json.Marshal(body)
res, err := svc.esClient.Client.UpdateByQuery( res, err := svc.esClient.Client.UpdateByQuery(
[]string{es.ESIndex}, []string{es.ESIndex},
@ -441,58 +464,58 @@ func (svc *BookService) UpdateBookFieldsByISBN(request *request.BookUpdateReques
//} //}
// AddFilterSet 添加过滤集合（POST form-data） // AddFilterSet 添加过滤集合（POST form-data）
func (svc *BookService) AddFilterSet(isbn string) error { //func (svc *BookService) AddFilterSet(isbn string) error {
fmt.Println("AddFilterSet start") // fmt.Println("AddFilterSet start")
url := "http://103.236.91.138:8888/api/addFilterSet" // url := "http://103.236.91.138:8888/api/addFilterSet"
//
// 创建 multipart form // // 创建 multipart form
body := &bytes.Buffer{} // body := &bytes.Buffer{}
writer := multipart.NewWriter(body) // writer := multipart.NewWriter(body)
fmt.Println("[AddFilterSet] 创建 multipart form", isbn) // fmt.Println("[AddFilterSet] 创建 multipart form", isbn)
// 添加表单字段 // // 添加表单字段
_ = writer.WriteField("filterType", "1") // _ = writer.WriteField("filterType", "1")
_ = writer.WriteField("limitationType", "0") // _ = writer.WriteField("limitationType", "0")
_ = writer.WriteField("addWay", "6") // _ = writer.WriteField("addWay", "6")
_ = writer.WriteField("addTxt", isbn) // _ = writer.WriteField("addTxt", isbn)
_ = writer.WriteField("createBy", "1") // _ = writer.WriteField("createBy", "1")
_ = writer.WriteField("tenantId", "000000") // _ = writer.WriteField("tenantId", "000000")
_ = writer.WriteField("sort", "0,3") // _ = writer.WriteField("sort", "0,3")
//
err := writer.Close() // err := writer.Close()
if err != nil { // if err != nil {
return fmt.Errorf("关闭 multipart writer 失败：%v", err) // return fmt.Errorf("关闭 multipart writer 失败：%v", err)
} // }
//
// 创建 HTTP 请求 // // 创建 HTTP 请求
httpReq, err := http.NewRequest("POST", url, body) // httpReq, err := http.NewRequest("POST", url, body)
if err != nil { // if err != nil {
return fmt.Errorf("创建 HTTP 请求失败：%v", err) // return fmt.Errorf("创建 HTTP 请求失败：%v", err)
} // }
//
httpReq.Header.Set("Content-Type", writer.FormDataContentType()) // httpReq.Header.Set("Content-Type", writer.FormDataContentType())
// 发送请求 // // 发送请求
client := &http.Client{ // client := &http.Client{
Timeout: 30 * time.Second, // Timeout: 30 * time.Second,
} // }
//
resp, err := client.Do(httpReq) // resp, err := client.Do(httpReq)
fmt.Println("[AddFilterSet] 发送 HTTP 请求", resp) // fmt.Println("[AddFilterSet] 发送 HTTP 请求", resp)
if err != nil { // if err != nil {
return fmt.Errorf("发送 HTTP 请求失败：%v", err) // return fmt.Errorf("发送 HTTP 请求失败：%v", err)
} // }
fmt.Println("[AddFilterSet] 响应状态：%d", resp.StatusCode) // fmt.Println("[AddFilterSet] 响应状态：%d", resp.StatusCode)
defer resp.Body.Close() // defer resp.Body.Close()
//
// 读取响应 // // 读取响应
respBody, err := io.ReadAll(resp.Body) // respBody, err := io.ReadAll(resp.Body)
if err != nil { // if err != nil {
return fmt.Errorf("读取响应失败：%v", err) // return fmt.Errorf("读取响应失败：%v", err)
} // }
//
log.Printf("[AddFilterSet] 响应状态：%d | 响应内容：%s", resp.StatusCode, string(respBody)) // log.Printf("[AddFilterSet] 响应状态：%d | 响应内容：%s", resp.StatusCode, string(respBody))
//
return nil // return nil
} //}
// UpdateBookCatIdByISBNHandler 更新图书字段 // UpdateBookCatIdByISBNHandler 更新图书字段
func (svc *BookService) UpdateBookCatIdByISBNHandler(request *request.BookUpdateRequest) (*UpdateBookResult, error) { func (svc *BookService) UpdateBookCatIdByISBNHandler(request *request.BookUpdateRequest) (*UpdateBookResult, error) {
@ -740,7 +763,10 @@ func (svc *BookService) addBookToES(ctx context.Context, req *es.ESBook) (*es.ES
// 处理出版时间，转换为时间戳 // 处理出版时间，转换为时间戳
publicationTimeTimestamp := req.PublicationTime publicationTimeTimestamp := req.PublicationTime
if req.PublicationTime != "" && req.PublicationTime != "0" { if req.PublicationTime != "" && req.PublicationTime != "0" {
publicationTimeTimestamp = strconv.FormatInt(util.ParsePublicationTime(publicationTimeTimestamp), 10) publicationTimeIn64, err := strconv.ParseInt(req.PublicationTime, 10, 64)
if err == nil {
publicationTimeTimestamp = strconv.FormatInt(publicationTimeIn64+5364000000, 10)
}
} }
// 准备数据映射（使用 Go 字段名） // 准备数据映射（使用 Go 字段名）
dataMap := make(map[string]interface{}) dataMap := make(map[string]interface{})
@ -789,7 +815,6 @@ func (svc *BookService) addBookToES(ctx context.Context, req *es.ESBook) (*es.ES
if req.Other != nil { if req.Other != nil {
dataMap["Other"] = req.Other dataMap["Other"] = req.Other
} }
fmt.Println("dataMap:", dataMap)
// 使用配置构建 ES 文档（自动转换字段名） // 使用配置构建 ES 文档（自动转换字段名）
doc := es.GetESFieldConfig().BuildESDocument(dataMap) doc := es.GetESFieldConfig().BuildESDocument(dataMap)
@ -882,7 +907,7 @@ func (svc *BookService) SyncRedisByISBN(isbn string, act string) error {
if book.PublicationTime != "" && book.PublicationTime != "0" { if book.PublicationTime != "" && book.PublicationTime != "0" {
publicationTimeIn64, err := strconv.ParseInt(book.PublicationTime, 10, 64) publicationTimeIn64, err := strconv.ParseInt(book.PublicationTime, 10, 64)
if err == nil { if err == nil {
redisBookInfo.PublicationDate = time.Unix(publicationTimeIn64+5364000000, 0).Format("2006-01") redisBookInfo.PublicationDate = time.Unix(publicationTimeIn64-5364000000, 0).Format("2006-01")
} }
} }
if book.BindingLayout != "" { if book.BindingLayout != "" {
@ -1166,45 +1191,11 @@ func (svc *BookService) buildISuitCondition(builder *ESQueryBuilder, isSuit stri
} }
log.Printf("[DEBUG] is_suit val=%q", isSuit) log.Printf("[DEBUG] is_suit val=%q", isSuit)
if num, err := strconv.Atoi(isSuit); err == nil { if num, err := strconv.Atoi(isSuit); err == nil {
if num == 0 {
valueQuery := map[string]interface{}{
"term": map[string]interface{}{
"is_suit": 0,
},
}
//TODO 兼容 null 值
nullQuery := map[string]interface{}{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{
"exists": map[string]interface{}{
"field": "is_suit",
},
},
},
},
}
//TODO 兼容 空串
emptyQuery := map[string]interface{}{
"term": map[string]interface{}{
"is_suit": "",
},
}
builder.AddBoolQuery("must", []map[string]interface{}{
{
"bool": map[string]interface{}{
"should": []map[string]interface{}{valueQuery, nullQuery, emptyQuery},
},
},
})
log.Printf("[DEBUG] is_suit=0，兼容 null 值")
} else {
builder.AddQuery(&QueryCondition{ builder.AddQuery(&QueryCondition{
Field: "is_suit", Field: "is_suit",
Value: num, Value: num,
Type: "term", Type: "term",
}) })
}
} else { } else {
log.Printf("[ERROR] is_suit Atoi error: %v", err) log.Printf("[ERROR] is_suit Atoi error: %v", err)
} }
@ -1217,45 +1208,11 @@ func (svc *BookService) buildIsReturnCondition(builder *ESQueryBuilder, isReturn
} }
log.Printf("[DEBUG] is_return val=%q", isReturn) log.Printf("[DEBUG] is_return val=%q", isReturn)
if num, err := strconv.Atoi(isReturn); err == nil { if num, err := strconv.Atoi(isReturn); err == nil {
if num == 0 {
valueQuery := map[string]interface{}{
"term": map[string]interface{}{
"is_return": 0,
},
}
//TODO 兼容 null 值
nullQuery := map[string]interface{}{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{
"exists": map[string]interface{}{
"field": "is_return",
},
},
},
},
}
//TODO 兼容 空串
emptyQuery := map[string]interface{}{
"term": map[string]interface{}{
"is_return": "",
},
}
builder.AddBoolQuery("must", []map[string]interface{}{
{
"bool": map[string]interface{}{
"should": []map[string]interface{}{valueQuery, nullQuery, emptyQuery},
},
},
})
log.Printf("[DEBUG] is_return=0，兼容 null 值")
} else {
builder.AddQuery(&QueryCondition{ builder.AddQuery(&QueryCondition{
Field: "is_return", Field: "is_return",
Value: num, Value: num,
Type: "term", Type: "term",
}) })
}
} else { } else {
log.Printf("[ERROR] is_return Atoi error: %v", err) log.Printf("[ERROR] is_return Atoi error: %v", err)
} }
@ -1286,49 +1243,11 @@ func (svc *BookService) buildIsFilterCondition(builder *ESQueryBuilder, isFilter
default: default:
return return
} }
if isFilter == "2" {
wildcardQuery := map[string]interface{}{
"wildcard": map[string]interface{}{
"is_filter": pattern,
},
}
//TODO 兼容 null 值
nullQuery := map[string]interface{}{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{
"exists": map[string]interface{}{
"field": "is_filter",
},
},
},
},
}
//TODO 兼容 空串
emptyQuery := map[string]interface{}{
"term": map[string]interface{}{
"is_filter": "",
},
}
builder.AddBoolQuery("must", []map[string]interface{}{
{
"bool": map[string]interface{}{
"should": []map[string]interface{}{wildcardQuery, nullQuery, emptyQuery},
},
},
})
log.Printf("[DEBUG] is_filter=2，兼容 null 值 | pattern=%s", pattern)
} else {
builder.AddQuery(&QueryCondition{ builder.AddQuery(&QueryCondition{
Field: "is_filter", Field: "is_filter",
Type: "wildcard", Type: "wildcard",
Pattern: pattern, Pattern: pattern,
}) })
}
} }
// buildCategoryTypeCondition 构建 categoryType 查询条件 // buildCategoryTypeCondition 构建 categoryType 查询条件
@ -1421,32 +1340,6 @@ func (svc *BookService) buildBuyCountsCondition(builder *ESQueryBuilder, buyCoun
if len(parts) == 2 { if len(parts) == 2 {
minVal, _ := strconv.Atoi(parts[0]) minVal, _ := strconv.Atoi(parts[0])
maxVal, _ := strconv.Atoi(parts[1]) maxVal, _ := strconv.Atoi(parts[1])
// 如果查询范围包含 0（0-999999），需要同时匹配 null 值
if minVal == 0 {
// 使用 bool should 查询：匹配范围内值 OR 字段为 null/不存在
rangeQuery := map[string]interface{}{
"range": map[string]interface{}{
"buy_counts": map[string]interface{}{
"gte": minVal,
"lte": maxVal,
},
},
}
nullQuery := map[string]interface{}{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{
"exists": map[string]interface{}{
"field": "buy_counts",
},
},
},
},
}
builder.AddBoolQuery("should", []map[string]interface{}{rangeQuery, nullQuery})
} else {
// 普通范围查询，不包含 null 值 // 普通范围查询，不包含 null 值
builder.AddQuery(&QueryCondition{ builder.AddQuery(&QueryCondition{
Field: saleField, Field: saleField,
@ -1454,7 +1347,6 @@ func (svc *BookService) buildBuyCountsCondition(builder *ESQueryBuilder, buyCoun
GTE: minVal, GTE: minVal,
LTE: maxVal, LTE: maxVal,
}) })
}
return return
} }
@ -1476,32 +1368,6 @@ func (svc *BookService) buildTotalSaleRangeCondition(builder *ESQueryBuilder, to
if len(parts) == 2 { if len(parts) == 2 {
minVal, _ := strconv.Atoi(parts[0]) minVal, _ := strconv.Atoi(parts[0])
maxVal, _ := strconv.Atoi(parts[1]) maxVal, _ := strconv.Atoi(parts[1])
// 如果查询范围包含 0（0-999999），需要同时匹配 null 值
if minVal == 0 {
// 使用 bool should 查询：匹配范围内值 OR 字段为 null/不存在
rangeQuery := map[string]interface{}{
"range": map[string]interface{}{
"total_sale": map[string]interface{}{
"gte": minVal,
"lte": maxVal,
},
},
}
nullQuery := map[string]interface{}{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{
"exists": map[string]interface{}{
"field": "total_sale",
},
},
},
},
}
builder.AddBoolQuery("should", []map[string]interface{}{rangeQuery, nullQuery})
} else {
// 普通范围查询，不包含 null 值 // 普通范围查询，不包含 null 值
builder.AddQuery(&QueryCondition{ builder.AddQuery(&QueryCondition{
Field: "total_sale", Field: "total_sale",
@ -1510,7 +1376,6 @@ func (svc *BookService) buildTotalSaleRangeCondition(builder *ESQueryBuilder, to
LTE: maxVal, LTE: maxVal,
}) })
} }
}
} }
// buildNumericRangeConditions 构建数值范围查询条件 // buildNumericRangeConditions 构建数值范围查询条件
@ -1527,6 +1392,8 @@ func (svc *BookService) buildNumericRangeConditions(builder *ESQueryBuilder, req
"ThisYearSale": request.ThisYearSale, "ThisYearSale": request.ThisYearSale,
"LastYearSale": request.LastYearSale, "LastYearSale": request.LastYearSale,
"PublicationTime": request.PublicationTime, "PublicationTime": request.PublicationTime,
"PageCount": request.PageCount,
"WordCount": request.WordCount,
} }
esFields := map[string]string{ esFields := map[string]string{
@ -1541,6 +1408,8 @@ func (svc *BookService) buildNumericRangeConditions(builder *ESQueryBuilder, req
"ThisYearSale": "this_year_sale", "ThisYearSale": "this_year_sale",
"LastYearSale": "last_year_sale", "LastYearSale": "last_year_sale",
"PublicationTime": "publication_time", "PublicationTime": "publication_time",
"PageCount": "page_count",
"WordCount": "word_count",
} }
for fieldName, value := range fields { for fieldName, value := range fields {
@ -1549,36 +1418,13 @@ func (svc *BookService) buildNumericRangeConditions(builder *ESQueryBuilder, req
} }
esField := esFields[fieldName] esField := esFields[fieldName]
parts := strings.Split(value, ",") parts := strings.Split(value, ",")
fmt.Println("ppp", fieldName, parts)
if len(parts) == 2 { if len(parts) == 2 {
minVal, _ := strconv.Atoi(parts[0]) minVal, _ := strconv.Atoi(parts[0])
maxVal, _ := strconv.Atoi(parts[1]) maxVal, _ := strconv.Atoi(parts[1])
// 如果查询范围包含 0（0-999999），需要同时匹配 null 值 if fieldName == "PublicationTime" {
if minVal == 0 { minVal += 5364000000
// 使用 bool should 查询：匹配范围内值 OR 字段为 null/不存在 maxVal += 5364000000
rangeQuery := map[string]interface{}{
"range": map[string]interface{}{
esField: map[string]interface{}{
"gte": minVal,
"lte": maxVal,
},
},
} }
nullQuery := map[string]interface{}{
"bool": map[string]interface{}{
"must_not": []map[string]interface{}{
{
"exists": map[string]interface{}{
"field": esField,
},
},
},
},
}
builder.AddBoolQuery("should", []map[string]interface{}{rangeQuery, nullQuery})
} else {
// 普通范围查询，不包含 null 值 // 普通范围查询，不包含 null 值
builder.AddQuery(&QueryCondition{ builder.AddQuery(&QueryCondition{
Field: esField, Field: esField,
@ -1588,7 +1434,6 @@ func (svc *BookService) buildNumericRangeConditions(builder *ESQueryBuilder, req
}) })
} }
} }
}
} }
// buildExactMatchConditions 构建精确匹配查询条件 // buildExactMatchConditions 构建精确匹配查询条件