// Package service ----------------------------- // @file : oneQueryExt.go // @author : JJXu // @contact : wavingbear@163.com // @time : 2024/2/4 13:53 // ------------------------------------------- package service import ( "context" "dubbo.apache.org/dubbo-go/v3/common/logger" dubboConfig "dubbo.apache.org/dubbo-go/v3/config" "encoding/json" "errors" "fmt" "github.com/dorlolo/simpleRequest" artShow "github.com/fonchain_enterprise/fonchain-main/api/artShow" "github.com/fonchain_enterprise/fonchain-main/api/artist" "github.com/fonchain_enterprise/fonchain-main/api/artwork" "github.com/fonchain_enterprise/fonchain-main/api/artwork_query" "github.com/fonchain_enterprise/fonchain-main/pkg/cache" "github.com/fonchain_enterprise/fonchain-main/pkg/config" "github.com/fonchain_enterprise/fonchain-main/pkg/e" "github.com/fonchain_enterprise/fonchain-main/pkg/model" "github.com/fonchain_enterprise/fonchain-main/pkg/utils" "github.com/gin-gonic/gin" "github.com/go-redis/redis" "github.com/robfig/cron/v3" "go.uber.org/zap" "io" "net/http" "strings" "sync" ) var ( ArtistOneQueryAuditLock sync.RWMutex ArtistOneQueryAuditCacheKey = "artist:one_query_audit" ) var ( ArtworkOneQueryAuditLock sync.RWMutex ArtworkOneQueryAuditCacheKey = "artwork:one_query_audit" ) type ArtistOneQueryAuditReq struct { artist.OneQueryAuditReq UseCache bool `json:"useCache"` //暂存数据 } func ArtistOneQueryAudit(c *gin.Context) { fmt.Println("一键查询-画家管理-核验") var req ArtistOneQueryAuditReq var err error if err = c.ShouldBindJSON(&req); err != nil { fmt.Println("参数解析失败", err.Error()) logger.Errorf("ArtistOneQueryAudit ShouldBind err", err) ResponseQuickMsg(c, e.Failed, err.Error(), nil) return } fmt.Println("一键查询-画家管理-核验 1") //查询数据详情 auditRecordRes, err := GrpcArtistImpl.GetArtistOneQueryCheckRecordDetail(c, &artist.GetArtistOneQueryCheckRecordByIdRequest{Id: req.ID}) if err != nil { ErrorWithMark(c, e.Failed, err, "GetArtistOneQueryCheckRecordDetail Err:"+err.Error(), "更新失败") return } fmt.Println("一键查询-画家管理-核验 2") //判断是否需要暂存数据 if cache.RedisClient == nil { logger.Error("redis 客户端没有启动") ResponseQuickMsg(c, e.Failed, err.Error(), nil) return } fmt.Println("一键查询-画家管理-核验 3") ArtistOneQueryAuditLock.Lock() defer ArtistOneQueryAuditLock.Unlock() value := cache.RedisClient.Get(ArtistOneQueryAuditCacheKey) var cacheData = make(map[string]string) if value.Err() == nil { var cacheBytes []byte err2 := value.Scan(&cacheBytes) if err2 != nil { logger.Error("查询暂存数据失败", zap.Error(err)) Error(c, e.Failed, err, "查询暂存数据失败") return } err = json.Unmarshal(cacheBytes, &cacheData) if err != nil { Error(c, e.Failed, err, "暂存数据解析失败") return } } fmt.Println("一键查询-画家管理-核验 4") // 按要求同步到总部 go func() { if req.Resume2 != "" && config.Env == "prod" { artistProfile, errs := GrpcArtistImpl.ArtistInfo(context.Background(), &artist.ArtistInfoRequest{ Uid: auditRecordRes.ArtistUID, }) if errs != nil { logger.Error("同步画家简介2到总部失败", zap.Error(errs)) } else { Resume2SyncToHeadOffice(artistProfile.ProfileInfo.Name, artistProfile.ProfileInfo.Phone, req.Resume2, auditRecordRes.ArtistUID) } } }() fmt.Println("一键查询-画家管理-核验 5") if req.UseCache { //暂存Resume2 cacheData[auditRecordRes.ArtistUID] = req.Resume2 cacheBytes, err := json.Marshal(&cacheData) logger.Error("暂存数据失败1111", zap.Error(err)) if err != nil { Error(c, e.Failed, err, "暂存数据失败") return } _, err = cache.RedisClient.Set(ArtistOneQueryAuditCacheKey, cacheBytes, 0).Result() if err != nil { logger.Error("暂存数据失败2222", zap.Error(err)) Error(c, e.Failed, err, "暂存数据失败") return } ResponseQuickMsg(c, e.Ok, "暂存成功", struct{}{}) return } else { fmt.Println("一键查询-画家管理-核验 6") //如果是待画家确认，则判断是否存在邀请函,如果已存在则改为已核验 if req.OneQueryAuditReq.CheckStatus == 4 { fmt.Println("一键查询-画家管理-核验 6.1") recordResp, errs := GrpcArtistImpl.GetArtistOneQueryCheckRecordDetail(c, &artist.GetArtistOneQueryCheckRecordByIdRequest{Id: req.ID}) if errs != nil { ErrorWithMark(c, e.Failed, errs, "GetArtistOneQueryCheckRecordDetail Err", "更新失败") return } fmt.Println("一键查询-画家管理-核验 6.1.1") letterResp, errs := GrpcArtistImpl.GetInvitationLetterList(c, &artist.GetInvitationLetterListRequest{Page: 1, PageSize: 1, Query: &artist.InvitationLetterData{ShowUid: recordResp.ShowUid}}) if errs != nil { ErrorWithMark(c, e.Failed, errs, "GetInvitationLetterList Err", "更新失败") return } fmt.Println("一键查询-画家管理-核验 6.1.2") if letterResp.Total > 0 { req.OneQueryAuditReq.CheckStatus = 3 req.OneQueryAuditReq.ConfirmType = 1 } fmt.Println("一键查询-画家管理-核验 6.1.3") //魏鹏说这段代码用不到了 2024-12-12 //魏鹏说审核通过调用这个接口 //_, _ = GrpcExhibitionFClientImpl.Verification(c, &exhibition_f.VerificationReq{Type: 1, ShowUid: recordResp.ShowUid}) //fmt.Println("一键查询-画家管理-核验 6.1.4") } fmt.Println("一键查询-画家管理-核验 6.2") resp, errs := GrpcArtistImpl.OneQueryAudit(c, &req.OneQueryAuditReq) if errs != nil { ResponseQuickMsg(c, e.Failed, errs.Error(), nil) return } fmt.Println("一键查询-画家管理-核验 6.3") //清理暂存 if req.CheckStatus == 3 { fmt.Println("一键查询-画家管理-核验 6.4") if _, ok := cacheData[auditRecordRes.ArtistUID]; ok { delete(cacheData, auditRecordRes.ArtistUID) cacheBytes, err := json.Marshal(&cacheData) if err != nil { logger.Error("暂存数据清理失败1111", zap.Error(err)) Error(c, e.Failed, err, "暂存数据清理失败") return } fmt.Println("一键查询-画家管理-核验 6.5") _, err = cache.RedisClient.Set(ArtistOneQueryAuditCacheKey, cacheBytes, 0).Result() if err != nil { logger.Error("清理暂存数据失败2222", zap.Error(err)) Error(c, e.Failed, err, "清理暂存数据失败") return } } } fmt.Println("一键查询-画家管理-核验 6.6") ResponseQuickMsg(c, e.Ok, resp.Msg, resp) } return } type ArtworkOneQueryAuditRequest struct { ArtworkUid string `json:"artworkUid"` CheckStatus int32 `json:"checkStatus"` EduEvaluation string `json:"eduEvaluation"` } func ArtworkOneQueryAudit(c *gin.Context) { var req ArtworkOneQueryAuditRequest var err error if err = c.ShouldBindJSON(&req); err != nil { fmt.Println("参数解析失败", err.Error()) logger.Error("ArtworkOneQueryAudit ShouldBind err", err) ResponseQuickMsg(c, e.Failed, err.Error(), nil) return } if cache.RedisClient == nil { logger.Error("redis 客户端没有启动") ResponseQuickMsg(c, e.Failed, err.Error(), nil) return } go func() { var artworkProfileRes *artwork_query.GetArtworkProfileListResp artworkProfileRes, err = GrpcArtworkQueryImpl.GetArtworkProfileList(context.Background(), &artwork_query.GetArtworkProfileListRequest{Query: &artwork_query.ArtworkProfileData{Uuid: req.ArtworkUid}, Page: 1, PageSize: 1}) if err != nil { zap.L().Error("ArtworkOneQueryAudit.GetArtworkProfileList Err", zap.Error(err)) return } SyncArtworkResume2ToHeadOffice(artworkProfileRes.List[0].Tfnum, req.EduEvaluation) }() //判断是否需要暂存数据 ArtworkOneQueryAuditLock.Lock() defer ArtworkOneQueryAuditLock.Unlock() value := cache.RedisClient.Get(ArtworkOneQueryAuditCacheKey) var cacheData = make(map[string]string) if value.Err() == nil { var cacheBytes []byte err2 := value.Scan(&cacheBytes) if err2 != nil { logger.Error("查询暂存数据失败", zap.Error(err)) Error(c, e.Failed, err, "查询暂存数据失败") return } err = json.Unmarshal(cacheBytes, &cacheData) if err != nil { Error(c, e.Failed, err, "暂存数据解析失败") return } } if req.CheckStatus == 4 { //暂存Resume2 cacheData[req.ArtworkUid] = req.EduEvaluation cacheBytes, err := json.Marshal(&cacheData) if err != nil { logger.Error("暂存数据失败1111", zap.Error(err)) Error(c, e.Failed, err, "暂存数据失败") return } _, err = cache.RedisClient.Set(ArtworkOneQueryAuditCacheKey, cacheBytes, 0).Result() if err != nil { logger.Error("暂存数据失败2222", zap.Error(err)) Error(c, e.Failed, err, "暂存数据失败") return } ResponseQuickMsg(c, e.Ok, "暂存成功", struct{}{}) return } else { var protoReq = &artwork.OneQueryAuditReq{ ArtworkUid: req.ArtworkUid, CheckStatus: req.CheckStatus, EduEvaluation: req.EduEvaluation, } resp, errs := GrpcArtworkImpl.OneQueryAudit(context.Background(), protoReq) if errs != nil { ResponseQuickMsg(c, e.Failed, errs.Error(), nil) return } //清理暂存 if req.CheckStatus == 3 && len(cacheData) > 0 { if _, ok := cacheData[req.ArtworkUid]; ok { delete(cacheData, req.ArtworkUid) cacheBytes, err := json.Marshal(&cacheData) if err != nil { logger.Error("ArtworkOneQueryAudit缓存数据解析失败", zap.Error(err)) Error(c, e.Failed, err, "暂存数据清理失败") return } _, err = cache.RedisClient.Set(ArtworkOneQueryAuditCacheKey, cacheBytes, 0).Result() if err != nil { logger.Error("ArtworkOneQueryAudit清理暂存数据失败", zap.Error(err)) Error(c, e.Failed, err, "清理暂存数据失败") return } } } ResponseQuickMsg(c, e.Ok, resp.Msg, resp) } return } func GetArtistUidListFromOneQueryDataCache() (artistList []string, err error) { ArtistOneQueryAuditLock.RLock() //获取画家的缓存数据 value := cache.RedisClient.Get(ArtistOneQueryAuditCacheKey) //获取需要删除的画家缓存 deleteValue, deleteErrs := cache.RedisClient.Get("artist_one_query_audit_delete_cache").Result() ArtistOneQueryAuditLock.RUnlock() var cacheBytes []byte var cacheData = make(map[string]string) if value.Err() == nil { err2 := value.Scan(&cacheBytes) if err2 != nil { logger.Error("GetArtistListFromOneQueryDataCache Err:获取暂存数据失败", zap.Error(err2)) err = errors.New("获取暂存数据失败") return } err = json.Unmarshal(cacheBytes, &cacheData) if err != nil { return } if deleteErrs == nil && deleteValue != "" { deleteArtistUidList := strings.Split(deleteValue, ",") for _, deleteArtistUid := range deleteArtistUidList { if _, ok := cacheData[deleteArtistUid]; ok { delete(cacheData, deleteArtistUid) } } cache.RedisClient.Set("artist_one_query_audit_delete_cache", nil, 0) } } if len(cacheData) == 0 { return } for k, _ := range cacheData { artistList = append(artistList, k) } return } type AristOneQueryRespData struct { artist.OneQueryResp_Info CacheContent string `json:"CacheContent"` QueryShowTime string `json:"QueryShowTime"` //用户筛选的画展时间 //邀请函中的数据 HasInvitationLetter bool `json:"HasInvitationLetter"` //存在邀请函 SuggestionStatus int32 `json:"SuggestionStatus"` ModifySuggestion string `json:"ModifySuggestion"` ShowUid string `json:"ShowUid"` //画展包中的数据, 通过邀请函中的ShowUid查询 ShowName string `json:"ShowName"` //画展名称 ShowTime string `json:"ShowTime"` //实际画展时间 PreTime string `json:"PreTime"` //预计画展时间 } func UpdateArtistOneQueryDataUseCache(data []*artist.OneQueryResp_Info, permission string, queryShowTime string) (resp []*AristOneQueryRespData, err error) { fmt.Println("data len", len(data)) fmt.Println("data len", len(data)) fmt.Println("data len", len(data)) if len(data) == 0 { return } resp = []*AristOneQueryRespData{} //如果用户角色为model.PermissionPublicize，则从缓存中读取暂存数据 // 注意这个判断逻辑在本函数中有两处 var cacheData map[string]string cacheData, err = GetOneQueryCacheData() if err != nil { return } for _, v := range data { v := v var cacheContent string if permission == model.PermissionPublicize { if len(cacheData) > 0 { resume2, ok := cacheData[v.ArtistUuid] if ok { cacheContent = resume2 } } } fmt.Println("1111showUid:", v.ShowUid) resp = append(resp, &AristOneQueryRespData{ CacheContent: cacheContent, QueryShowTime: queryShowTime, OneQueryResp_Info: artist.OneQueryResp_Info{ CardId: v.CardId, Tnum: v.Tnum, StyleFaction: v.StyleFaction, Resume: v.Resume, Age: v.Age, CaaCertNum: v.CaaCertNum, PenName: v.PenName, CoopPlatform: v.CoopPlatform, Gender: v.Gender, Student: v.Student, Teacher: v.Teacher, NativePlace: v.NativePlace, Name: v.Name, School: v.School, Position: v.Position, StageName: v.StageName, CaaJoinTime: v.CaaJoinTime, ArtistUuid: v.ArtistUuid, JoinShow: v.JoinShow, Phone: v.Phone, Resume2: v.Resume2, CheckStatus: v.CheckStatus, ShowUid: v.ShowUid, ID: v.ID, PkUuid: v.PkUuid, }, ShowUid: v.ShowUid, }) } return } func UpdateArtistOneQueryDataUseInvitationLetter(data []*AristOneQueryRespData) error { if len(data) == 0 { return nil } var showUids []string for _, v := range data { showUids = append(showUids, v.ShowUid) } fmt.Println("showUids:", showUids) invitationList, err := GrpcArtistImpl.GetInvitationLetterList(context.Background(), &artist.GetInvitationLetterListRequest{ShowUids: showUids}) if err != nil { logger.Error("UpdateArtistOneQueryDataUseInvitationLetter.GetInvitationLetterList error", zap.Error(err)) fmt.Println("GrpcArtistImpl.GetInvitationLetterLis err:", err.Error()) return err } fmt.Println("invitationList.Total:", invitationList.Total) for i, v1 := range data { fmt.Println("ShowUid1:", v1.ShowUid) var findedLetter bool for _, v2 := range invitationList.List { v2 := v2 if v1.ShowUid == v2.ShowUid { findedLetter = true fmt.Println("ShowUid2:", v2.ShowUid) data[i].SuggestionStatus = v2.SuggestionStatus data[i].ModifySuggestion = v2.ModifySuggestion break } data[i].HasInvitationLetter = findedLetter } } return nil } func UpdateArtistOneQueryDataUseArtShow(data []*AristOneQueryRespData) error { if len(data) == 0 { return nil } var showUids []string for _, v := range data { showUids = append(showUids, v.ShowUid) } fmt.Println("UpdateArtistOneQueryDataUseArtShow --1") showTimeRes, err := GrpcArtShowImpl.GetShowTimeWithShowUid(context.Background(), &artShow.GetShowTimeWithShowUidReq{ShowUids: showUids}) if err != nil { return err } fmt.Println("UpdateArtistOneQueryDataUseArtShow --2") recordRes, errs := GrpcArtistImpl.GetArtistOneQueryCheckRecordList(context.Background(), &artist.GetArtistOneQueryCheckRecordListRequest{Page: 1, PageSize: -1, ShowUids: showUids}) if errs != nil { return errs } fmt.Println("UpdateArtistOneQueryDataUseArtShow --3") fmt.Printf("UpdateArtistOneQueryDataUseArtShow data:%+v\n\n", data) fmt.Printf("UpdateArtistOneQueryDataUseArtShow showTimeRes:%+v\n\n", showTimeRes) fmt.Printf("UpdateArtistOneQueryDataUseArtShow recordRes.List:%+v\n\n", showTimeRes) for i, v := range data { for _, sub := range showTimeRes.Data { if v.ShowUid == sub.ShowUid { sub := sub data[i].PreTime = sub.PreTime data[i].ShowTime = sub.ShowTime data[i].ShowName = sub.ShowName } } for _, r := range recordRes.List { if r.ShowUid == v.ShowUid { r := r data[i].ConfirmType = r.ConfirmType data[i].ConfirmTime = r.ConfirmTime } } } fmt.Println("UpdateArtistOneQueryDataUseArtShow --4") return nil } func GetArtworkUidListFromOneQueryDataCache() (artworkUidList []string, err error) { ArtworkOneQueryAuditLock.RLock() value := cache.RedisClient.Get(ArtworkOneQueryAuditCacheKey) ArtworkOneQueryAuditLock.RUnlock() var cacheBytes []byte var cacheData = make(map[string]string) if value.Err() == nil { err2 := value.Scan(&cacheBytes) if err2 != nil { logger.Error("GetArtworkUidListFromOneQueryDataCache Err:获取暂存数据失败", zap.Error(err2)) err = errors.New("获取暂存数据失败") return } err = json.Unmarshal(cacheBytes, &cacheData) if err != nil { return } } if len(cacheData) > 0 { for k, _ := range cacheData { artworkUidList = append(artworkUidList, k) } } return } type ArtworkOneQueryRespData struct { artwork_query.OneQueryResp_Info CacheContent string `json:"CacheContent"` } func UpdateArtworkOneQueryDataUseCache(data []*artwork_query.OneQueryResp_Info, permission string) (resp []ArtworkOneQueryRespData, err error) { resp = []ArtworkOneQueryRespData{} //判断是否需要暂存数据 var value *redis.StringCmd var cacheData = make(map[string]string) //如果是permission=auth_search_training,需要从缓存中获取暂存的画作简介2 //注意permission这个判断逻辑在本函数中有两个地方 if permission == "auth_search_training" { ArtworkOneQueryAuditLock.RLock() value = cache.RedisClient.Get(ArtworkOneQueryAuditCacheKey) ArtworkOneQueryAuditLock.RUnlock() if value.Err() == nil { var cacheBytes []byte err2 := value.Scan(&cacheBytes) if err2 != nil { logger.Error("获取暂存数据失败", zap.Error(err2)) err = errors.New("获取暂存数据失败") return } err = json.Unmarshal(cacheBytes, &cacheData) if err != nil { return } } } for _, v := range data { v := v var cacheContent string if permission == "auth_search_training" { content, ok := cacheData[v.ArtworkUuid] fmt.Println("for:", v.ArtworkUuid, ok, content) if ok { cacheContent = content } } resp = append(resp, ArtworkOneQueryRespData{ OneQueryResp_Info: artwork_query.OneQueryResp_Info{ ArtworkName: v.ArtworkName, ArtistName: v.ArtistName, Length: v.Length, Width: v.Width, Ruler: v.Ruler, Abstract: v.Abstract, Comment: v.Comment, ArtworkUuid: v.ArtworkUuid, DigiArtImg: v.DigiArtImg, EduEvaluation: v.EduEvaluation, CheckStatus: v.CheckStatus, ArtistUuid: v.ArtistUuid, }, CacheContent: cacheContent, }) } return } func ArtistOneQueryShowTimePoint(c *gin.Context) { var showUidList = []string{} recordRes, err := GrpcArtistImpl.GetArtistOneQueryCheckRecordList(c, &artist.GetArtistOneQueryCheckRecordListRequest{Query: nil, Where: "check_status = 2 OR check_status=5", Page: 1, PageSize: -1}, ) fmt.Println("recordRes.Total:", recordRes.Total) if err != nil { logger.Error("ArtistOneQueryShowTimePoint Err:", zap.Error(err)) ResponseData(c, showUidList) return } if len(recordRes.List) == 0 { ResponseData(c, showUidList) return } else { for _, v := range recordRes.List { showUidList = append(showUidList, v.ShowUid) } } fmt.Println("showUidList :", showUidList) res, err := GrpcArtShowImpl.GetShowTimeWithShowUid(c, &artShow.GetShowTimeWithShowUidReq{ShowUids: showUidList}) if err != nil { fmt.Println("GetShowTimeWithShowUid err", err.Error()) ResponseData(c, []struct{}{}) return } if len(res.Data) == 0 { fmt.Println("GetShowTimeWithShowUid 数据为空") ResponseData(c, []struct{}{}) return } var showTimeList []string for _, v := range res.Data { if v.ShowTime != "" { showTimeList = append(showTimeList, getYearMonth(v.ShowTime)) } else if v.PreTime != "" { showTimeList = append(showTimeList, getYearMonth(v.PreTime)) } } showTimeList = utils.ArrayDeduplicate(showTimeList) fmt.Println("ShowTimeList :", showTimeList) ResponseData(c, showTimeList) } func getYearMonth(timeStr string) string { items := strings.Split(timeStr, "-") return fmt.Sprintf("%s-%s", items[0], items[1]) } func OneQueryTask(c *cron.Cron) { if dubboConfig.GetConsumerService("ArtistInfoUserClientImpl") != nil && dubboConfig.GetConsumerService("ArtistClientImpl") != nil { var cronSchedulerSpaceTime = "0 0 * * *" //每天凌晨执行 if config.Env == "test" || config.Env == "dev" { cronSchedulerSpaceTime = "*/1 * * * *" //每分钟执行一次 } _, err := c.AddFunc(cronSchedulerSpaceTime, func() { resp, err := GrpcArtistImpl.UpdateOneQueryCheckStatusThatUserNotPerformed(context.Background(), &artist.UpdateOneQueryCheckStatusThatUserNotPerformedReq{}) if err != nil { zap.L().Error("执行定时任务[更新用户在7天内没有确认的'一键查询画家'的审批状态]失败", zap.Error(err)) } //个人简介2同步到总部 if config.Env == "prod" { for _, artistUid := range resp.ArtistUidList { artistProfileRes, errs := GrpcArtistImpl.ArtistInfo(context.Background(), &artist.ArtistInfoRequest{Uid: artistUid}) if errs != nil { zap.L().Error("OneQueryTask 获取画家信息失败", zap.Error(errs), zap.String("artistUid", artistUid)) continue } cacheData, cacheErr := GetOneQueryCacheData() if cacheErr != nil { zap.L().Error("OneQueryTask 获取暂存数据失败", zap.Error(cacheErr), zap.String("artistUid", artistUid)) continue } var resume2 string if len(cacheData) > 0 { var ok bool resume2, ok = cacheData[artistUid] if ok { cacheData[artistUid] = resume2 } else { var recordRes *artist.GetArtistOneQueryCheckRecordListResp recordRes, err = GrpcArtistImpl.GetArtistOneQueryCheckRecordList(context.Background(), &artist.GetArtistOneQueryCheckRecordListRequest{Query: &artist.ArtistOneQueryCheckRecordData{ArtistUID: artistUid}, Page: 1, PageSize: -1, Order: "id desc"}) if err != nil { zap.L().Error("OneQueryTask 获取画家审核记录失败", zap.Error(err), zap.String("artistUid", artistUid)) continue } if recordRes.Total > 0 { resume2 = recordRes.List[0].Resume2 } } } Resume2SyncToHeadOffice(artistProfileRes.ProfileInfo.Name, artistProfileRes.ProfileInfo.Phone, resume2, artistUid) } } }) if err != nil { zap.L().Error("添加定时任务[[更新用户在7天内没有确认的'一键查询画家'的审批状态]失败", zap.Error(err)) return } } } // Resume2SyncToHeadOffice 个人简介2同步到总部 func Resume2SyncToHeadOffice(artistName, phone, resume2, artistUid string) { httpReq := simpleRequest.NewRequest() httpReq.Headers().ConentType_json() httpReq.Body().Sets(map[string]interface{}{ "artist_name": artistName, "brand_phone": phone, "artist_desc": resume2, }) results, errs := httpReq.POST("https://www.tyfon.com.cn/index.php?app=fontree&act=add_brand") if errs != nil { zap.L().Error("同步画家简介2到总部失败,请求失败", zap.Error(errs), zap.String("artist_uid", artistUid)) fmt.Println("同步画家简介2到总部失败,请求失败", errs) } else { var resultBody = struct { Code int `json:"code"` Msg string `json:"msg"` }{} _ = json.Unmarshal(results, &resultBody) if resultBody.Code != 200 { zap.L().Error("同步画家简介2到总部失败,请求失败", zap.Error(errs), zap.String("artist_uid", artistUid), zap.Any("resultBody", resultBody)) fmt.Println("同步画家简介2到总部失败", resultBody.Msg) } else { zap.L().Info("同步画家简介2到总部成功", zap.String("artist_uid", artistUid)) } } } // GetOneQueryCacheData 获取redis中缓存的个人简介2数据 map[{artistUid}]{resume2} func GetOneQueryCacheData() (cacheData map[string]string, err error) { ArtistOneQueryAuditLock.RLock() value := cache.RedisClient.Get(ArtistOneQueryAuditCacheKey) ArtistOneQueryAuditLock.RUnlock() if value.Err() == nil { var cacheBytes []byte err2 := value.Scan(&cacheBytes) if err2 != nil { logger.Error("获取暂存数据失败", zap.Error(err2)) err = errors.New("获取暂存数据失败") } fmt.Println("cacheBytes:", string(cacheBytes)) err = json.Unmarshal(cacheBytes, &cacheData) return } return nil, value.Err() } // 同步画家评价2到总部 func SyncArtworkResume2ToHeadOffice(tfnum, resume2 string) error { httpReq := simpleRequest.NewRequest() httpReq.Headers().ConentType_json() httpReq.Body().Sets(map[string]any{ "app": "fontree", "act": "batch_add_art", "art_arr": []map[string]any{ { "cert_id": tfnum, "art_desc": resume2, }, }, }) resBytes, err := httpReq.POST("https://www.tyfon.com.cn/index.php?app=fontree&act=batch_add_art") if err != nil { return err } var res struct { Code int `json:"code"` Msg string `json:"msg"` } _ = json.Unmarshal(resBytes, &res) if res.Code != 0 { zap.L().Error("同步画作评价2到总部失败", zap.String("msg", res.Msg), zap.Any("res", res), zap.String("tfnum", tfnum)) } else { zap.L().Info("同步画作评价2到总部成功", zap.String("tfnum", tfnum)) } return nil } func SyncArtworkTest(c *gin.Context) { var req = struct { Tfnum string `json:"tfnum"` Resume2 string `json:"resume2"` }{} if err := c.ShouldBindJSON(&req); err != nil { fmt.Println("参数解析失败", err.Error()) logger.Error("SyncArtworkTest ShouldBind err", err) ResponseQuickMsg(c, e.Failed, err.Error(), nil) return } err := SyncArtworkResume2ToHeadOffice(req.Tfnum, req.Resume2) if err != nil { ResponseQuickMsg(c, e.Failed, err.Error(), nil) return } ResponseQuickMsg(c, e.Ok, "同步成功", nil) } // 下载长文本字符串 func DownloadIfHttpLongText(resume string) string { if strings.HasPrefix(resume, "http") { //下载文字内容 resumeResp, _ := http.Get(resume) defer resumeResp.Body.Close() body, _ := io.ReadAll(resumeResp.Body) if body != nil { return string(body) } } return resume }