package es import ( "bufio" "bytes" "centerBook/image" "centerBook/kongfz" "centerBook/model/request" "centerBook/monitor" "centerBook/tail" "centerBook/util/redisClient" "context" "encoding/json" "fmt" "io" "log" "net/http" "strconv" "strings" "time" "github.com/gin-gonic/gin" jsoniter "github.com/json-iterator/go" "github.com/elastic/go-elasticsearch/v8/esapi" ) const ESIndex = "books-from-mysql-v3" // ESBookResponse 用于返回给Java客户端的格式，ID为简单的int64 type ESBookResponse struct { ID int64 `json:"id"` BookName string `json:"book_name"` BookPic map[string]interface{} `json:"book_pic"` BookPicS map[string]interface{} `json:"book_pic_s"` BookPicB string `json:"book_pic_b"` BookPicW map[string]interface{} `json:"book_pic_w"` BookDefPic map[string]interface{} `json:"book_def_pic"` // 自制官图，临时用 ISBN string `json:"isbn"` Author string `json:"author"` Category string `json:"category"` Publisher string `json:"publisher"` PublicationTime string `json:"publication_time"` BindingLayout string `json:"binding_layout"` FixPrice float64 `json:"fix_price"` Content string `json:"content"` IsSuit int `json:"is_suit"` DaySale7 int `json:"day_sale_7"` DaySale15 int `json:"day_sale_15"` DaySale30 int `json:"day_sale_30"` DaySale60 int `json:"day_sale_60"` DaySale90 int `json:"day_sale_90"` DaySale180 int `json:"day_sale_180"` DaySale365 int `json:"day_sale_365"` ThisYearSale int `json:"this_year_sale"` LastYearSale int `json:"last_year_sale"` TotalSale int `json:"total_sale"` BuyCounts int64 `json:"buy_counts"` SellCounts int64 `json:"sell_counts"` BookPicObj map[string]interface{} `json:"book_pic_obj"` BookPicObjS map[string]interface{} `json:"book_pic_obj_s"` UpdateTime NumberOrString `json:"update_time"` IsIllegal int `json:"is_illegal"` // 是否非法 示例 000000 IsReturn int `json:"is_return"` // 是否为驳回 示例 0 否 1 是 IsFilter string `json:"is_filter"` // 过滤字段 PageCount NumberOrString `json:"page_count"` // 页数 WordCount NumberOrString `json:"word_count"` // 字数 BookFormat NumberOrString `json:"book_format"` // 多少开 //CatId request.CatIdObject `json:"cat_id"` // 类目 Other map[string]interface{} `json:"other"` // 扩展字段，用于兼容未来新增字段 } // FlexibleString 处理可能是字符串或数组的字段 type FlexibleString struct { Value string } // NewFlexibleString 创建一个FlexibleString实例 func NewFlexibleString(value string) FlexibleString { return FlexibleString{Value: value} } func (f *FlexibleString) UnmarshalJSON(data []byte) error { // 尝试解析为单个字符串 var single string if err := json.Unmarshal(data, &single); err == nil { f.Value = single return nil } // 尝试解析为数组 var arr []string if err := json.Unmarshal(data, &arr); err == nil { if len(arr) > 0 { f.Value = arr[0] // 取第一个值 } return nil } return fmt.Errorf("cannot parse string: %s", string(data)) } // MarshalJSON 实现JSON序列化，返回字符串而不是对象 func (f *FlexibleString) MarshalJSON() ([]byte, error) { log.Printf("[FlexibleString MarshalJSON] 正在序列化: %s", f.Value) return json.Marshal(f.Value) } // FlexibleID 处理ID字段可能是数组或单个值的情况 type FlexibleID struct { Value int64 } // NewFlexibleID 创建一个FlexibleID实例 func NewFlexibleID(value int64) FlexibleID { return FlexibleID{Value: value} } func (f *FlexibleID) UnmarshalJSON(data []byte) error { // 尝试解析为单个数字 var single int64 if err := json.Unmarshal(data, &single); err == nil { f.Value = single return nil } // 尝试解析为数组 var arr []int64 if err := json.Unmarshal(data, &arr); err == nil { if len(arr) > 0 { f.Value = arr[0] // 取第一个值 } return nil } // 尝试解析为字符串数字 var str string if err := json.Unmarshal(data, &str); err == nil { if val, err := strconv.ParseInt(str, 10, 64); err == nil { f.Value = val return nil } } return fmt.Errorf("cannot parse ID: %s", string(data)) } // ConvertToResponse 将ESBook转换为ESBookResponse，处理ID字段转换 func (book *ESBook) ConvertToResponse() ESBookResponse { bookPicMap := map[string]interface{}{ "localPath": book.BookPic.LocalPath, "pddPath": book.BookPic.PddPath, } bookPicSMap := map[string]interface{}{ "localPath": book.BookPicS.LocalPath, "pddResponse": book.BookPicS.PddResponse, } bookDefPic := map[string]interface{}{ "localPath": book.BookDefPic.LocalPath, "pddPath": book.BookDefPic.PddPath, } publicationTime := book.PublicationTime if publicationTime == "" || publicationTime == "0" || publicationTime == "0000-00-00" { publicationTime = time.Unix(0, 0).Format("2006-01") } return ESBookResponse{ ID: book.ID, BookName: book.BookName.Value, BookPic: bookPicMap, BookPicS: bookPicSMap, BookPicB: book.BookPicB, BookPicW: book.BookPicW, BookDefPic: bookDefPic, ISBN: book.ISBN, Author: book.Author, Category: book.Category, Publisher: book.Publisher, PublicationTime: publicationTime, BindingLayout: book.BindingLayout, FixPrice: float64(book.FixPrice), Content: book.Content, IsSuit: book.IsSuit, DaySale7: book.DaySale7, DaySale15: book.DaySale15, DaySale30: book.DaySale30, DaySale60: book.DaySale60, DaySale90: book.DaySale90, DaySale180: book.DaySale180, DaySale365: book.DaySale365, ThisYearSale: book.ThisYearSale, LastYearSale: book.LastYearSale, TotalSale: book.TotalSale, BuyCounts: book.BuyCounts, SellCounts: book.SellCounts, BookPicObj: book.BookPicObj, BookPicObjS: book.BookPicObjS, UpdateTime: book.UpdateTime, IsIllegal: book.IsIllegal, IsReturn: book.IsReturn, IsFilter: book.IsFilter, PageCount: book.PageCount, WordCount: book.WordCount, BookFormat: book.BookFormat, //CatId: book.CatId, Other: book.Other, } } // 用于 book_pic type BookPicObj struct { LocalPath string `json:"localPath"` PddPath string `json:"pddPath"` } // 用于 book_pic_s type BookPicSObj struct { LocalPath string `json:"localPath"` PddResponse string `json:"pddResponse"` } // 用于 book_def_pic type BookDefPicObj struct { LocalPath string `json:"localPath"` PddPath string `json:"pddPath"` } type ESBook struct { ID int64 `json:"id,omitempty"` BookName FlexibleString `json:"book_name,omitempty"` BookPic BookPicObj `json:"book_pic,omitempty"` BookPicS BookPicSObj `json:"book_pic_s,omitempty"` BookPicB string `json:"book_pic_b,omitempty"` BookPicW map[string]interface{} `json:"book_pic_w,omitempty"` // 新增自制默认官图字段 BookDefPic BookDefPicObj `json:"book_def_pic,omitempty"` ISBN string `json:"isbn,omitempty"` Author string `json:"author,omitempty"` Category string `json:"category,omitempty"` Publisher string `json:"publisher,omitempty"` PublicationTime string `json:"publication_time,omitempty"` BindingLayout string `json:"binding_layout,omitempty"` FixPrice Float64OrString `json:"fix_price,omitempty"` Content string `json:"content,omitempty"` IsSuit int `json:"is_suit,omitempty"` // ⭐ 新增的字段 DaySale7 int `json:"day_sale_7,omitempty"` DaySale15 int `json:"day_sale_15,omitempty"` DaySale30 int `json:"day_sale_30,omitempty"` DaySale60 int `json:"day_sale_60,omitempty"` DaySale90 int `json:"day_sale_90,omitempty"` DaySale180 int `json:"day_sale_180,omitempty"` DaySale365 int `json:"day_sale_365,omitempty"` ThisYearSale int `json:"this_year_sale,omitempty"` LastYearSale int `json:"last_year_sale,omitempty"` TotalSale int `json:"total_sale,omitempty"` BuyCounts int64 `json:"buy_counts,omitempty"` SellCounts int64 `json:"sell_counts,omitempty"` BookPicObj map[string]interface{} `json:"book_pic_obj,omitempty"` BookPicObjS map[string]interface{} `json:"book_pic_obj_s,omitempty"` UpdateTime NumberOrString `json:"update_time,omitempty"` IsIllegal int `json:"is_illegal,omitempty"` // 是否非法 示例 000000 IsReturn int `json:"is_return,omitempty"` // 是否为驳回 示例 0 否 1 是 IsFilter string `json:"is_filter,omitempty"` // 过滤字段 PageCount NumberOrString `json:"page_count"` // 页数 WordCount NumberOrString `json:"word_count"` // 字数 BookFormat NumberOrString `json:"book_format"` // 多少开 CatId request.CatIdObject `json:"cat_id"` // 类目 Other map[string]interface{} `json:"other"` // 扩展字段，用于兼容未来新增字段 } // AddBookRequest 用于 Service 方法的入参 type AddBookRequest struct { BookName string `json:"book_name"` Author string `json:"author"` Publisher string `json:"publisher"` ISBN string `json:"isbn"` BookPic string `json:"book_pic"` BookPicS string `json:"book_pic_s"` BookPicNew string `json:"Book_pic_new"` BindingLayout string `json:"binding_layout"` FixPrice float64 `json:"fix_price"` PublicationTime string `json:"publication_time"` } // AddBookFullRequest 新的完整插入请求结构体，book_name强制为string类型 type AddBookFullRequest struct { BookName string `json:"book_name"` // 强制要求string类型 BookPic map[string]interface{} `json:"book_pic"` // 支持复杂对象 BookPicS map[string]interface{} `json:"book_pic_s"` // 支持复杂对象 BookPicB string `json:"book_pic_b"` // 大图地址 BookPicW map[string]interface{} `json:"book_pic_w"` // 水印图 ISBN string `json:"isbn"` // ISBN号 Author string `json:"author"` // 作者 Category string `json:"category"` // 分类 Publisher string `json:"publisher"` // 出版社 PublicationTime string `json:"publication_time"` // 出版时间 BindingLayout string `json:"binding_layout"` // 装帧 FixPrice float64 `json:"fix_price"` // 定价(分为单位) Content string `json:"content"` // 内容描述 IsSuit int `json:"is_suit"` // 是否套装: 0否, 1是 DaySale7 int `json:"day_sale_7"` // 7天销量 DaySale15 int `json:"day_sale_15"` // 15天销量 DaySale30 int `json:"day_sale_30"` // 30天销量 DaySale60 int `json:"day_sale_60"` // 60天销量 DaySale90 int `json:"day_sale_90"` // 90天销量 DaySale180 int `json:"day_sale_180"` // 180天销量 DaySale365 int `json:"day_sale_365"` // 365天销量 ThisYearSale int `json:"this_year_sale"` // 今年销量 LastYearSale int `json:"last_year_sale"` // 去年销量 TotalSale int `json:"total_sale"` // 总销量 BuyCounts int64 `json:"buy_counts"` // 购买次数 SellCounts int64 `json:"sell_counts"` // 售卖次数 BookPicObj map[string]interface{} `json:"book_pic_obj"` // 图片对象 BookPicObjS map[string]interface{} `json:"book_pic_obj_s"` // 小图对象 IsIllegal int `json:"is_illegal"` // 是否非法 示例 000000 IsReturn int `json:"is_return"` // 是否为驳回 示例 0 否 1 是 IsFilter string `json:"is_filter"` // 过滤字段 } type ESSearchService struct { ES *ESClient } type NumberOrString string func (n *NumberOrString) UnmarshalJSON(data []byte) error { s := strings.TrimSpace(string(data)) // 如果是数字（不以引号开头） if len(s) > 0 && s[0] != '"' { *n = NumberOrString(s) return nil } // 普通字符串 var str string if err := json.Unmarshal(data, &str); err != nil { return err } *n = NumberOrString(str) return nil } type Float64OrString float64 func (f *Float64OrString) UnmarshalJSON(b []byte) error { // 去掉空值 if string(b) == "null" || len(b) == 0 { *f = 0 return nil } // 尝试解析为 float var num float64 if err := json.Unmarshal(b, &num); err == nil { *f = Float64OrString(num) return nil } // 尝试解析为 string var str string if err := json.Unmarshal(b, &str); err == nil { if str == "" { *f = 0 return nil } parsed, err := strconv.ParseFloat(str, 64) if err != nil { return err } *f = Float64OrString(parsed) return nil } return fmt.Errorf("无法解析 fix_price: %s", string(b)) } func NewESSearchService(es *ESClient) *ESSearchService { return &ESSearchService{ES: es} } // validateBookPicObj 验证 BookPic 对象格式 func validateBookPicObj(bookPic map[string]interface{}, fieldName string) error { // 允许book_pic为nil，直接返回成功 if bookPic == nil { return nil } // 检查字段是否存在，不存在则使用默认空字符串 localPath, hasLocalPath := bookPic["localPath"] if !hasLocalPath { localPath = "" bookPic["localPath"] = "" } pddPath, hasPddPath := bookPic["pddPath"] if !hasPddPath { pddPath = "" bookPic["pddPath"] = "" } // 检查字段类型，允许空字符串，但必须是字符串类型 if _, ok := localPath.(string); !ok { return fmt.Errorf("%s localPath 必须为字符串类型", fieldName) } if _, ok := pddPath.(string); !ok { return fmt.Errorf("%s pddPath 必须为字符串类型", fieldName) } return nil } // validateBookPicSObj 验证 BookPicS 对象格式 func validateBookPicSObj(bookPicS map[string]interface{}, fieldName string) error { // 允许book_pic_s为nil，直接返回成功 if bookPicS == nil { return nil } // 检查字段是否存在，不存在则使用默认空字符串 localPath, hasLocalPath := bookPicS["localPath"] if !hasLocalPath { localPath = "" bookPicS["localPath"] = "" } pddResponse, hasPddResponse := bookPicS["pddResponse"] if !hasPddResponse { pddResponse = "" bookPicS["pddResponse"] = "" } // 检查字段类型，允许空字符串，但必须是字符串类型 if _, ok := localPath.(string); !ok { return fmt.Errorf("%s localPath 必须为字符串类型", fieldName) } if _, ok := pddResponse.(string); !ok { return fmt.Errorf("%s pddResponse 必须为字符串类型", fieldName) } return nil } // validateBookPicWObj 验证 BookPicW 对象格式 func validateBookPicWObj(bookPicW map[string]interface{}, fieldName string) error { if bookPicW == nil { return fmt.Errorf("%s 不能为 nil", fieldName) } // BookPicW 是任意对象，只需要验证不是空map if len(bookPicW) == 0 { return fmt.Errorf("%s 不能为空对象", fieldName) } return nil } // validateBookPicObjS 验证 BookPicObjS 对象格式（类似于 BookPicS） func validateBookPicObjS(bookPicObjS map[string]interface{}, fieldName string) error { return validateBookPicSObj(bookPicObjS, fieldName) } type esHitsWrapper struct { Hits struct { Total struct { Value int `json:"value"` } `json:"total"` Hits []struct { Index string `json:"_index"` ID string `json:"_id"` Source ESBook `json:"_source"` } `json:"hits"` } `json:"hits"` } // SearchBooks 搜索图书 func (svc *ESSearchService) SearchBooks(keyword string, endpoint ...string) ([]ESBook, error) { keyword = strings.TrimSpace(keyword) if keyword == "" { return []ESBook{}, nil } query := map[string]interface{}{ "_source": []string{ "id", "book_name", "book_pic", "book_pic_s", "isbn", "author", "category", "publisher", "publication_time", "binding_layout", "fix_price", "content", "update_time", }, "query": map[string]interface{}{ "multi_match": map[string]interface{}{ "query": keyword, "type": "best_fields", "fields": []string{"book_name^5", "isbn^10", "author^3"}, "fuzziness": "AUTO", }, }, } body, err := json.Marshal(query) if err != nil { return nil, fmt.Errorf("序列化请求失败: %v", err) } req := esapi.SearchRequest{ Index: []string{ESIndex}, Body: bytes.NewReader(body), TrackTotalHits: true, } // 如果有传入 endpoint，使用监控 var res *esapi.Response var duration time.Duration if len(endpoint) > 0 && endpoint[0] != "" { monitoredES := monitor.NewMonitoredESClient(svc.ES.Client, endpoint[0]) res, duration, err = monitoredES.Search(context.Background(), &req) log.Printf("[SearchBooks] ES 查询耗时：%dms", duration.Milliseconds()) } else { // 原有逻辑，不带监控 res, err = req.Do(context.Background(), svc.ES.Client.Transport) } if err != nil { return nil, fmt.Errorf("执行 ES 查询失败: %v", err) } defer res.Body.Close() if res.IsError() { return nil, fmt.Errorf("ES 返回错误: %s", res.String()) } var parsed esHitsWrapper if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil { return nil, fmt.Errorf("解析 ES 响应失败: %v", err) } list := make([]ESBook, 0, len(parsed.Hits.Hits)) for _, hit := range parsed.Hits.Hits { list = append(list, hit.Source) } return list, nil } // SearchBookByISBN 通过 ISBN 查询图书 func (svc *ESSearchService) SearchBookByISBN(isbn string) (*ESBook, error) { isbn = strings.TrimSpace(isbn) log.Printf("[SearchBookByISBN] 开始查询 | ISBN=%s", isbn) if isbn == "" { log.Printf("[SearchBookByISBN] ISBN 为空，取消查询") return nil, fmt.Errorf("ISBN 不能为空") } query := map[string]interface{}{ "query": map[string]interface{}{ "term": map[string]interface{}{ "isbn": isbn, // 精准匹配 }, }, "_source": true, } body, err := json.Marshal(query) if err != nil { log.Printf("[SearchBookByISBN] 构建查询 JSON 失败: %v", err) return nil, fmt.Errorf("构建查询 JSON 失败: %v", err) } // 执行查询 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), ) if err != nil { log.Printf("[SearchBookByISBN] ES 查询失败: %v", err) return nil, fmt.Errorf("ES 查询失败: %v", err) } defer res.Body.Close() //log.Printf("[SearchBookByISBN] ES 响应: %s", res.String()) if res.IsError() { log.Printf("[SearchBookByISBN] ES 返回错误: %s", res.String()) return nil, fmt.Errorf("ES 返回错误: %s", res.String()) } var parsed esHitsWrapper if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil { log.Printf("[SearchBookByISBN] 解析 ES 返回失败: %v", err) return nil, fmt.Errorf("解析 ES 返回失败: %v", err) } if len(parsed.Hits.Hits) == 0 { log.Printf("[SearchBookByISBN] 未找到 ISBN=%s 对应文档", isbn) return nil, nil } // 取第一条结果 book := parsed.Hits.Hits[0].Source //log.Printf("[SearchBookByISBN] 查询到文档: %+v", book) return &book, nil } func (svc *ESSearchService) SearchBookByBookName(bookName string) ([]ESBook, error) { bookName = strings.TrimSpace(bookName) if bookName == "" { return nil, fmt.Errorf("bookName 不能为空") } query := map[string]interface{}{ "_source": true, "query": map[string]interface{}{ "match": map[string]interface{}{ "book_name": map[string]interface{}{ "query": bookName, "operator": "and", "fuzziness": "AUTO", }, }, }, } body, _ := json.Marshal(query) 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), ) if err != nil { return nil, fmt.Errorf("ES 查询失败: %v", err) } defer res.Body.Close() if res.IsError() { return nil, fmt.Errorf("ES 返回错误: %s", res.String()) } var parsed esHitsWrapper if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil { return nil, fmt.Errorf("解析 ES 返回失败: %v", err) } list := make([]ESBook, 0, len(parsed.Hits.Hits)) for _, hit := range parsed.Hits.Hits { list = append(list, hit.Source) } return list, nil } // SearchBooksAllFields 单字段匹配 func (svc *ESSearchService) SearchBooksAllFields(keyword string) ([]ESBook, error) { keyword = strings.TrimSpace(keyword) if keyword == "" { return []ESBook{}, nil } query := map[string]interface{}{ "_source": true, "query": map[string]interface{}{ "multi_match": map[string]interface{}{ "query": keyword, "type": "best_fields", // 使用最佳字段评分模式 "fields": []string{ "id^1", "book_name^5", "book_pic^1", "book_pic_s^1", "isbn^10", "author^4", "category^2", "publisher^3", "publication_time^1", "binding_layout^1", "fix_price^1", "content^1", "update_time^1", }, "fuzziness": "AUTO", // 自动纠错/模糊匹配 }, }, } body, _ := json.Marshal(query) 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), ) if err != nil { return nil, fmt.Errorf("执行 ES 查询失败: %v", err) } defer res.Body.Close() if res.IsError() { return nil, fmt.Errorf("ES 返回错误: %s", res.String()) } var parsed esHitsWrapper if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil { return nil, fmt.Errorf("解析 ES 响应失败: %v", err) } list := make([]ESBook, 0, len(parsed.Hits.Hits)) for _, hit := range parsed.Hits.Hits { list = append(list, hit.Source) } return list, nil } // SearchBooksByConditions 多字段AND搜索 func (svc *ESSearchService) SearchBooksByConditions(conds map[string]string, page, pageSize int) ([]ESBook, int, error) { mustQueries := make([]map[string]interface{}, 0) for field, value := range conds { value = strings.TrimSpace(value) if value == "" { continue } // 特殊处理 day_sale_30 做范围查询 if field == "day_sale_30" { // 这里假设前端传入 "1"，表示查询 >1 if v, err := strconv.Atoi(value); err == nil { mustQueries = append(mustQueries, map[string]interface{}{ "range": map[string]interface{}{ "day_sale_30": map[string]interface{}{ "gt": v, }, }, }) } continue } // 其他字段用 match 查询 mustQueries = append(mustQueries, map[string]interface{}{ "match": map[string]interface{}{ field: map[string]interface{}{ "query": value, "operator": "and", "fuzziness": "AUTO", }, }, }) } if len(mustQueries) == 0 { return []ESBook{}, 0, nil } from := (page - 1) * pageSize query := map[string]interface{}{ "_source": true, "from": from, "size": pageSize, "query": map[string]interface{}{ "bool": map[string]interface{}{ "must": mustQueries, }, }, } body, _ := json.Marshal(query) 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), ) if err != nil { return nil, 0, fmt.Errorf("ES 查询失败: %v", err) } defer res.Body.Close() if res.IsError() { return nil, 0, fmt.Errorf("ES 错误: %s", res.String()) } var parsed esHitsWrapper if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil { return nil, 0, fmt.Errorf("解析失败: %v", err) } list := make([]ESBook, 0, len(parsed.Hits.Hits)) for _, hit := range parsed.Hits.Hits { list = append(list, hit.Source) } return list, parsed.Hits.Total.Value, nil } // CountByIDRange 统计 ID 范围内的数量 func (svc *ESSearchService) CountByIDRange(minID, maxID int) (int, error) { query := map[string]interface{}{ "query": map[string]interface{}{ "range": map[string]interface{}{ "id": map[string]interface{}{ "gte": minID, "lte": maxID, }, }, }, } body, _ := json.Marshal(query) res, err := svc.ES.Client.Count( svc.ES.Client.Count.WithIndex(ESIndex), svc.ES.Client.Count.WithBody(bytes.NewReader(body)), ) if err != nil { return 0, err } defer res.Body.Close() if res.IsError() { return 0, fmt.Errorf("ES 错误: %s", res.String()) } var resp struct { Count int `json:"count"` } if err := json.NewDecoder(res.Body).Decode(&resp); err != nil { return 0, err } return resp.Count, nil } // UpdateBookPicByISBN 根据 ISBN 更新 ES 文档的图片字段 // 功能：更新 `book_pic` 与 `book_pic_s` 字段（任意一个或两个） // 入参： // - isbn: 目标文档的 ISBN（精确匹配） // - bookPic: 新的大图地址（可为空，空则不更新该字段） // - bookPicS: 新的小图地址（可为空，空则不更新该字段） // 返回：成功更新的文档数量 func (svc *ESSearchService) UpdateBookPicByISBN(isbn, bookPic, bookPicS string) (int, error) { isbn = strings.TrimSpace(isbn) if isbn == "" { return 0, fmt.Errorf("ISBN 不能为空") } // 构建脚本：仅对提供的字段进行更新 scriptParts := make([]string, 0, 2) if strings.TrimSpace(bookPic) != "" { scriptParts = append(scriptParts, "ctx._source.book_pic = params.book_pic;") } if strings.TrimSpace(bookPicS) != "" { scriptParts = append(scriptParts, "ctx._source.book_pic_s = params.book_pic_s;") } if len(scriptParts) == 0 { return 0, fmt.Errorf("至少提供 book_pic 或 book_pic_s 其中之一") } source := strings.Join(scriptParts, " ") body := map[string]interface{}{ "script": map[string]interface{}{ "source": source, "lang": "painless", "params": map[string]interface{}{ "book_pic": bookPic, "book_pic_s": bookPicS, }, }, "query": map[string]interface{}{ "term": map[string]interface{}{ "isbn": isbn, }, }, } payload, _ := json.Marshal(body) res, err := svc.ES.Client.UpdateByQuery( []string{ESIndex}, svc.ES.Client.UpdateByQuery.WithBody(bytes.NewReader(payload)), svc.ES.Client.UpdateByQuery.WithRefresh(true), svc.ES.Client.UpdateByQuery.WithConflicts("proceed"), ) if err != nil { return 0, fmt.Errorf("ES UpdateByQuery 执行失败: %v", err) } defer res.Body.Close() if res.IsError() { return 0, fmt.Errorf("ES 返回错误: %s", res.String()) } // 解析更新数量 var parsed struct { Total int `json:"total"` Updated int `json:"updated"` VersionConflicts int `json:"version_conflicts"` } if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil { return 0, fmt.Errorf("解析 ES UpdateByQuery 响应失败: %v", err) } return parsed.Updated, nil } // UpdateSellCountsByISBN 根据 ISBN 更新 ES 文档的 sell_counts 字段 // 功能：将指定 ISBN 的文档字段 `sell_counts` 更新为给定值 // 入参： // - isbn: 精确匹配目标文档的 ISBN // - sellCounts: 在售数量（非负整数） // 返回：成功更新的文档数量 func (svc *ESSearchService) UpdateSellCountsByISBN(isbn string, sellCounts int) (int, error) { isbn = strings.TrimSpace(isbn) if isbn == "" { return 0, fmt.Errorf("ISBN 不能为空") } if sellCounts < 0 { return 0, fmt.Errorf("sell_counts 不可为负数") } body := map[string]interface{}{ "script": map[string]interface{}{ "source": "ctx._source.sell_counts = params.sell_counts;", "lang": "painless", "params": map[string]interface{}{ "sell_counts": sellCounts, }, }, "query": map[string]interface{}{ "term": map[string]interface{}{ "isbn": isbn, }, }, } payload, _ := json.Marshal(body) res, err := svc.ES.Client.UpdateByQuery( []string{ESIndex}, svc.ES.Client.UpdateByQuery.WithBody(bytes.NewReader(payload)), svc.ES.Client.UpdateByQuery.WithRefresh(true), svc.ES.Client.UpdateByQuery.WithConflicts("proceed"), ) if err != nil { return 0, fmt.Errorf("ES UpdateByQuery 执行失败: %v", err) } defer res.Body.Close() if res.IsError() { return 0, fmt.Errorf("ES 返回错误: %s", res.String()) } var parsed struct { Total int `json:"total"` Updated int `json:"updated"` VersionConflicts int `json:"version_conflicts"` } if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil { return 0, fmt.Errorf("解析 ES UpdateByQuery 响应失败: %v", err) } return parsed.Updated, nil } // UpdateSellCountsByISBNHandler 根据请求的 ISBN 调用外部接口获取在售数量并更新 ES // 功能： // 1) 读取 `isbn` 参数； // 2) 调用 tail.GetOnSaleCount 获取在售数量； // 3) 调用 UpdateSellCountsByISBN 更新 ES； // 4) 返回更新结果与在售数量。 func (svc *ESSearchService) UpdateSellCountsByISBNHandler(c *gin.Context) { // 异步执行：立即返回成功，后台更新 ES isbn := strings.TrimSpace(c.Query("isbn")) if isbn == "" { c.JSON(200, gin.H{"code": 200, "message": "success", "data": gin.H{}}) return } // 获取在售数量（容错 data:{}） onSaleCount, err := tail.GetOnSaleCount(isbn) log.Printf("[Async] 获取在售数量 | ISBN=%s | count=%d", isbn, onSaleCount) if err != nil { c.JSON(500, gin.H{"error": "获取在售数量失败", "details": err.Error()}) return } if onSaleCount == 0 { c.JSON(200, gin.H{"code": 200, "message": "success", "data": gin.H{}}) return } // 后台异步更新 go func(isbn string, count int) { updated, err := svc.UpdateSellCountsByISBN(isbn, count) if err != nil { log.Printf("[Async] 更新 ES 失败 | ISBN=%s | err=%v", isbn, err) return } log.Printf("[Async] 更新 ES 成功 | ISBN=%s | sell_counts=%d | updated=%d", isbn, count, updated) }(isbn, onSaleCount) // 立即返回成功，携带异步提示 c.JSON(200, gin.H{ "code": 200, "message": "success", "data": gin.H{"isbn": isbn, "on_sale_count": onSaleCount, "async": true}, }) } // UpdateSellCountsDirectHandler 直接按入参异步更新 ES 的在售数量 // 功能： // - 从请求中读取 `isbn` 与 `onSaleCount`； // - 校验参数（ISBN 非空、onSaleCount >= 0 且为整数）； // - 后台异步调用 ES 更新 `sell_counts` 字段； // - 立即返回标准成功结构，包含 async 提示；当 onSaleCount=0 时直接返回 success 不更新。 func (svc *ESSearchService) UpdateSellCountsDirectHandler(c *gin.Context) { isbn := strings.TrimSpace(c.Query("isbn")) countStr := strings.TrimSpace(c.Query("onSaleCount")) if isbn == "" { c.JSON(400, gin.H{"error": "缺少 isbn 参数"}) return } if countStr == "" { c.JSON(400, gin.H{"error": "缺少 onSaleCount 参数"}) return } count, err := strconv.Atoi(countStr) if err != nil { c.JSON(400, gin.H{"error": "onSaleCount 必须为整数", "details": err.Error()}) return } if count < 0 { c.JSON(400, gin.H{"error": "onSaleCount 不可为负数"}) return } // 如果为 0，直接返回 success，不做更新 if count == 0 { c.JSON(200, gin.H{"code": 200, "message": "success", "data": gin.H{}}) return } // 后台异步更新 ES 的 sell_counts 字段 go func(isbn string, c int) { updated, err := svc.UpdateSellCountsByISBN(isbn, c) if err != nil { log.Printf("[Async] 直接更新 ES 失败 | ISBN=%s | err=%v", isbn, err) return } log.Printf("[Async] 直接更新 ES 成功 | ISBN=%s | sell_counts=%d | updated=%d", isbn, c, updated) }(isbn, count) // 立即返回成功，携带异步提示 c.JSON(200, gin.H{ "code": 200, "message": "success", "data": gin.H{"isbn": isbn, "sell_counts": count, "async": true}, }) } // SearchBookBaseInfoES 根据条件查询 ES 图书信息 func (svc *ESSearchService) SearchBookBaseInfoES(c *gin.Context) ([]ESBook, int, error) { q := c.Request.URL.Query() must := make([]map[string]interface{}, 0) // ES 字段映射 snakeMap := map[string]string{ "bookName": "book_name", "bookPic": "book_pic", "publication_times": "publication_time", "isSuit": "is_suit", } // ===== saleSelect 对应字段映射 ===== saleSelect := c.DefaultQuery("saleSelect", "") saleField := map[string]string{ "7": "day_sale_7", "15": "day_sale_15", "30": "day_sale_30", "60": "day_sale_60", "90": "day_sale_90", "180": "day_sale_180", "365": "day_sale_365", "0": "this_year_sale", "1": "last_year_sale", }[saleSelect] fmt.Printf("[DEBUG] saleSelect=%s saleField=%s\n", saleSelect, saleField) // saleField >= 1 默认条件 if saleField != "" { cond := map[string]interface{}{ "range": map[string]interface{}{ saleField: map[string]interface{}{"gte": 1}, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) } // per_page → pageSize if perPage := c.Query("per_page"); perPage != "" { q.Set("pageSize", perPage) } // ========== 遍历参数 ========== for key, vals := range q { val := strings.TrimSpace(vals[0]) if val == "" { continue } if key == "page" || key == "pageSize" || key == "per_page" || key == "saleSelect" || key == "picType" || key == "shopType" { continue } // 忽略无用字段 if key == "is_pricing" || key == "vio_book" || key == "book_set" || key == "onenum_mbooks" || key == "ill_publisher" || key == "ill_author" { continue } originalKey := key fmt.Printf("[DEBUG] Processing key=%s val=%s\n", key, val) // 字段映射 if nk, ok := snakeMap[key]; ok { key = nk } // ===== is_suit ===== if key == "is_suit" { fmt.Printf("[DEBUG] is_suit val=%q\n", val) if num, err := strconv.Atoi(val); err == nil { cond := map[string]interface{}{ "term": map[string]interface{}{"is_suit": num}, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) } else { fmt.Printf("[ERROR] is_suit Atoi error: %v\n", err) } continue } // ===== is_return ===== if key == "is_return" { fmt.Printf("[DEBUG] is_return val=%q\n", val) if num, err := strconv.Atoi(val); err == nil { cond := map[string]interface{}{ "term": map[string]interface{}{"is_return": num}, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) } else { fmt.Printf("[ERROR] is_return Atoi error: %v\n", err) } continue } // ===== is_filter ===== // ===== is_filter（按 shopType 位匹配）===== // ===== is_filter（按 shopType 位匹配）===== if key == "is_filter" { fmt.Printf("[DEBUG] is_filter val=%q\n", val) // 只处理 1（=1） 和 2（=0） if val != "1" && val != "2" { continue } shopType := c.DefaultQuery("shopType", "") var pattern string // val=1 -> 位=1 // val=2 -> 位=0 targetBit := "1" if val == "2" { targetBit = "0" } switch shopType { case "0": pattern = targetBit + "*" case "1": pattern = "?" + targetBit + "*" case "2": pattern = "??" + targetBit + "*" case "3": pattern = "???" + targetBit + "*" default: continue } cond := map[string]interface{}{ "wildcard": map[string]interface{}{ "is_filter": pattern, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== categoryType ===== if originalKey == "categoryType" { var cond map[string]interface{} if val == "1" { cond = map[string]interface{}{ "prefix": map[string]interface{}{"isbn": "9787"}, } } else { cond = map[string]interface{}{ "bool": map[string]interface{}{ "must_not": []map[string]interface{}{ {"prefix": map[string]interface{}{"isbn": "9787"}}, }, }, } } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== category ===== if key == "category" { var cond map[string]interface{} if val == "排除大学教材" { cond = map[string]interface{}{ "bool": map[string]interface{}{ "must_not": []map[string]interface{}{ {"match_phrase": map[string]interface{}{ "category": "图书/教材教辅考试/大学教材", }}, }, }, } } else { cond = map[string]interface{}{ "match_phrase": map[string]interface{}{"category": val}, } } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===================================================== // ========== ★★★ book_pic + picType 联动逻辑 ★★★ ========== // ===================================================== if key == "book_pic" { picType := c.DefaultQuery("picType", "1") // 默认官图 var targetField string if picType == "1" { targetField = "book_pic.pddPath" } else { targetField = "book_pic_s.pddResponse" } var cond map[string]interface{} if val == "1" { // 有图：字段必须存在且非空 cond = map[string]interface{}{ "bool": map[string]interface{}{ "must": []map[string]interface{}{ {"exists": map[string]interface{}{"field": targetField}}, {"wildcard": map[string]interface{}{ targetField: "*", }}, }, }, } } else { // 无图：使用keyword字段查询字段不存在或为空字符串 var keywordField string if picType == "1" { keywordField = "book_pic.pddPath.keyword" } else { keywordField = "book_pic_s.pddResponse.keyword" } cond = map[string]interface{}{ "bool": map[string]interface{}{ "should": []map[string]interface{}{ // 情况1：字段完全不存在 { "bool": map[string]interface{}{ "must_not": []map[string]interface{}{ {"exists": map[string]interface{}{"field": keywordField}}, }, }, }, // 情况2：keyword字段存在但为空字符串 { "term": map[string]interface{}{ keywordField: "", }, }, }, "minimum_should_match": 1, }, } } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== buy_counts → saleField ===== if key == "buy_counts" { fmt.Printf("[DEBUG] buy_counts uses saleField=%s\n", saleField) if saleField == "" { continue } 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{}{ saleField: map[string]interface{}{ "gte": minVal, "lte": maxVal, }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } if num, err := strconv.Atoi(val); err == nil { cond := map[string]interface{}{ "range": map[string]interface{}{ saleField: map[string]interface{}{ "gte": num, }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } } // ===== totalSale_range ===== if key == "totalSale_range" { 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{}{ "total_sale": map[string]interface{}{ "gte": minVal, "lte": maxVal, }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } } // ===== 数值范围 ===== if key == "sell_counts" || strings.HasPrefix(key, "day_sale_") || key == "this_year_sale" || key == "last_year_sale" || key == "publication_time" { 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{}{ key: map[string]interface{}{ "gte": minVal, "lte": maxVal, }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } } // ===== 精确匹配 ===== if key == "isbn" || key == "id" || key == "publisher" { cond := map[string]interface{}{ "term": map[string]interface{}{key: val}, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== 模糊匹配 ===== if key == "book_name" || key == "author" { cond := map[string]interface{}{ "match": map[string]interface{}{ key: map[string]interface{}{ "query": val, "operator": "and", "fuzziness": "AUTO", }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== 默认前缀匹配 ===== cond := map[string]interface{}{ "prefix": map[string]interface{}{key: val}, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) } // ========== 分页 ========== page, _ := strconv.Atoi(c.DefaultQuery("page", "1")) pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", c.DefaultQuery("per_page", "10"))) from := (page - 1) * pageSize // ========== pageSize大于500则根据id查询 ========= fmt.Printf("[DEBUG] page=%d pageSize=%d from=%d\n", page, pageSize, from) var sort []map[string]interface{} if pageSize >= 500 { sort = []map[string]interface{}{ {"id": map[string]interface{}{"order": "asc"}}, } } else { sort = []map[string]interface{}{ {"update_time": map[string]interface{}{"order": "desc"}}, } } // ========== 构建 ES 查询 ========== query := map[string]interface{}{ "from": from, "size": pageSize, "query": map[string]interface{}{ "bool": map[string]interface{}{ "must": must, }, }, "sort": sort, } body, _ := json.MarshalIndent(query, "", " ") 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), ) if err != nil { fmt.Printf("[ERROR] ES.Client.Search error: %v\n", err) return nil, 0, err } 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 // 使用CopyBuffer可以重用缓冲区 writer := bufio.NewWriterSize(&buf, 8192) _, err = io.Copy(writer, res.Body) if err != nil { return nil, 0, fmt.Errorf("复制响应数据失败: %v", err) } rawData := buf.Bytes() //rawData, err := io.ReadAll(res.Body) if err != nil { return nil, 0, fmt.Errorf("读取响应失败: %v", err) } // 检查是否有数据 if len(rawData) == 0 { return nil, 0, fmt.Errorf("ES返回空响应") } // 验证是否是有效的JSON if rawData[0] != '{' { return nil, 0, fmt.Errorf("ES返回非JSON响应: %s", string(rawData[:min(100, len(rawData))])) } fmt.Println("[DEBUG] ES query executed successfully") var _json = jsoniter.ConfigCompatibleWithStandardLibrary var parsed esHitsWrapper if err := _json.Unmarshal(rawData, &parsed); err != nil { 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)) for _, hit := range parsed.Hits.Hits { list = append(list, hit.Source) } return list, parsed.Hits.Total.Value, nil } func (svc *ESSearchService) BatchGetBookBaseInfoES(c *gin.Context) ([]ESBook, int, error) { q := c.Request.URL.Query() must := make([]map[string]interface{}, 0) // ES 字段映射 snakeMap := map[string]string{ "bookName": "book_name", "bookPic": "book_pic", "publication_times": "publication_time", "isSuit": "is_suit", } // ===== saleSelect 对应字段映射 ===== saleSelect := c.DefaultQuery("saleSelect", "") saleField := map[string]string{ "7": "day_sale_7", "15": "day_sale_15", "30": "day_sale_30", "60": "day_sale_60", "90": "day_sale_90", "180": "day_sale_180", "365": "day_sale_365", "0": "this_year_sale", "1": "last_year_sale", }[saleSelect] fmt.Printf("[DEBUG] saleSelect=%s saleField=%s\n", saleSelect, saleField) // saleField >= 1 默认条件 if saleField != "" { cond := map[string]interface{}{ "range": map[string]interface{}{ saleField: map[string]interface{}{"gte": 1}, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) } // per_page → pageSize if perPage := c.Query("per_page"); perPage != "" { q.Set("pageSize", perPage) } // ========== 遍历参数 ========== for key, vals := range q { val := strings.TrimSpace(vals[0]) if val == "" { continue } // 不作为查询条件的字段 if key == "page" || key == "pageSize" || key == "per_page" || key == "saleSelect" || key == "picType" || key == "shopType" { continue } // 忽略无用字段 if key == "is_pricing" || key == "vio_book" || key == "book_set" || key == "onenum_mbooks" || key == "ill_publisher" || key == "ill_author" { continue } originalKey := key fmt.Printf("[DEBUG] Processing key=%s val=%s\n", key, val) // 字段映射 if nk, ok := snakeMap[key]; ok { key = nk } // ===== is_suit ===== if key == "is_suit" { fmt.Printf("[DEBUG] is_suit val=%q\n", val) if num, err := strconv.Atoi(val); err == nil { cond := map[string]interface{}{ "term": map[string]interface{}{"is_suit": num}, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) } else { fmt.Printf("[ERROR] is_suit Atoi error: %v\n", err) } continue } // ===== is_return ===== if key == "is_return" { fmt.Printf("[DEBUG] is_return val=%q\n", val) if num, err := strconv.Atoi(val); err == nil { cond := map[string]interface{}{ "term": map[string]interface{}{"is_return": num}, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) } else { fmt.Printf("[ERROR] is_return Atoi error: %v\n", err) } continue } // ===== is_filter ===== // ===== is_filter（按 shopType 位匹配）===== if key == "is_filter" { fmt.Printf("[DEBUG] is_filter val=%q\n", val) // 只处理 1（=1） 和 2（=0） if val != "1" && val != "2" { continue } shopType := c.DefaultQuery("shopType", "") var pattern string // val=1 -> 位=1 // val=2 -> 位=0 targetBit := "1" if val == "2" { targetBit = "0" } switch shopType { case "0": pattern = targetBit + "*" case "1": pattern = "?" + targetBit + "*" case "2": pattern = "??" + targetBit + "*" case "3": pattern = "???" + targetBit + "*" default: continue } cond := map[string]interface{}{ "wildcard": map[string]interface{}{ "is_filter": pattern, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== categoryType ===== if originalKey == "categoryType" { var cond map[string]interface{} if val == "1" { cond = map[string]interface{}{ "prefix": map[string]interface{}{"isbn": "9787"}, } } else { cond = map[string]interface{}{ "bool": map[string]interface{}{ "must_not": []map[string]interface{}{ {"prefix": map[string]interface{}{"isbn": "9787"}}, }, }, } } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== category ===== if key == "category" { var cond map[string]interface{} if val == "排除大学教材" { cond = map[string]interface{}{ "bool": map[string]interface{}{ "must_not": []map[string]interface{}{ {"match_phrase": map[string]interface{}{ "category": "图书/教材教辅考试/大学教材", }}, }, }, } } else { cond = map[string]interface{}{ "match_phrase": map[string]interface{}{"category": val}, } } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===================================================== // ========== ★★★ book_pic + picType 联动逻辑 ★★★ ========== // ===================================================== if key == "book_pic" { picType := c.DefaultQuery("picType", "1") // 默认官图 var targetField string if picType == "1" { targetField = "book_pic.pddPath" } else { targetField = "book_pic_s.pddResponse" } var cond map[string]interface{} if val == "1" { // 有图：字段必须存在且非空 cond = map[string]interface{}{ "bool": map[string]interface{}{ "must": []map[string]interface{}{ {"exists": map[string]interface{}{"field": targetField}}, {"wildcard": map[string]interface{}{ targetField: "*", }}, }, }, } } else { // 无图：使用keyword字段查询字段不存在或为空字符串 var keywordField string if picType == "1" { keywordField = "book_pic.pddPath.keyword" } else { keywordField = "book_pic_s.pddResponse.keyword" } cond = map[string]interface{}{ "bool": map[string]interface{}{ "should": []map[string]interface{}{ // 情况1：字段完全不存在 { "bool": map[string]interface{}{ "must_not": []map[string]interface{}{ {"exists": map[string]interface{}{"field": keywordField}}, }, }, }, // 情况2：keyword字段存在但为空字符串 { "term": map[string]interface{}{ keywordField: "", }, }, }, "minimum_should_match": 1, }, } } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== buy_counts → saleField ===== if key == "buy_counts" { fmt.Printf("[DEBUG] buy_counts uses saleField=%s\n", saleField) if saleField == "" { continue } 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{}{ saleField: map[string]interface{}{ "gte": minVal, "lte": maxVal, }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } if num, err := strconv.Atoi(val); err == nil { cond := map[string]interface{}{ "range": map[string]interface{}{ saleField: map[string]interface{}{ "gte": num, }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } } // ===== totalSale_range ===== if key == "totalSale_range" { 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{}{ "total_sale": map[string]interface{}{ "gte": minVal, "lte": maxVal, }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } } // ===== 数值范围 ===== if key == "sell_counts" || strings.HasPrefix(key, "day_sale_") || key == "this_year_sale" || key == "last_year_sale" || key == "publication_time" { 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{}{ key: map[string]interface{}{ "gte": minVal, "lte": maxVal, }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } } // ===== 精确匹配 ===== if key == "isbn" || key == "id" || key == "publisher" { cond := map[string]interface{}{ "term": map[string]interface{}{key: val}, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== 模糊匹配 ===== if key == "book_name" || key == "author" { cond := map[string]interface{}{ "match": map[string]interface{}{ key: map[string]interface{}{ "query": val, "operator": "and", "fuzziness": "AUTO", }, }, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) continue } // ===== 默认前缀匹配 ===== cond := map[string]interface{}{ "prefix": map[string]interface{}{key: val}, } must = append(must, cond) fmt.Printf("[DEBUG] must += %v\n", cond) } // ========== 分页 ========== page, _ := strconv.Atoi(c.DefaultQuery("page", "1")) pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", c.DefaultQuery("per_page", "10"))) from := (page - 1) * pageSize // ========== pageSize大于500则根据id查询 ========= fmt.Printf("[DEBUG] page=%d pageSize=%d from=%d\n", page, pageSize, from) var sort []map[string]interface{} if pageSize >= 500 { sort = []map[string]interface{}{ {"id": map[string]interface{}{"order": "asc"}}, } } else { sort = []map[string]interface{}{ {"update_time": map[string]interface{}{"order": "desc"}}, } } // ========== 构建 ES 查询 ========== query := map[string]interface{}{ "from": from, "size": pageSize, "query": map[string]interface{}{ "bool": map[string]interface{}{ "must": must, }, }, "sort": sort, "_source": map[string]interface{}{ "includes": []string{"isbn", "author", "book_name", "fix_price", "publisher"}, }, } body, _ := json.MarshalIndent(query, "", " ") 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() monitoredES := monitor.NewMonitoredESClient(svc.ES.Client, endpoint) queryBody := string(body) req := esapi.SearchRequest{ Index: []string{ESIndex}, Body: bytes.NewReader([]byte(queryBody)), TrackTotalHits: true, Pretty: true, } res, duration, err := monitoredES.Search(context.Background(), &req) fmt.Printf("[DEBUG] ES Query Response:\n%s\n", res) fmt.Printf("[DEBUG] ES 查询耗时：%dms\n", duration.Milliseconds()) if err != nil { fmt.Printf("[ERROR] ES.Client.Search error: %v\n", err) return nil, 0, err } defer res.Body.Close() // 读取响应 var buf bytes.Buffer // 使用CopyBuffer可以重用缓冲区 writer := bufio.NewWriterSize(&buf, 8192) _, err = io.Copy(writer, res.Body) if err != nil { return nil, 0, fmt.Errorf("复制响应数据失败: %v", err) } err = writer.Flush() if err != nil { return nil, 0, fmt.Errorf("刷新缓冲区失败：%v", err) } rawData := buf.Bytes() //rawData, err := io.ReadAll(res.Body) if err != nil { return nil, 0, fmt.Errorf("读取响应失败: %v", err) } // 检查是否有数据 if len(rawData) == 0 { return nil, 0, fmt.Errorf("ES返回空响应") } // 验证是否是有效的JSON if rawData[0] != '{' { return nil, 0, fmt.Errorf("ES返回非JSON响应: %s", string(rawData[:min(100, len(rawData))])) } fmt.Println("[DEBUG] ES query executed successfully") var _json = jsoniter.ConfigCompatibleWithStandardLibrary var parsed esHitsWrapper if err := _json.Unmarshal(rawData, &parsed); err != nil { return nil, 0, fmt.Errorf("JSON解析失败: %v, 原始数据: %s", err, string(rawData[:min(200, len(rawData))])) } list := make([]ESBook, 0, len(parsed.Hits.Hits)) for _, hit := range parsed.Hits.Hits { list = append(list, hit.Source) } return list, parsed.Hits.Total.Value, nil } // Gin Handler 包装器 func (svc *ESSearchService) SearchBookBaseInfoESHandler(c *gin.Context) { // DEBUG: 打印所有 query 参数 fmt.Printf("[DEBUG] Query Params: %v\n", c.Request.URL.RawQuery) list, total, err := svc.SearchBookBaseInfoES(c) if err != nil { fmt.Printf("[ERROR] SearchBookBaseInfoES failed: %v\n", err) c.JSON(500, gin.H{"error": err.Error()}) return } // 转换为Java兼容的响应格式 responseList := make([]ESBookResponse, 0, len(list)) for _, book := range list { responseList = append(responseList, book.ConvertToResponse()) } // 分页 page, _ := strconv.Atoi(c.DefaultQuery("page", "1")) pageSizeStr := c.DefaultQuery("pageSize", c.DefaultQuery("per_page", "10")) pageSize, _ := strconv.Atoi(pageSizeStr) // DEBUG: 打印响应数据摘要 fmt.Printf("[DEBUG] Response Info => total=%d page=%d pageSize=%d returnCount=%d\n", total, page, pageSize, len(responseList)) c.JSON(200, gin.H{ "current_page": page, "data": responseList, "per_page": pageSize, "total": total, }) } func (svc *ESSearchService) BatchGetBookBaseInfoESHandler(c *gin.Context) { list, total, err := svc.BatchGetBookBaseInfoES(c) if err != nil { fmt.Printf("[ERROR] BatchGetBookBaseInfoES failed: %v\n", err) c.JSON(500, gin.H{"error": err.Error()}) return } isbnList := make([]map[string]interface{}, 0, len(list)) for _, book := range list { isbnList = append(isbnList, map[string]interface{}{ "isbn": book.ISBN, "book_name": book.BookName.Value, "fix_price": float64(book.FixPrice), "author": book.Author, "publisher": book.Publisher, }) } page, _ := strconv.Atoi(c.DefaultQuery("page", "1")) pageSizeStr := c.DefaultQuery("pageSize", c.DefaultQuery("per_page", "10")) pageSize, _ := strconv.Atoi(pageSizeStr) fmt.Printf("[DEBUG] Response Info => total=%d page=%d pageSize=%d returnCount=%d\n", total, page, pageSize, len(isbnList)) c.JSON(200, gin.H{ "current_page": page, "data": isbnList, "per_page": pageSize, "total": total, }) } func (svc *ESSearchService) SearchBooksHandler(c *gin.Context) { isbn := c.Query("isbn") if isbn == "" { log.Printf("[SearchBooksHandler] 缺少 isbn 参数") c.JSON(400, gin.H{"error": "缺少 isbn 参数"}) return } log.Printf("[SearchBooksHandler] ISBN 模糊搜索：%s", isbn) ctx := context.Background() endpoint := c.FullPath() // 获取监控的 Redis 客户端 db1Client, err := redisClient.GetClientByName("db1") if err == nil { monitoredRedis := monitor.NewMonitoredRedisClient(db1Client, endpoint) val, _, err := monitoredRedis.Get(ctx, isbn) if err == nil && val != "" { log.Printf("[SearchBooksHandler] 从 Redis db1 查询到数据：%s", isbn) var redisBook request.BookInfo if err := json.Unmarshal([]byte(val), &redisBook); err == nil { esBook := ConvertRedisBookToESBook(&redisBook) if esBook != nil { responseData := esBook.ConvertToResponse() c.JSON(200, gin.H{ "data": responseData, }) return } } } } // ES 查询 result, err := svc.SearchBooks(isbn, endpoint) 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() endpoint := c.FullPath() // Redis 查询（使用监控） db1Client, err := redisClient.GetClientByName("db1") if err == nil { monitoredRedis := monitor.NewMonitoredRedisClient(db1Client, endpoint) val, _, err := monitoredRedis.Get(ctx, isbn) if err == nil && val != "" { log.Printf("[SearchBookByISBNHandler] 从 Redis db1 查询到数据：%s", isbn) var redisBook request.BookInfo if err := json.Unmarshal([]byte(val), &redisBook); err == nil { esBook := ConvertRedisBookToESBook(&redisBook) if esBook != nil { responseData := esBook.ConvertToResponse() c.JSON(200, gin.H{ "data": responseData, }) return } } else { log.Printf("[SearchBookByISBNHandler] Redis 数据解析失败：%v", err) } } } // ES 查询（使用监控） query := map[string]interface{}{ "query": map[string]interface{}{ "term": map[string]interface{}{ "isbn": isbn, }, }, "_source": true, } body, err := json.Marshal(query) if err != nil { log.Printf("[SearchBookByISBNHandler] 构建查询 JSON 失败：%v", err) c.JSON(500, gin.H{"error": "构建查询失败"}) return } req := esapi.SearchRequest{ Index: []string{ESIndex}, Body: bytes.NewReader(body), TrackTotalHits: true, Pretty: true, } // 创建监控客户端并执行查询 monitoredES := monitor.NewMonitoredESClient(svc.ES.Client, endpoint) resp, duration, err := monitoredES.Search(ctx, &req) log.Printf("[SearchBookByISBNHandler] ES 查询耗时：%dms", duration.Milliseconds()) if err != nil { log.Printf("[SearchBookByISBNHandler] ES 查询失败：%v", err) c.JSON(500, gin.H{"error": "ES 查询失败：" + err.Error()}) return } defer resp.Body.Close() if resp.IsError() { log.Printf("[SearchBookByISBNHandler] ES 返回错误：%s", resp.String()) c.JSON(500, gin.H{"error": "ES 返回错误：" + resp.String()}) return } var parsed esHitsWrapper if err := json.NewDecoder(resp.Body).Decode(&parsed); err != nil { log.Printf("[SearchBookByISBNHandler] 解析 ES 响应失败：%v", err) c.JSON(500, gin.H{"error": "解析响应失败"}) return } var result *ESBook if len(parsed.Hits.Hits) > 0 { result = &parsed.Hits.Hits[0].Source } 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 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) } responseData := result.ConvertToResponse() c.JSON(200, gin.H{ "data": responseData, }) } // 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 结构 func ConvertKongfzToESBook(apiBook *kongfz.BookResponse) *ESBook { if apiBook == nil || apiBook.Data.ISBN == "" { return nil } pubTimeStr := "" if apiBook.Data.PublicationTime != 0 { pubTimeStr = time.Unix(apiBook.Data.PublicationTime, 0).Format("2006-01") } // 处理 fix_price -> 分为单位 fixPriceFen := 0 if apiBook.Data.FixPrice != "" { priceFloat, err := strconv.ParseFloat(apiBook.Data.FixPrice, 64) if err == nil { fixPriceFen = int(priceFloat * 100) // 元 -> 分 } } return &ESBook{ ISBN: apiBook.Data.ISBN, BookName: FlexibleString{Value: apiBook.Data.BookName}, Author: apiBook.Data.Author, Publisher: apiBook.Data.Publisher, PublicationTime: pubTimeStr, FixPrice: Float64OrString(float64(fixPriceFen)), BookPic: BookPicObj{ LocalPath: "", PddPath: apiBook.Data.BookPic, // 初始化 BookPic 字段 }, BookPicS: BookPicSObj{ LocalPath: "", PddResponse: apiBook.Data.BookPicS, }, BookPicObjS: map[string]interface{}{ "pddResponse": apiBook.Data.BookPicS, }, // 其他字段默认赋值 BuyCounts: 0, SellCounts: 0, TotalSale: 0, BookPicW: make(map[string]interface{}), IsSuit: 0, Category: "", Content: "", } } func (svc *ESSearchService) SearchBookByBookNameHandler(c *gin.Context) { bookName := c.Query("bookName") if bookName == "" { c.JSON(400, gin.H{"error": "缺少 bookName 参数"}) return } result, err := svc.SearchBookByBookName(bookName) if err != nil { c.JSON(500, gin.H{"error": err.Error()}) return } if len(result) == 0 { c.JSON(404, gin.H{"error": "未找到该书名的图书"}) return } // 转换为Java兼容的响应格式 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) SearchBooksAllFieldsHandler(c *gin.Context) { keyword := c.Query("q") if keyword == "" { c.JSON(400, gin.H{"error": "缺少搜索参数 q"}) return } result, err := svc.SearchBooksAllFields(keyword) if err != nil { c.JSON(500, gin.H{"error": "ES 查询失败", "details": err.Error()}) return } // 转换为Java兼容的响应格式 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) SearchBooksByConditionsHandler(c *gin.Context) { conds := map[string]string{ "book_name": c.Query("book_name"), "isbn": c.Query("isbn"), "author": c.Query("author"), "category": c.Query("category"), "publisher": c.Query("publisher"), "publication_time": c.Query("publication_time"), "day_sale_30": c.Query("day_sale_30"), } page, _ := strconv.Atoi(c.DefaultQuery("page", "1")) pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "10")) result, total, err := svc.SearchBooksByConditions(conds, page, pageSize) if err != nil { c.JSON(500, gin.H{"error": err.Error()}) return } // 转换为Java兼容的响应格式 responseList := make([]ESBookResponse, 0, len(result)) for _, book := range result { responseList = append(responseList, book.ConvertToResponse()) } c.JSON(200, gin.H{ "count": len(result), "total": total, "data": responseList, "page": page, "pageSize": pageSize, }) } // CountByIDRangeHandler Gin 包装器 func (svc *ESSearchService) CountByIDRangeHandler(c *gin.Context) { minID, _ := strconv.Atoi(c.DefaultQuery("minID", "0")) maxID, _ := strconv.Atoi(c.DefaultQuery("maxID", "0")) if minID == 0 || maxID == 0 { c.JSON(400, gin.H{ "error": "缺少 minID 或 maxID 参数", }) return } count, err := svc.CountByIDRange(minID, maxID) if err != nil { c.JSON(500, gin.H{ "error": "ES 查询失败", "details": err.Error(), }) return } c.JSON(200, gin.H{ "minID": minID, "maxID": maxID, "count": count, }) } // CheckBookSuit 检查书名是否包含套装关键字 func CheckBookSuit(bookName string) bool { if bookName == "" { return false } // 套装关键字列表 suitKeywords := []string{ "套装", "卷本", "上中下", "上、下", "共二", "共三", "共四", "共五", "共六", "共七", "共八", "共九", "共十", "共十一", "共十二", "共十三", "共十四", "共十五", "共十六", "共十七", "共十八", "共十九", "共二十", "共二十一", "共二十二", "共二十三", "共二十四", "共二十五", "共二十六", "共二十七", "共二十八", "共二十九", "共三十", "共2", "共3", "共4", "共5", "共6", "共7", "共8", "共9", "全2", "全3", "全4", "全5", "全6", "全7", "全八", "全9", "共11", "共12", "共13", "共14", "共15", "共16", "共17", "共18", "共19", "全二", "全三", "全四", "全五", "全六", "全七", "全八", "全九", "2本合售", "3本合售", "4本合售", "5本合售", "6本合售", "7本合售", "8本合售", "9本合售", "合二", "合三", "合四", "合五", "合六", "合七", "合八", "合九", "合十", "合十一", "合十二", "合十三", "合十四", "合十五", "合十六", "合十七", "合十八", "合十九", "全套", "全套上下", "一套两本", "一套三本", "一套四本", "一套五本", "一套六本", "一套七本", "一套八本", "一套九本", "一套十本", "一套十一本", "1-1", "1-2", "1-3", "1-4", "1-5", "1-6", "1-7", "1-8", "1-9", "一-一", "一-二", "一-三", "一-四", "一-五", "一-六", "一-七", "一-八", "一-九", "壹-壹", "壹-贰", "壹-叁", "壹-肆", "壹-伍", "壹-陆", "壹-柒", "壹-捌", "壹-玖", "共十一", "共十二", "共十三", "共十四", "共十五", "共十六", "共十七", "共十八", "共十九", "全十一", "全十二", "全十三", "全十四", "全十五", "全十六", "全十七", "全十八", "全十九", "共贰", "共叁", "共肆", "共伍", "共陆", "共柒", "共捌", "共玖", "共拾", "全贰", "全叁", "全肆", "全伍", "全陆", "全柒", "全捌", "全玖", "全拾", "合贰", "合叁", "合肆", "合伍", "合陆", "合柒", "合捌", "合玖", "合拾", "共拾壹", "共拾贰", "共拾叁", "共拾肆", "共拾伍", "共拾陆", "共拾柒", "共拾捌", "共拾玖", "全拾壹", "全拾贰", "全拾叁", "全拾肆", "全拾伍", "全拾陆", "全拾柒", "全拾捌", "全拾玖", "合拾壹", "合拾贰", "合拾叁", "合拾肆", "合拾伍", "合拾陆", "合拾柒", "合拾捌", "合拾玖", "合2本", "合3本", "合4本", "合5本", "合6本", "合7本", "合8本", "合9本", "合10本", "合11本", "合12本", "合13本", "合14本", "合15本", "合16本", "合17本", "合18本", "合19本", "共2本", "共3本", "共4本", "共5本", "共6本", "共7本", "共8本", "共9本", "共10本", "共11本", "共12本", "共13本", "共14本", "共15本", "共16本", "共17本", "共18本", "共19本", "全2本", "全3本", "全4本", "全5本", "全6本", "全7本", "全8本", "全9本", "全10本", "全11本", "全12本", "全13本", "全14本", "全15本", "全16本", "全17本", "全18本", "全19本", "合二本", "合三本", "合四本", "合五本", "合六本", "合七本", "合八本", "合九本", "合十本", "合十一本", "合十二本", "合十三本", "合十四本", "合十五本", "合十六本", "合十七本", "合十八本", "合十九本", "共二本", "共三本", "共四本", "共五本", "共六本", "共七本", "共八本", "共九本", "共十本", "共十一本", "共十二本", "共十三本", "共十四本", "共十五本", "共十六本", "共十七本", "共十八本", "共十九本", "全二本", "全三本", "全四本", "全五本", "全六本", "全七本", "全八本", "全九本", "全十本", "全十一本", "全十二本", "全十三本", "全十四本", "全十五本", "全十六本", "全十七本", "全十八本", "全十九本", "合贰本", "合叁本", "合肆本", "合伍本", "合陆本", "合柒本", "合捌本", "合玖本", "合拾本", "合拾壹本", "合拾贰本", "合拾叁本", "合拾肆本", "合拾伍本", "合拾陆本", "合拾柒本", "合拾捌本", "合拾玖本", "共贰本", "共叁本", "共肆本", "共伍本", "共陆本", "共柒本", "共捌本", "共玖本", "共拾本", "共拾壹本", "共拾贰本", "共拾叁本", "共拾肆本", "共拾伍本", "共拾陆本", "共拾柒本", "共拾捌本", "共拾玖本", "全贰本", "全叁本", "全肆本", "全伍本", "全陆本", "全柒本", "全捌本", "全玖本", "全拾本", "全拾壹本", "全拾贰本", "全拾叁本", "全拾肆本", "全拾伍本", "全拾陆本", "全拾柒本", "全拾捌本", "全拾玖本", "合2册", "合3册", "合4册", "合5册", "合6册", "合7册", "合8册", "合9册", "合10册", "合11册", "合12册", "合13册", "合14册", "合15册", "合16册", "合17册", "合18册", "合19册", "共2册", "共3册", "共4册", "共5册", "共6册", "共7册", "共8册", "共9册", "共10册", "共11册", "共12册", "共13册", "共14册", "共15册", "共16册", "共17册", "共18册", "共19册", "全2册", "全3册", "全4册", "全5册", "全6册", "全7册", "全8册", "全9册", "全10册", "全11册", "全12册", "全13册", "全14册", "全15册", "全16册", "全17册", "全18册", "全19册", "合二册", "合三册", "合四册", "合五册", "合六册", "合七册", "合八册", "合九册", "合十册", "合十一册", "合十二册", "合十三册", "合十四册", "合十五册", "合十六册", "合十七册", "合十八册", "合十九册", "共二册", "共三册", "共四册", "共五册", "共六册", "共七册", "共八册", "共九册", "共十册", "共十一册", "共十二册", "共十三册", "共十四册", "共十五册", "共十六册", "共十七册", "共十八册", "共十九册", "全二册", "全三册", "全四册", "全五册", "全六册", "全七册", "全八册", "全九册", "全十册", "全十一册", "全十二册", "全十三册", "全十四册", "全十五册", "全十六册", "全十七册", "全十八册", "全十九册", "合贰册", "合叁册", "合肆册", "合伍册", "合陆册", "合柒册", "合捌册", "合玖册", "合拾册", "合拾壹册", "合拾贰册", "合拾叁册", "合拾肆册", "合拾伍册", "合拾陆册", "合拾柒册", "合拾捌册", "合拾玖册", "共贰册", "共叁册", "共肆册", "共伍册", "共陆册", "共柒册", "共捌册", "共玖册", "共拾册", "共拾壹册", "共拾贰册", "共拾叁册", "共拾肆册", "共拾伍册", "共拾陆册", "共拾柒册", "共拾捌册", "共拾玖册", "全贰册", "全叁册", "全肆册", "全伍册", "全陆册", "全柒册", "全捌册", "全玖册", "全拾册", "全拾壹册", "全拾贰册", "全拾叁册", "全拾肆册", "全拾伍册", "全拾陆册", "全拾柒册", "全拾捌册", "全拾玖册", "合2卷", "合3卷", "合4卷", "合5卷", "合6卷", "合7卷", "合8卷", "合9卷", "合10卷", "合11卷", "合12卷", "合13卷", "合14卷", "合15卷", "合16卷", "合17卷", "合18卷", "合19卷", "共2卷", "共3卷", "共4卷", "共5卷", "共6卷", "共7卷", "共8卷", "共9卷", "共10卷", "共11卷", "共12卷", "共13卷", "共14卷", "共15卷", "共16卷", "共17卷", "共18卷", "共19卷", "全2卷", "全3卷", "全4卷", "全5卷", "全6卷", "全7卷", "全8卷", "全9卷", "全10卷", "全11卷", "全12卷", "全13卷", "全14卷", "全15卷", "全16卷", "全17卷", "全18卷", "全19卷", "合二卷", "合三卷", "合四卷", "合五卷", "合六卷", "合七卷", "合八卷", "合九卷", "合十卷", "合十一卷", "合十二卷", "合十三卷", "合十四卷", "合十五卷", "合十六卷", "合十七卷", "合十八卷", "合十九卷", "共二卷", "共三卷", "共四卷", "共五卷", "共六卷", "共七卷", "共八卷", "共九卷", "共十卷", "共十一卷", "共十二卷", "共十三卷", "共十四卷", "共十五卷", "共十六卷", "共十七卷", "共十八卷", "共十九卷", "全二卷", "全三卷", "全四卷", "全五卷", "全六卷", "全七卷", "全八卷", "全九卷", "全十卷", "全十一卷", "全十二卷", "全十三卷", "全十四卷", "全十五卷", "全十六卷", "全十七卷", "全十八卷", "全十九卷", "合贰卷", "合叁卷", "合肆卷", "合伍卷", "合陆卷", "合柒卷", "合捌卷", "合玖卷", "合拾卷", "合拾壹卷", "合拾贰卷", "合拾叁卷", "合拾肆卷", "合拾伍卷", "合拾陆卷", "合拾柒卷", "合拾捌卷", "合拾玖卷", "共贰卷", "共叁卷", "共肆卷", "共伍卷", "共陆卷", "共柒卷", "共捌卷", "共玖卷", "共拾卷", "共拾壹卷", "共拾贰卷", "共拾叁卷", "共拾肆卷", "共拾伍卷", "共拾陆卷", "共拾柒卷", "共拾捌卷", "共拾玖卷", "全贰卷", "全叁卷", "全肆卷", "全伍卷", "全陆卷", "全柒卷", "全捌卷", "全玖卷", "全拾卷", "全拾壹卷", "全拾贰卷", "全拾叁卷", "全拾肆卷", "全拾伍卷", "全拾陆卷", "全拾柒卷", "全拾捌卷", "全拾玖卷", "合2辑", "合3辑", "合4辑", "合5辑", "合6辑", "合7辑", "合8辑", "合9辑", "合10辑", "合11辑", "合12辑", "合13辑", "合14辑", "合15辑", "合16辑", "合17辑", "合18辑", "合19辑", "共2辑", "共3辑", "共4辑", "共5辑", "共6辑", "共7辑", "共8辑", "共9辑", "共10辑", "共11辑", "共12辑", "共13辑", "共14辑", "共15辑", "共16辑", "共17辑", "共18辑", "共19辑", "全2辑", "全3辑", "全4辑", "全5辑", "全6辑", "全7辑", "全8辑", "全9辑", "全10辑", "全11辑", "全12辑", "全13辑", "全14辑", "全15辑", "全16辑", "全17辑", "全18辑", "全19辑", "合二辑", "合三辑", "合四辑", "合五辑", "合六辑", "合七辑", "合八辑", "合九辑", "合十辑", "合十一辑", "合十二辑", "合十三辑", "合十四辑", "合十五辑", "合十六辑", "合十七辑", "合十八辑", "合十九辑", "共二辑", "共三辑", "共四辑", "共五辑", "共六辑", "共七辑", "共八辑", "共九辑", "共十辑", "共十一辑", "共十二辑", "共十三辑", "共十四辑", "共十五辑", "共十六辑", "共十七辑", "共十八辑", "共十九辑", "全二辑", "全三辑", "全四辑", "全五辑", "全六辑", "全七辑", "全八辑", "全九辑", "全十辑", "全十一辑", "全十二辑", "全十三辑", "全十四辑", "全十五辑", "全十六辑", "全十七辑", "全十八辑", "全十九辑", "合贰辑", "合叁辑", "合肆辑", "合伍辑", "合陆辑", "合柒辑", "合捌辑", "合玖辑", "合拾辑", "合拾壹辑", "合拾贰辑", "合拾叁辑", "合拾肆辑", "合拾伍辑", "合拾陆辑", "合拾柒辑", "合拾捌辑", "合拾玖辑", "共贰辑", "共叁辑", "共肆辑", "共伍辑", "共陆辑", "共柒辑", "共捌辑", "共玖辑", "共拾辑", "共拾壹辑", "共拾贰辑", "共拾叁辑", "共拾肆辑", "共拾伍辑", "共拾陆辑", "共拾柒辑", "共拾捌辑", "共拾玖辑", "全贰辑", "全叁辑", "全肆辑", "全伍辑", "全陆辑", "全柒辑", "全捌辑", "全玖辑", "全拾辑", "全拾壹辑", "全拾贰辑", "全拾叁辑", "全拾肆辑", "全拾伍辑", "全拾陆辑", "全拾柒辑", "全拾捌辑", "全拾玖辑", "一函二", "一函三", "一函四", "一函五", "一函六", "一函七", "一函八", "一函九", "一函十", } // 检查书名是否包含任何一个套装关键字 for _, keyword := range suitKeywords { if strings.Contains(bookName, keyword) { return true } } return false } // CheckBookSuitHandler 检查书名是否包含套装关键字的HTTP处理器 func (svc *ESSearchService) CheckBookSuitHandler(c *gin.Context) { bookName := c.Query("bookName") if bookName == "" { c.JSON(400, gin.H{ "error": "缺少 bookName 参数", }) return } isSuit := CheckBookSuit(bookName) c.JSON(200, gin.H{ "code": 200, "message": "success", "data": gin.H{ "book_name": bookName, "is_suit": isSuit, }, }) } // UpdateBookSuitByISBNHandler 根据ISBN更新图书的is_suit字段 func (svc *ESSearchService) UpdateBookSuitByISBNHandler(c *gin.Context) { // 获取请求参数 var request struct { ISBN string `json:"isbn" binding:"required"` } if err := c.ShouldBindJSON(&request); err != nil { c.JSON(400, gin.H{ "error": "请求参数错误", "details": err.Error(), }) return } isbn := strings.TrimSpace(request.ISBN) if isbn == "" { c.JSON(400, gin.H{ "error": "ISBN不能为空", }) return } // 根据ISBN查询图书 book, err := svc.SearchBookByISBN(isbn) if err != nil { c.JSON(500, gin.H{ "error": "查询图书失败", "details": err.Error(), }) return } if book == nil { c.JSON(404, gin.H{ "error": "未找到该ISBN对应的图书", }) return } // 检查书名是否包含套装关键字 isSuit := 0 if CheckBookSuit(book.BookName.Value) { isSuit = 1 log.Printf("书名 '%s' 包含套装关键字，is_suit设置为1", book.BookName.Value) } else { log.Printf("书名 '%s' 不包含套装关键字，is_suit设置为0", book.BookName.Value) } // 更新ES中的is_suit字段 body := map[string]interface{}{ "script": map[string]interface{}{ "source": "ctx._source.is_suit = params.is_suit;", "lang": "painless", "params": map[string]interface{}{ "is_suit": isSuit, }, }, "query": map[string]interface{}{ "term": map[string]interface{}{ "isbn": isbn, }, }, } fmt.Println(body) payload, _ := json.Marshal(body) res, err := svc.ES.Client.UpdateByQuery( []string{ESIndex}, svc.ES.Client.UpdateByQuery.WithBody(bytes.NewReader(payload)), svc.ES.Client.UpdateByQuery.WithRefresh(true), svc.ES.Client.UpdateByQuery.WithConflicts("proceed"), ) if err != nil { c.JSON(500, gin.H{ "error": "更新ES失败", "details": err.Error(), }) return } defer res.Body.Close() if res.IsError() { c.JSON(500, gin.H{ "error": "ES返回错误", "details": res.String(), }) return } // 解析更新结果 var parsed struct { Total int `json:"total"` Updated int `json:"updated"` VersionConflicts int `json:"version_conflicts"` } if err := json.NewDecoder(res.Body).Decode(&parsed); err != nil { c.JSON(500, gin.H{ "error": "解析更新结果失败", "details": err.Error(), }) return } // 返回结果 c.JSON(200, gin.H{ "code": 200, "message": "success", "data": gin.H{ "isbn": isbn, "book_name": book.BookName.Value, "is_suit": isSuit, "updated": parsed.Updated, "contains_suit_keyword": isSuit == 1, }, }) } // UpdateBookFieldsByISBNHandler 根据ISBN通用更新图书字段 func (svc *ESSearchService) UpdateBookFieldsByISBNHandler(c *gin.Context) { // 请求参数 var request struct { ISBN string `json:"isbn" binding:"required"` Data map[string]interface{} `json:"data" binding:"required"` } // 参数解析 if err := c.ShouldBindJSON(&request); err != nil { c.JSON(400, gin.H{ "error": "请求参数错误", "details": err.Error(), }) return } isbn := strings.TrimSpace(request.ISBN) if isbn == "" { c.JSON(400, gin.H{ "error": "ISBN不能为空", }) return } if len(request.Data) == 0 { c.JSON(400, gin.H{ "error": "至少提供一个要更新的字段", }) return } // 先确认 ISBN 是否存在 book, err := svc.SearchBookByISBN(isbn) fmt.Println("book:", book) if err != nil { c.JSON(500, gin.H{ "error": "查询ES失败", "details": err.Error(), }) return } if book == nil { c.JSON(404, gin.H{ "error": "未找到该ISBN对应的图书", }) return } // 调用 Service 层更新逻辑 updated, err := svc.UpdateBookFieldsByISBN( c.Request.Context(), isbn, request.Data, ) if err != nil { c.JSON(500, gin.H{ "error": "更新ES失败", "details": err.Error(), }) return } // 返回结果 c.JSON(200, gin.H{ "code": 200, "message": "success", "data": gin.H{ "isbn": isbn, "updated": updated, "fields_updated": len(request.Data), "updated_fields": func() []string { fields := make([]string, 0, len(request.Data)) for k := range request.Data { fields = append(fields, k) } return fields }(), }, }) } func (svc *ESSearchService) UpdateBookFieldsByISBN( ctx context.Context, isbn string, data map[string]interface{}, ) (int, error) { if isbn == "" { return 0, fmt.Errorf("ISBN不能为空") } if len(data) == 0 { return 0, fmt.Errorf("至少提供一个要更新的字段") } // 构建更新脚本 var scriptParts []string params := make(map[string]interface{}) allowedFields := map[string]bool{ //"book_name": true, "book_pic": true, "book_pic_s": true, "book_pic_b": true, "book_pic_w": true, "author": true, "category": true, "publisher": true, "publication_time": true, "binding_layout": true, "fix_price": true, "content": true, "is_suit": true, "day_sale_7": true, "day_sale_15": true, "day_sale_30": true, "day_sale_60": true, "day_sale_90": true, "day_sale_180": true, "day_sale_365": true, "this_year_sale": true, "last_year_sale": true, "total_sale": true, "buy_counts": true, "sell_counts": true, "is_illegal": true, "is_return": true, "is_filter": true, "update_time": true, "page_count": true, "word_count": true, "book_format": true, } for field, value := range data { if !allowedFields[field] { continue } scriptParts = append(scriptParts, fmt.Sprintf("ctx._source.%s = params.%s;", field, field)) params[field] = value } fmt.Println("scriptParts:", scriptParts) if len(scriptParts) == 0 { return 0, fmt.Errorf("没有有效的字段可更新") } body := map[string]interface{}{ "script": map[string]interface{}{ "source": strings.Join(scriptParts, " "), "lang": "painless", "params": params, }, "query": map[string]interface{}{ "term": map[string]interface{}{ "isbn": isbn, }, }, } payload, _ := json.Marshal(body) res, err := svc.ES.Client.UpdateByQuery( []string{ESIndex}, svc.ES.Client.UpdateByQuery.WithBody(bytes.NewReader(payload)), svc.ES.Client.UpdateByQuery.WithRefresh(true), svc.ES.Client.UpdateByQuery.WithConflicts("proceed"), ) if err != nil { return 0, err } defer res.Body.Close() if res.IsError() { errorBody := res.String() log.Printf("[UpdateBookFieldsByISBN] ES 返回错误 | status=%s | body=%s", res.Status(), errorBody) return 0, fmt.Errorf("ES 返回错误：%s, 详细信息：%s", res.Status(), errorBody) } if res.IsError() { return 0, fmt.Errorf("ES返回错误: %s", res.String()) } var parsed struct { Updated int `json:"updated"` } _ = json.NewDecoder(res.Body).Decode(&parsed) return parsed.Updated, nil } // AddBookToESHandler 根据ISBN查询ES中是否存在，不存在则新增数据,存在则根据参数更新 func (svc *ESSearchService) AddBookToESHandler(c *gin.Context) { var req ESBook if err := c.ShouldBindJSON(&req); err != nil { c.JSON(http.StatusBadRequest, gin.H{ "error": "参数解析错误", "message": err.Error(), }) return } if req.ISBN == "" { c.JSON(http.StatusBadRequest, gin.H{ "error": "ISBN不能为空", }) return } // 打印接收参数 log.Printf("接收参数: %+v", req) // ====== 外层：先查 ES 是否存在 ====== book, err := svc.SearchBookByISBN(req.ISBN) if err != nil { c.JSON(500, gin.H{ "error": "查询ES失败", "msg": err.Error(), }) return } // ====== 已存在直接处理 ====== if book != nil { log.Printf("ES中已存在: %+v", book) updateData := make(map[string]interface{}) if book.Publisher == "" && req.Publisher != "" { updateData["publisher"] = req.Publisher } if book.PublicationTime == "" && req.PublicationTime != "" { updateData["publication_time"] = req.PublicationTime } if book.BookPic.PddPath == "" && req.BookPic.PddPath != "" { updateData["book_pic"] = map[string]interface{}{ "localPath": "", "pddPath": req.BookPic.PddPath, } } if book.BookPicS.PddResponse == "" && req.BookPicS.PddResponse != "" { updateData["book_pic_s"] = map[string]interface{}{ "localPath": "", "pddResponse": req.BookPicS.PddResponse, } } if book.BookName.Value == "" && req.BookName.Value != "" { updateData["book_name"] = req.BookName.Value } if book.Author == "" && req.Author != "" { updateData["author"] = req.Author } // 打印传递的参数 log.Printf("更新数据: %+v", updateData) if len(updateData) > 0 { updateData["update_time"] = fmt.Sprintf("%d", time.Now().Unix()) _, err := svc.UpdateBookFieldsByISBN( c.Request.Context(), req.ISBN, updateData, ) if err != nil { c.JSON(500, gin.H{ "error": "补全ES字段失败", "msg": err.Error(), }) return } } // 重新查询最新数据 newBook, _ := svc.SearchBookByISBN(req.ISBN) c.JSON(200, gin.H{ "data": newBook.ConvertToResponse(), "source": "es", }) return } // ====== 不存在，才真正新增 ====== newBook, err := svc.AddBookToES(c.Request.Context(), &req) if err != nil { c.JSON(500, gin.H{ "error": err.Error(), }) return } c.JSON(200, gin.H{ "data": newBook.ConvertToResponse(), "source": "service", }) } // AddBookFullToESHandler 新的完整插入接口，支持所有字段，book_name强制为string类型 func (svc *ESSearchService) AddBookFullToESHandler(c *gin.Context) { var req AddBookFullRequest // 参数校验 if err := c.ShouldBindJSON(&req); err != nil { c.JSON(http.StatusBadRequest, gin.H{ "error": "参数解析错误", "message": err.Error(), }) return } // 强制校验 book_name 为字符串类型 //if req.BookName == "" { // c.JSON(http.StatusBadRequest, gin.H{ // "error": "book_name 不能为空", // "message": "book_name 字段必须为非空字符串", // }) // return //} // ISBN 必填校验 if req.ISBN == "" { c.JSON(http.StatusBadRequest, gin.H{ "error": "ISBN 不能为空", "message": "ISBN 字段为必填项", }) return } // 验证 BookPic 对象格式 if req.BookPic != nil { if err := validateBookPicObj(req.BookPic, "book_pic"); err != nil { c.JSON(http.StatusBadRequest, gin.H{ "error": "book_pic 格式错误", "message": err.Error(), }) return } } // 验证 BookPicS 对象格式 if req.BookPicS != nil { if err := validateBookPicSObj(req.BookPicS, "book_pic_s"); err != nil { c.JSON(http.StatusBadRequest, gin.H{ "error": "book_pic_s 格式错误", "message": err.Error(), }) return } } // 验证 BookPicW 对象格式 if req.BookPicW != nil { if err := validateBookPicWObj(req.BookPicW, "book_pic_w"); err != nil { c.JSON(http.StatusBadRequest, gin.H{ "error": "book_pic_w 格式错误", "message": err.Error(), }) return } } // 验证 BookPicObj 对象格式 if req.BookPicObj != nil { if err := validateBookPicObj(req.BookPicObj, "book_pic_obj"); err != nil { c.JSON(http.StatusBadRequest, gin.H{ "error": "book_pic_obj 格式错误", "message": err.Error(), }) return } } // 验证 BookPicObjS 对象格式 if req.BookPicObjS != nil { if err := validateBookPicObjS(req.BookPicObjS, "book_pic_obj_s"); err != nil { c.JSON(http.StatusBadRequest, gin.H{ "error": "book_pic_obj_s 格式错误", "message": err.Error(), }) return } } // 验证数值字段范围 if req.FixPrice < 0 { c.JSON(http.StatusBadRequest, gin.H{ "error": "fix_price 不能为负数", "message": "fix_price 字段必须为非负数", }) return } if req.IsSuit < 0 || req.IsSuit > 1 { c.JSON(http.StatusBadRequest, gin.H{ "error": "is_suit 值错误", "message": "is_suit 字段必须为 0 或 1", }) return } // 验证销量字段不能为负数 salesFields := []struct { name string value int }{ {"day_sale_7", req.DaySale7}, {"day_sale_15", req.DaySale15}, {"day_sale_30", req.DaySale30}, {"day_sale_60", req.DaySale60}, {"day_sale_90", req.DaySale90}, {"day_sale_180", req.DaySale180}, {"day_sale_365", req.DaySale365}, {"this_year_sale", req.ThisYearSale}, {"last_year_sale", req.LastYearSale}, {"total_sale", req.TotalSale}, } for _, field := range salesFields { if field.value < 0 { c.JSON(http.StatusBadRequest, gin.H{ "error": fmt.Sprintf("%s 不能为负数", field.name), "message": fmt.Sprintf("%s 字段必须为非负数", field.name), }) return } } // 验证购买和售卖次数不能为负数 if req.BuyCounts < 0 { c.JSON(http.StatusBadRequest, gin.H{ "error": "buy_counts 不能为负数", "message": "buy_counts 字段必须为非负数", }) return } if req.SellCounts < 0 { c.JSON(http.StatusBadRequest, gin.H{ "error": "sell_counts 不能为负数", "message": "sell_counts 字段必须为非负数", }) return } // 验证字符串字段长度（防止过长导致存储问题） if len(req.BookName) > 500 { c.JSON(http.StatusBadRequest, gin.H{ "error": "book_name 过长", "message": "book_name 字段长度不能超过500个字符", }) return } if len(req.Author) > 200 { c.JSON(http.StatusBadRequest, gin.H{ "error": "author 过长", "message": "author 字段长度不能超过200个字符", }) return } if len(req.Publisher) > 200 { c.JSON(http.StatusBadRequest, gin.H{ "error": "publisher 过长", "message": "publisher 字段长度不能超过200个字符", }) return } if len(req.ISBN) > 20 { c.JSON(http.StatusBadRequest, gin.H{ "error": "isbn 过长", "message": "isbn 字段长度不能超过20个字符", }) return } // 验证ISBN格式（简单验证） if req.ISBN != "" { // 移除连字符和空格后检查是否只包含数字 cleanISBN := strings.ReplaceAll(strings.ReplaceAll(req.ISBN, "-", ""), " ", "") if len(cleanISBN) < 10 || len(cleanISBN) > 13 { c.JSON(http.StatusBadRequest, gin.H{ "error": "isbn 格式错误", "message": "isbn 格式不正确，应为10-13位数字", }) return } // 检查是否只包含数字 for _, r := range cleanISBN { if r < '0' || r > '9' { c.JSON(http.StatusBadRequest, gin.H{ "error": "isbn 格式错误", "message": "isbn 只能包含数字", }) return } } } // 转换为 ESBook 结构体 esBook := &ESBook{ BookName: FlexibleString{Value: req.BookName}, // 强制使用字符串 ISBN: req.ISBN, Author: req.Author, Category: req.Category, Publisher: req.Publisher, PublicationTime: req.PublicationTime, BindingLayout: req.BindingLayout, FixPrice: Float64OrString(req.FixPrice), Content: req.Content, IsSuit: req.IsSuit, DaySale7: req.DaySale7, DaySale15: req.DaySale15, DaySale30: req.DaySale30, DaySale60: req.DaySale60, DaySale90: req.DaySale90, DaySale180: req.DaySale180, DaySale365: req.DaySale365, ThisYearSale: req.ThisYearSale, LastYearSale: req.LastYearSale, TotalSale: req.TotalSale, BuyCounts: req.BuyCounts, SellCounts: req.SellCounts, BookPicObj: req.BookPicObj, BookPicObjS: req.BookPicObjS, IsIllegal: req.IsIllegal, IsReturn: req.IsReturn, IsFilter: req.IsFilter, } // 处理复杂图片字段（已经过验证，直接使用） // BookPic if req.BookPic != nil { localPath := req.BookPic["localPath"].(string) pddPath := req.BookPic["pddPath"].(string) esBook.BookPic = BookPicObj{ LocalPath: localPath, PddPath: pddPath, } } else { esBook.BookPic = BookPicObj{LocalPath: "", PddPath: ""} } // BookPicS if req.BookPicS != nil { localPath := req.BookPicS["localPath"].(string) pddResponse := req.BookPicS["pddResponse"].(string) esBook.BookPicS = BookPicSObj{ LocalPath: localPath, PddResponse: pddResponse, } } else { esBook.BookPicS = BookPicSObj{LocalPath: "", PddResponse: ""} } // BookPicB esBook.BookPicB = req.BookPicB // BookPicW if req.BookPicW != nil { esBook.BookPicW = req.BookPicW } else { esBook.BookPicW = make(map[string]interface{}) } // 调用 AddBookToES 方法插入数据 book, err := svc.AddBookToES(c.Request.Context(), esBook) if err != nil { c.JSON(500, gin.H{ "error": "插入ES失败", "message": err.Error(), }) return } // 转换为Java兼容的响应格式 responseData := book.ConvertToResponse() c.JSON(http.StatusOK, gin.H{ "code": 200, "message": "success", "data": responseData, "source": "full_insert", }) } // AddBookToES 新增数据到es中 或者更新 func (svc *ESSearchService) AddBookToES(ctx context.Context, req *ESBook) (*ESBook, error) { // 打印入参 log.Printf("入参: %+v", req) if req.ISBN == "" { return nil, fmt.Errorf("ISBN不能为空") } now := time.Now().Unix() // 解析 book_pic_new bookPicObjS := map[string]interface{}{ "pddResponse": req.BookPicS.PddResponse, } // 获取销量数据 salesData, _ := tail.CheckSales([]string{req.ISBN}) log.Printf("销量数据: %+v", salesData) var daySale7, daySale15, daySale30, daySale60, daySale90, daySale180, daySale365 int var thisYearSale, lastYearSale, totalSale int if salesData != nil && salesData.Data != nil { if s, ok := salesData.Data[req.ISBN]; ok { parse := func(str string) int { if v, err := strconv.Atoi(str); err == nil { return v } return 0 } daySale7 = parse(s.DaySale7) daySale15 = parse(s.DaySale15) daySale30 = parse(s.DaySale30) daySale60 = parse(s.DaySale60) daySale90 = parse(s.DaySale90) daySale180 = parse(s.DaySale180) daySale365 = parse(s.DaySale365) thisYearSale = parse(s.ThisYearSale) lastYearSale = parse(s.LastYearSale) totalSale = parse(s.Sale) } } if totalSale == 0 && req.BuyCounts > 0 { totalSale = int(req.BuyCounts) } // 套装判断 isSuit := 0 if CheckBookSuit(req.BookName.Value) { isSuit = 1 } // 生成新 ID 以便新增数据插入新ID lastID, err := svc.GetLastID() if err != nil { return nil, fmt.Errorf("获取最后ID失败: %w", err) } newID := lastID + 1 newBook := ESBook{ ID: int64(newID), BookName: FlexibleString{Value: req.BookName.Value}, BookPic: BookPicObj{ LocalPath: "", PddPath: req.BookPic.PddPath, }, BookPicS: BookPicSObj{ LocalPath: "", PddResponse: req.BookPicS.PddResponse, }, BookPicW: make(map[string]interface{}), ISBN: req.ISBN, Author: req.Author, Publisher: req.Publisher, PublicationTime: req.PublicationTime, FixPrice: req.FixPrice, IsSuit: isSuit, DaySale7: daySale7, DaySale15: daySale15, DaySale30: daySale30, DaySale60: daySale60, DaySale90: daySale90, DaySale180: daySale180, DaySale365: daySale365, ThisYearSale: thisYearSale, LastYearSale: lastYearSale, TotalSale: totalSale, BuyCounts: req.BuyCounts, SellCounts: req.SellCounts, BookPicObjS: bookPicObjS, UpdateTime: NumberOrString(fmt.Sprintf("%d", now)), IsIllegal: 0, IsReturn: 0, IsFilter: "000000", } // 打印 log.Printf("生成新数据: %+v", newBook) // 创建临时map用于序列化，避免FlexibleString的序列化问题 tempBook := map[string]interface{}{ "id": newBook.ID, "book_name": newBook.BookName.Value, // 直接使用字符串值 "book_pic": newBook.BookPic, "book_pic_s": newBook.BookPicS, "book_pic_b": newBook.BookPicB, "book_pic_w": newBook.BookPicW, "isbn": newBook.ISBN, "author": newBook.Author, "category": newBook.Category, "publisher": newBook.Publisher, "publication_time": newBook.PublicationTime, "binding_layout": newBook.BindingLayout, "fix_price": newBook.FixPrice, "content": newBook.Content, "is_suit": newBook.IsSuit, "day_sale_7": newBook.DaySale7, "day_sale_15": newBook.DaySale15, "day_sale_30": newBook.DaySale30, "day_sale_60": newBook.DaySale60, "day_sale_90": newBook.DaySale90, "day_sale_180": newBook.DaySale180, "day_sale_365": newBook.DaySale365, "this_year_sale": newBook.ThisYearSale, "last_year_sale": newBook.LastYearSale, "total_sale": newBook.TotalSale, "buy_counts": newBook.BuyCounts, "sell_counts": newBook.SellCounts, "book_pic_obj": newBook.BookPicObj, "book_pic_obj_s": newBook.BookPicObjS, "is_illegal": newBook.IsIllegal, "is_return": newBook.IsReturn, "is_filter": newBook.IsFilter, "update_time": newBook.UpdateTime, } log.Printf("[AddBookToES] 准备序列化tempBook的book_name: %s", tempBook["book_name"]) jsonData, err := json.Marshal(tempBook) if err != nil { return nil, fmt.Errorf("序列化失败: %w", err) } log.Printf("[AddBookToES] 序列化结果: %s", string(jsonData)) // 写入 ES esReq := esapi.IndexRequest{ Index: ESIndex, DocumentID: req.ISBN, Body: bytes.NewReader(jsonData), Refresh: "true", } log.Printf("写入 ES 请求: %+v", esReq) res, err := esReq.Do(ctx, svc.ES.Client.Transport) //log.Printf("写入 ES 响应: %+v", res) if err != nil { return nil, fmt.Errorf("ES写入失败: %w", err) } defer res.Body.Close() if res.IsError() { return nil, fmt.Errorf("ES返回错误: %s", res.String()) } return &newBook, nil } // GetLastID 查询最后一条文档的ID func (svc *ESSearchService) GetLastID() (int, error) { log.Println("[GetLastID] 开始查询最新文档 ID") query := `{ "size": 1, "sort": [{"id": {"order": "desc"}}] }` res, err := svc.ES.Client.Search( svc.ES.Client.Search.WithContext(context.Background()), svc.ES.Client.Search.WithIndex(ESIndex), svc.ES.Client.Search.WithBody(strings.NewReader(query)), ) if err != nil { log.Printf("[GetLastID] ES 查询失败: %v\n", err) return 0, fmt.Errorf("ES 查询失败: %w", err) } defer res.Body.Close() if res.IsError() { log.Printf("[GetLastID] ES 返回错误: %s\n", res.String()) return 0, fmt.Errorf("ES 返回错误: %s", res.String()) } // 打印日志 //log.Println("[GetLastID] ES 响应:", res.String()) //log.Println("[GetLastID] 响应内容:", res.Body) // 定义结构体，ID 为数组 var result struct { Hits struct { Hits []struct { Source struct { ID int `json:"id"` // 改回单个 int } `json:"_source"` } `json:"hits"` } `json:"hits"` } if err := json.NewDecoder(res.Body).Decode(&result); err != nil { log.Printf("[GetLastID] 解析 ES 返回 JSON 失败: %v\n", err) return 0, fmt.Errorf("解析 ES 返回 JSON 失败: %w", err) } if len(result.Hits.Hits) == 0 { log.Println("[GetLastID] 没有找到任何文档") return 0, nil } lastID := result.Hits.Hits[0].Source.ID log.Printf("[GetLastID] 查询到最新文档 ID: %d\n", lastID) return lastID, nil } // DeleteBookHandler 删除图书 func (svc *ESSearchService) DeleteBookHandler(c *gin.Context) { isbn := c.Query("isbn") if err := svc.DeleteBookByISBN(isbn); err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, gin.H{"message": "删除成功"}) } // DeleteBookByISBN 通过 ISBN 删除 ES 文档 // // func (svc *ESSearchService) DeleteBookByISBN(isbn string) error { // isbn = strings.TrimSpace(isbn) // log.Printf("[DeleteBookByISBN] 开始删除 | ISBN=%s", isbn) // // if isbn == "" { // log.Printf("[DeleteBookByISBN] ISBN 为空，取消删除") // return fmt.Errorf("ISBN 不能为空") // } // // // 查询文档，确认存在 // byISBN, err := svc.SearchBookByISBN(isbn) // if err != nil { // log.Printf("[DeleteBookByISBN] 查询 ISBN 出错: %v", err) // return err // } // if byISBN == nil { // log.Printf("[DeleteBookByISBN] 未找到 ISBN 对应的文档: %s", isbn) // return fmt.Errorf("未找到 ISBN 对应的文档: %s", isbn) // } // // log.Printf("[DeleteBookByISBN] 找到文档: %+v", byISBN) // // // 构建删除请求 // req := esapi.DeleteRequest{ // Index: ESIndex, // DocumentID: isbn, // 确认文档 ID 与 ISBN 一致，否则需要 DeleteByQuery // Refresh: "true", // } // // // 执行删除请求 // res, err := req.Do(context.Background(), svc.ES.Client.Transport) // if err != nil { // log.Printf("[DeleteBookByISBN] 执行 ES 删除请求失败: %v", err) // return fmt.Errorf("执行 ES 删除请求失败: %v", err) // } // defer res.Body.Close() // // // 检查响应状态 // if res.IsError() { // if res.StatusCode == 404 { // log.Printf("[DeleteBookByISBN] 文档不存在，已跳过删除 | ISBN=%s", isbn) // return nil // } // log.Printf("[DeleteBookByISBN] ES 返回错误: %s", res.String()) // return fmt.Errorf("ES 返回错误: %s", res.String()) // } // // // 解析响应结果 // var result struct { // Result string `json:"result"` // Version int `json:"_version"` // } // if err := json.NewDecoder(res.Body).Decode(&result); err != nil { // log.Printf("[DeleteBookByISBN] 解析 ES 删除响应失败: %v", err) // return fmt.Errorf("解析 ES 删除响应失败: %v", err) // } // // log.Printf("[DeleteBookByISBN] 成功删除 ES 文档 | ISBN=%s | result=%s | version=%d", isbn, result.Result, result.Version) // return nil // } func (svc *ESSearchService) DeleteBookByISBN(isbn string) error { isbn = strings.TrimSpace(isbn) log.Printf("[DeleteBookByISBN] 开始删除 | ISBN=%s", isbn) if isbn == "" { return fmt.Errorf("ISBN 不能为空") } //index := "books-from-mysql-v2" query := fmt.Sprintf(`{ "query": { "term": { "isbn": "%s" } } }`, isbn) res, err := svc.ES.Client.DeleteByQuery( []string{ESIndex}, strings.NewReader(query), svc.ES.Client.DeleteByQuery.WithRefresh(true), ) if err != nil { return fmt.Errorf("执行 DeleteByQuery 失败: %v", err) } defer res.Body.Close() if res.IsError() { return fmt.Errorf("ES 返回错误: %s", res.String()) } log.Printf("[DeleteBookByISBN] 成功删除 ISBN=%s 对应的文档", isbn) return nil } // DeleteBookByID 通过 ID 删除 ES 文档 func (svc *ESSearchService) DeleteBookByID(id string) error { id = strings.TrimSpace(id) log.Printf("[DeleteBookByID] 开始删除 | ID=%s", id) if id == "" { return fmt.Errorf("ID 不能为空") } query := fmt.Sprintf(`{ "query": { "term": { "id": "%s" } } }`, id) res, err := svc.ES.Client.DeleteByQuery( []string{ESIndex}, strings.NewReader(query), svc.ES.Client.DeleteByQuery.WithRefresh(true), ) if err != nil { return fmt.Errorf("执行 DeleteByQuery 失败: %v", err) } defer res.Body.Close() if res.IsError() { return fmt.Errorf("ES 返回错误: %s", res.String()) } log.Printf("[DeleteBookByID] 成功删除 ID=%s 对应的文档", id) return nil } // DeleteBookByIDHandler 根据ID删除图书的HTTP处理器 func (svc *ESSearchService) DeleteBookByIDHandler(c *gin.Context) { id := strings.TrimSpace(c.Query("id")) if id == "" { c.JSON(400, gin.H{ "error": "缺少 id 参数", }) return } if err := svc.DeleteBookByID(id); err != nil { c.JSON(500, gin.H{ "error": "删除失败", "details": err.Error(), }) return } c.JSON(200, gin.H{ "code": 200, "message": "success", "data": gin.H{ "id": id, "deleted": true, }, }) } // BatchAddBookRequest 批量插入请求结构体 type BatchAddBookRequest struct { Books []AddBookFullRequest `json:"books"` // 图书列表 } // BatchInsertResultItem 单个图书插入结果 type BatchInsertResultItem struct { Index int `json:"index"` // 在批次中的索引 ISBN string `json:"isbn"` // 图书ISBN Success bool `json:"success"` // 是否成功 Error string `json:"error"` // 错误信息(如果有) Document string `json:"document"` // 文档ID(如果成功) } // BatchInsertResult 批量插入结果 type BatchInsertResult struct { TotalCount int `json:"total_count"` // 总数量 SuccessCount int `json:"success_count"` // 成功数量 FailedCount int `json:"failed_count"` // 失败数量 Results []BatchInsertResultItem `json:"results"` // 详细结果 } // BatchAddBookToESHandler 批量插入图书到ES的HTTP处理器 func (svc *ESSearchService) BatchAddBookToESHandler(c *gin.Context) { var req BatchAddBookRequest if err := c.ShouldBindJSON(&req); err != nil { c.JSON(400, gin.H{ "error": "请求参数格式错误", "details": err.Error(), }) return } // 验证至少提供一本书 if len(req.Books) == 0 { c.JSON(400, gin.H{ "error": "至少提供一本要插入的图书", }) return } // 限制批量插入数量，避免一次性处理过多 maxBatchSize := 100 if len(req.Books) > maxBatchSize { c.JSON(400, gin.H{ "error": fmt.Sprintf("批量插入数量不能超过%d本", maxBatchSize), }) return } result := BatchInsertResult{ TotalCount: len(req.Books), SuccessCount: 0, FailedCount: 0, Results: make([]BatchInsertResultItem, 0, len(req.Books)), } // 逐个处理每本书 for i, book := range req.Books { item := BatchInsertResultItem{ Index: i, ISBN: book.ISBN, Success: false, } // 验证必填字段 if book.BookName == "" { item.Error = "book_name不能为空" result.Results = append(result.Results, item) result.FailedCount++ continue } if book.ISBN == "" { item.Error = "ISBN不能为空" result.Results = append(result.Results, item) result.FailedCount++ continue } // 验证ISBN格式 if !validateISBNFormat(book.ISBN) { item.Error = "ISBN格式不正确，应为10-13位数字" result.Results = append(result.Results, item) result.FailedCount++ continue } // 确保book_pic和book_pic_s存在且验证通过 if err := validateBookPicObj(book.BookPic, "book_pic"); err != nil { item.Error = fmt.Sprintf("book_pic验证失败: %v", err) result.Results = append(result.Results, item) result.FailedCount++ continue } if err := validateBookPicSObj(book.BookPicS, "book_pic_s"); err != nil { item.Error = fmt.Sprintf("book_pic_s验证失败: %v", err) result.Results = append(result.Results, item) result.FailedCount++ continue } if book.BookPicW != nil { if err := validateBookPicWObj(book.BookPicW, "book_pic_w"); err != nil { item.Error = fmt.Sprintf("book_pic_w验证失败: %v", err) result.Results = append(result.Results, item) result.FailedCount++ continue } } // 转换为ESBook结构体 esBook := &ESBook{ BookName: FlexibleString{Value: book.BookName}, // 强制使用字符串 ISBN: book.ISBN, Author: book.Author, Category: book.Category, Publisher: book.Publisher, PublicationTime: book.PublicationTime, BindingLayout: book.BindingLayout, FixPrice: Float64OrString(book.FixPrice), Content: book.Content, IsSuit: book.IsSuit, DaySale7: book.DaySale7, DaySale15: book.DaySale15, DaySale30: book.DaySale30, DaySale60: book.DaySale60, DaySale90: book.DaySale90, DaySale180: book.DaySale180, DaySale365: book.DaySale365, ThisYearSale: book.ThisYearSale, LastYearSale: book.LastYearSale, TotalSale: book.TotalSale, BuyCounts: book.BuyCounts, SellCounts: book.SellCounts, BookPicObj: book.BookPicObj, BookPicObjS: book.BookPicObjS, IsIllegal: book.IsIllegal, IsReturn: book.IsReturn, IsFilter: book.IsFilter, } // 处理复杂图片字段（已经过验证，直接使用） // BookPic - 验证函数确保了要么为nil，要么包含正确的字段 if book.BookPic != nil { localPath := book.BookPic["localPath"].(string) pddPath := book.BookPic["pddPath"].(string) esBook.BookPic = BookPicObj{ LocalPath: localPath, PddPath: pddPath, } } else { // 创建默认空对象 esBook.BookPic = BookPicObj{LocalPath: "", PddPath: ""} } // BookPicS - 验证函数确保了要么为nil，要么包含正确的字段 if book.BookPicS != nil { localPath := book.BookPicS["localPath"].(string) pddResponse := book.BookPicS["pddResponse"].(string) esBook.BookPicS = BookPicSObj{ LocalPath: localPath, PddResponse: pddResponse, } } else { // 创建默认空对象 esBook.BookPicS = BookPicSObj{LocalPath: "", PddResponse: ""} } // BookPicB esBook.BookPicB = book.BookPicB // BookPicW if book.BookPicW != nil { esBook.BookPicW = book.BookPicW } else { esBook.BookPicW = make(map[string]interface{}) } // 插入到ES log.Printf("[BatchAddBookToESHandler] 准备插入书籍: ISBN=%s, BookName=%+v", book.ISBN, esBook.BookName) addedBook, err := svc.AddBookToES(c.Request.Context(), esBook) if err != nil { item.Error = fmt.Sprintf("插入ES失败: %v", err) result.Results = append(result.Results, item) result.FailedCount++ continue } item.Success = true item.Document = addedBook.ISBN // 使用ISBN作为文档标识 result.Results = append(result.Results, item) result.SuccessCount++ } // 根据整体结果返回相应的状态码 statusCode := 200 if result.SuccessCount == 0 { statusCode = 500 // 全部失败 } else if result.FailedCount > 0 { statusCode = 207 // 部分成功 (Multi-Status) } c.JSON(statusCode, gin.H{ "code": statusCode, "message": "批量插入完成", "data": result, }) } // validateISBNFormat 验证ISBN格式 func validateISBNFormat(isbn string) bool { if isbn == "" { return false } // 移除连字符和空格后检查是否只包含数字 cleanISBN := strings.ReplaceAll(strings.ReplaceAll(isbn, "-", ""), " ", "") if len(cleanISBN) < 10 || len(cleanISBN) > 13 { return false } // 检查是否只包含数字 for _, r := range cleanISBN { if r < '0' || r > '9' { return false } } return true } // CheckBookExistsRequest 检查书籍是否存在的请求结构体 type CheckBookExistsRequest struct { ISBN string `json:"isbn" binding:"required"` // 要查询的ISBN } // CheckBookExistsResponse 检查书籍是否存在的响应结构体 type CheckBookExistsResponse struct { Exists bool `json:"exists"` // 是否存在 ISBN string `json:"isbn"` // 查询的ISBN BookID string `json:"book_id"` // 书籍ID（如果存在） BookName string `json:"book_name"` // 书名（如果存在） Message string `json:"message"` // 提示信息 } // CheckBookExistsByISBN 根据ISBN检查书籍是否存在 func (svc *ESSearchService) CheckBookExistsByISBN(isbn string) *CheckBookExistsResponse { isbn = strings.TrimSpace(isbn) log.Printf("[CheckBookExistsByISBN] 开始检查 | ISBN=%s", isbn) if isbn == "" { return &CheckBookExistsResponse{ Exists: false, ISBN: "", Message: "ISBN不能为空", } } // 调用现有的SearchBookByISBN方法 book, err := svc.SearchBookByISBN(isbn) if err != nil { log.Printf("[CheckBookExistsByISBN] 查询失败: %v", err) return &CheckBookExistsResponse{ Exists: false, ISBN: isbn, Message: fmt.Sprintf("查询失败: %v", err), } } if book == nil { log.Printf("[CheckBookExistsByISBN] 未找到书籍 | ISBN=%s", isbn) return &CheckBookExistsResponse{ Exists: false, ISBN: isbn, Message: "未找到该ISBN对应的书籍", } } log.Printf("[CheckBookExistsByISBN] 找到书籍 | ISBN=%s, BookName=%s", isbn, book.BookName.Value) return &CheckBookExistsResponse{ Exists: true, ISBN: isbn, BookID: fmt.Sprintf("%d", book.ID), BookName: book.BookName.Value, Message: "书籍存在", } } // CheckBookExistsByISBNHandler 根据ISBN检查书籍是否存在的HTTP处理器 func (svc *ESSearchService) CheckBookExistsByISBNHandler(c *gin.Context) { // 支持GET和POST两种方式 var req CheckBookExistsRequest var _ error // GET方式：从query参数获取 if c.Request.Method == "GET" { isbn := strings.TrimSpace(c.Query("isbn")) if isbn == "" { c.JSON(400, gin.H{ "code": 400, "error": "缺少ISBN参数", "message": "请在请求中提供isbn参数，例如: ?isbn=9787020002207", }) return } req.ISBN = isbn } else { // POST方式：从JSON body获取 if err := c.ShouldBindJSON(&req); err != nil { c.JSON(400, gin.H{ "code": 400, "error": "请求参数格式错误", "message": err.Error(), }) return } } // 调用业务逻辑 result := svc.CheckBookExistsByISBN(req.ISBN) // 根据结果返回不同的状态码 statusCode := 200 if !result.Exists && result.Message == "查询失败" { statusCode = 500 // 查询出错 } else if !result.Exists { statusCode = 404 // 未找到 } c.JSON(statusCode, gin.H{ "code": statusCode, "success": result.Exists, "data": result, }) } // ConvertRedisBookToESBook 将 Redis 中的 BookInfo 转换为 ESBook func ConvertRedisBookToESBook(redisBook *request.BookInfo) *ESBook { if redisBook == nil || redisBook.Isbn == "" { return nil } // 构建图片对象 carouselUrls := []string{} if len(redisBook.ImageObject.CarouselUrlArray) > 0 { carouselUrls = redisBook.ImageObject.CarouselUrlArray } liveShootingUrls := []string{} if len(redisBook.ImageObject.DetailUrlObject.LiveShootingUrl) > 0 { liveShootingUrls = redisBook.ImageObject.DetailUrlObject.LiveShootingUrl } // 提取第一张轮播图作为 book_pic bookPicPath := "" if len(carouselUrls) > 0 { bookPicPath = carouselUrls[0] } // 提取第一张实拍图作为 book_pic_s bookPicSResponse := "" if len(liveShootingUrls) > 0 { bookPicSResponse = liveShootingUrls[0] } return &ESBook{ ISBN: redisBook.Isbn, BookName: FlexibleString{Value: redisBook.BookName}, Author: redisBook.Author, Publisher: redisBook.Publishing, PublicationTime: redisBook.PublicationDate, BindingLayout: redisBook.Binding, PageCount: NumberOrString(strconv.FormatInt(redisBook.PagesCount, 10)), WordCount: NumberOrString(strconv.FormatInt(redisBook.WordsCount, 10)), BookFormat: NumberOrString(strconv.FormatInt(redisBook.Format, 10)), FixPrice: Float64OrString(redisBook.Price), BookPic: BookPicObj{ LocalPath: "", PddPath: bookPicPath, }, BookPicS: BookPicSObj{ LocalPath: "", PddResponse: bookPicSResponse, }, BookDefPic: BookDefPicObj{ LocalPath: "", PddPath: redisBook.ImageObject.DefaultImageUrl, }, BookPicB: redisBook.ImageObject.WhiteBackgroundUrl, CatId: redisBook.CatIdObject, // 销量等字段默认为 0 DaySale7: 0, DaySale15: 0, DaySale30: 0, DaySale60: 0, DaySale90: 0, DaySale180: 0, DaySale365: 0, ThisYearSale: 0, LastYearSale: 0, TotalSale: 0, BuyCounts: 0, SellCounts: 0, IsSuit: 0, IsIllegal: 0, IsReturn: 0, IsFilter: "000000", } }