775 lines
26 KiB
Go
775 lines
26 KiB
Go
// 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
|
||
}
|