fonchain-fiee/pkg/service/artistInfo/asArtwork/supplement.go

// Package asArtwork -----------------------------
// @file      : artworkSupplement.go
// @author    : JJXu
// @contact   : wavingbear@163.com
// @time      : 2023/2/27 11:22
// -------------------------------------------

package asArtwork

import (
	"context"
	"encoding/json"
	"fmt"
	artShow "github.com/fonchain_enterprise/fonchain-main/api/artShow"
	"github.com/fonchain_enterprise/fonchain-main/api/artistInfoArtwork"
	"github.com/fonchain_enterprise/fonchain-main/api/artistInfoUser"
	"github.com/fonchain_enterprise/fonchain-main/api/artistinfoArtshow"
	"github.com/fonchain_enterprise/fonchain-main/api/artwork"
	"github.com/fonchain_enterprise/fonchain-main/api/artwork_query"
	"github.com/fonchain_enterprise/fonchain-main/pkg/common/syncDownload"
	"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/service"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/artistInfo/asPush"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/artistInfo/asUser"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/artistInfo/asUtil"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils/excel"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils/stime"
	"github.com/gin-gonic/gin"
	"os"
	"path"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

// 画作补充信息
var Supplement = artworkSupplement{}

// 画作补充模块
type artworkSupplement struct {
}

// GetUnsupplementedExtDataList 获取补充信息的画作列表
//func (a artworkSupplement) GetUnsupplementedDataList(c *gin.Context) {
//	var req GetAuditSupplementDataListRequest
//	if err := c.ShouldBindJSON(&req); err != nil {
//		service.Error(c, e.InvalidParams, err, err.Error())
//		return
//	}
//	if req.ArtistUid == "" {
//		userInfo, err, code := asAccount.GetUserInfoWithToken(c)
//		if err != nil {
//			service.Error(c, code, err, err.Error())
//			return
//		}
//		req.ArtistUid = userInfo.MgmtArtistUid
//	}
//	artworkDatas, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords(c, &artistInfoArtwork.GetArtworkLockRecordsRequest{
//		ArtistUid: req.ArtistUid,
//		QueryType: artistInfoArtwork.ArtworkQueryMode_NowLockedArtwork,
//	})
//	if err != nil {
//		service.Error(c, e.Failed, err, err.Error())
//		return
//	}
//	var cleanDatas = []*artistInfoArtwork.ArtistLockInfo{}
//	for i, v := range artworkDatas.Data {
//		//筛选出已被锁定并且未审核通过的画作
//		if v.Status == 2 && v.LockTime != "" && v.SupplementAuditStatus != 2 {
//			cleanDatas = append(cleanDatas, artworkDatas.Data[i])
//		}
//	}
//	result, err := ReplenishArtwork(cleanDatas)
//	if err != nil {
//		service.ErrorWithMark(c, e.Failed, err, "GetIncompleteExtDataList ReplenishArtwork Error", err.Error())
//		return
//	}
//	service.ResponseList(c, result, service.OptionPage(req.Page, req.PageSize, len(result)), service.OptionMsg("查询成功"))
//}

// Detail 获取画作补充信息详情
func (a artworkSupplement) Detail(c *gin.Context) {
	var req DelAwRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	res, err := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{
		Type:        "1,2,3", //1=首选项 2=画作荣誉信息  3=获取画作补充信息
		ArtworkUuid: req.ArtworkUuid,
	})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "Detail: GrpcArtworkImpl.ArtworkDetail", "查询失败")
		return
	}
	lockRecords, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockDetail(c, &artistInfoArtwork.GetArtworkLockDetailRequest{
		ArtworkUid: res.ArtworkUuid,
	})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "Detail : GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error", err.Error())
		return
	}
	//转换成利于前端对接的数据结构
	var returnData = ArtworkSupplementInfo{}
	err = returnData.ConvertResponse(lockRecords, res.ProfileInfo, res.MarketInfo, res.ExtDataInfo)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "Detail:returnData.ConvertResponse", "查询失败")
		return
	}
	service.Success(c, returnData)
}

// GetSupplementDataListAtUserSide 获取用户端画作补充信息列表
func (a artworkSupplement) GetSupplementDataListAtUserSide(c *gin.Context) {
	userInfo, err, code := asUser.GetUserInfoWithToken(c)
	if err != nil {
		service.Error(c, code, err, err.Error())
		return
	}

	var req GetSupplementDataListAtUserSideRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}

	lockRecords, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords(c, &artistInfoArtwork.GetArtworkLockRecordsRequest{
		ArtistUid: userInfo.MgmtArtistUid,
		QueryType: artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfSupplementing,
	})
	if err != nil {
		service.ErrorWithMark(c, code, err, "GetSupplementDataListAtUserSide : GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error", err.Error())
		return
	}
	var datasPagination = []*artistInfoArtwork.ArtworkLockInfo{}
	if req.PageSize != -1 {
		for k, v := range lockRecords.Data {
			if k >= req.PageSize*(req.Page-1) && k < req.PageSize*req.Page {
				datasPagination = append(datasPagination, v)
			}
		}
	} else {
		datasPagination = lockRecords.Data
	}
	//returnDatas, err := ReplenishArtwork(datasPagination)
	//if err != nil {
	//	service.ErrorWithMark(c, code, err, "GetSupplementDataListAtUserSide :ReplenishArtwork Error", err.Error())
	//	return
	//}
	var returnDatas []ArtworkSupplementInfo
	for _, v := range datasPagination {
		// todo 后续优化
		artworkDetail, err := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{
			Type:        "1,2,3",
			ArtworkUuid: v.ArtworkUid,
		})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide : GrpcArtworkImpl.ArtworkDetail Error", err.Error())
			return
		}
		var data ArtworkSupplementInfo
		if err = data.ConvertResponse(v, artworkDetail.ProfileInfo, artworkDetail.MarketInfo, artworkDetail.ExtDataInfo); err != nil {
			service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide : data.ConvertResponse Error", err.Error())
			return
		}
		returnDatas = append(returnDatas, data)
	}
	service.ResponseList(c, returnDatas, service.OptionPage(req.Page, req.PageSize, len(returnDatas)), service.OptionMsg("查询成功"))
}

// GetSupplementDataListAtBackendSide 获取后台的画作补充信息列表
// Deprecated: 此方法已弃用,请使用 GetSupplementDataListAtBackendSide2 替代
func (a artworkSupplement) GetSupplementDataListAtBackendSide(c *gin.Context) {
	var req GetSupplementDataListAtBackendSideRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	//模糊查询画作名称
	var artworkUids []string
	if req.ArtworkName != "" {
		res, err := service.GrpcArtworkQueryImpl.ArtworkPreviewList(c, &artwork_query.ArtworkPreviewListRequest{ArtworkName: req.ArtworkName, ArtistUid: req.ArtistUid})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "GetArtworkPreviewListAtBackendSide: GrpcArtworkQueryImpl.ArtworkPreviewList Error", "画作服务查询失败")
		}
		for _, v := range res.Data {
			artworkUids = append(artworkUids, v.ArtworkUid)
		}
	}
	var lockRecords *artistInfoArtwork.ArtworkLockList
	var err error
	if req.History {
		lockRecords, err = service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords(c, &artistInfoArtwork.GetArtworkLockRecordsRequest{
			ArtistUid:             req.ArtistUid,
			QueryType:             artistInfoArtwork.ArtworkQueryMode_HistorySupplementInfo,
			ArtworkUids:           artworkUids,
			SupplementAuditStatus: int64(req.SupplementAuditStatus),
		})
	} else {
		lockRecords, err = service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords(c, &artistInfoArtwork.GetArtworkLockRecordsRequest{
			ArtistUid:             req.ArtistUid,
			QueryType:             artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfSupplementing,
			ArtworkUids:           artworkUids,
			SupplementAuditStatus: int64(req.SupplementAuditStatus),
		})
	}
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide : GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error", err.Error())
		return
	}
	var datasPagination = []*artistInfoArtwork.ArtworkLockInfo{}
	if req.PageSize != -1 {
		for k, v := range lockRecords.Data {
			if k >= req.PageSize*(req.Page-1) && k < req.PageSize*req.Page {
				datasPagination = append(datasPagination, v)
			}
		}
	} else {
		datasPagination = lockRecords.Data
	}
	//datas, err := ReplenishArtwork(datasPagination)
	//if err != nil {
	//	service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide :ReplenishArtwork Error", err.Error())
	//	return
	//}
	var returnDatas []ArtworkSupplementInfo
	for _, v := range datasPagination {
		// todo 后续优化 提升效率
		artworkDetail, err := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{
			Type:        "123",
			ArtworkUuid: v.ArtworkUid,
		})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide : GrpcArtworkImpl.ArtworkDetail Error", err.Error())
			return
		}
		var data = ArtworkSupplementInfo{}
		if err = data.ConvertResponse(v, artworkDetail.ProfileInfo, artworkDetail.MarketInfo, artworkDetail.ExtDataInfo); err != nil {
			service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide : data.ConvertResponse Error", err.Error())
			return
		}
		returnDatas = append(returnDatas, data)
	}
	service.ResponseList(c, returnDatas, service.OptionPage(req.Page, req.PageSize, len(lockRecords.Data)), service.OptionMsg("查询成功"))
}

// UpdateExtData 更新画作补充信息
func (artworkSupplement) UpdateSupplement(c *gin.Context) {
	//userInfo, err, code := asAccount.GetUserInfoWithToken(c)
	//if err != nil {
	//	service.Error(c, code, err, err.Error())
	//	return
	//}
	var req ArtworkSupplementInfo
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	if req.ArtworkUuid == "" {
		service.Error(c, e.InvalidParams, nil, "画作uid不能为空")
		return
	}
	//查询画作锁定和审批状态
	artworkLock, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockDetail(c, &artistInfoArtwork.GetArtworkLockDetailRequest{ArtworkUid: req.ArtworkUuid})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtistInfoArtworkImpl.GetArtworkLockDetail Error", "更新失败")
		return
	}
	if artworkLock.Status != 2 {
		service.Error(c, e.Failed, nil, "画作未在锁定列表，操作取消")
		return
	}
	profile, marketDatas, extdata := req.ConvertGrpcRequest()
	//更新首选项
	_, err = service.GrpcArtworkImpl.UpdateArtworkProfile(c, profile)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtworkImpl.UpdateExtData Error", "更新失败")
		return
	}
	//更新荣誉
	for _, marketData := range marketDatas {
		_, err = service.GrpcArtworkImpl.UpdateMarketInfo(c, marketData)
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtworkImpl.UpdateExtData Error", "更新失败")
			return
		}
	}
	//更新网络首发情况
	_, err = service.GrpcArtworkImpl.UpdateExtData(c, extdata)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtworkImpl.UpdateExtData Error", "更新失败")
		return
	}
	service.Success(c)
}

// AuditExt 画作基本信息和补充信息审批
func (artworkSupplement) AuditSupplement(c *gin.Context) {
	accInfo, err, code := asUser.GetAccInfoWithToken(c)
	if err != nil {
		service.Error(c, code, err, err.Error())
		return
	}

	var req AuditSupplement
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	var artworkUids = []string{}
	if req.ArtworkUid != "" {
		artworkUids = append(artworkUids, req.ArtworkUid)
	} else if req.ArtworkUids != nil {
		artworkUids = append(artworkUids, req.ArtworkUids...)
	}
	defer func() {
		if err != nil {
			return
		}
		for _, artworkUid := range artworkUids {
			if req.FlowIndex == 2 {
				asUser.UpdateOperationTime(c, artistinfoArtshow.OdType_artworkBaseData, artworkUid)
			} else if req.FlowIndex == 3 {
				asUser.UpdateOperationTime(c, artistinfoArtshow.OdType_artworkSupplyData, artworkUid)
			}
		}
		if (req.AuditStatus != 4 && req.FlowIndex == 2) || req.FlowIndex == 3 {
			pusher := asPush.NewPusher()
			for _, artworkUid := range artworkUids {
				//查询画作锁定和审批状态
				artworkLock, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockDetail(context.Background(), &artistInfoArtwork.GetArtworkLockDetailRequest{ArtworkUid: artworkUid})
				if err != nil {
					service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtistInfoArtworkImpl.GetArtworkLockDetail Error", "审批失败")
					return
				}
				if artworkLock.Status == 3 {
					service.Error(c, e.Failed, nil, "画作已解锁，不允许审批")
					return
				}
				//生成流转记录请求数据
				flowRecord, auditType, auditResult := generateArtworkAuditFlowIndex(req.AuditStatus, req.FlowIndex, artworkLock, time.Now().Unix())
				if req.AuditMark != "" {
					flowRecord.ClauseList = append(flowRecord.ClauseList, req.AuditMark)
				}
				if req.AuditMark2 != "" {
					flowRecord.ClauseList = append(flowRecord.ClauseList, req.AuditMark2)
				}
				fmt.Printf("flowRecord:%+v\n", flowRecord)
				_, err = service.GrpcArtistInfoArtworkImpl.AddArtworkFlowRecord(context.Background(), flowRecord)
				if err != nil {
					fmt.Println("AuditSupplement AddArtworkFlowRecord Err：", err.Error())
				}
				//发送审批通知
				userData, err := service.GrpcArtistInfoUserImpl.FindUser(context.Background(), &artistInfoUser.FindUserRequest{MgmtArtistUid: artworkLock.ArtistUid})
				if err != nil {
					fmt.Println("AuditSupplement FindUser Err：", err.Error())
					continue
				}
				artworkView, err := service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(context.Background(), &artistInfoArtwork.ArtworkViewRequest{ArtworkUids: []string{artworkUid}, PageSize: 1, Page: 1})
				if err != nil || artworkView.Total == 0 {
					fmt.Println("AuditSupplement GetArtworkViewList Err：", err.Error())
					continue
				}
				//if err = asUser.ArtistInfoPushNotice.ArtworkAuditResultNotice(userData.Id, artworkView.Datas[0].ArtworkName, auditType, auditResult); err != nil {
				//	fmt.Println("AuditSupplement ArtworkAuditResultNotice Err：", err.Error())
				//}
				if err = pusher.ArtworkAuditResultNotice(userData.Id, artworkView.Datas[0].ArtworkName, auditType, auditResult); err != nil {
					fmt.Println("AuditSupplement ArtworkAuditResultNotice Err：", err.Error())
				}

			}
		}
	}()
	fmt.Println("accInfo:", accInfo.ID, accInfo.NickName)
	_, err = service.GrpcArtistInfoArtworkImpl.UpdateArtworkAuditStatus(c, req.ConvertGrpcRequest(accInfo.ID, accInfo.NickName))
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtistInfoArtworkImpl.UpdateArtworkAuditStatus Error", "审批失败")
		return
	}

	service.Success(c)
}

// 基本画作重新审批
// Deprecated 此逻辑由前端控制，后台不需要处理
func (artworkSupplement) ReAuditBaseInfo(c *gin.Context) {

	accInfo, err, code := asUser.GetAccInfoWithToken(c)
	if err != nil {
		service.Error(c, code, err, err.Error())
		return
	}

	var req AuditSupplement
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	artworkDetail, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockDetail(c, &artistInfoArtwork.GetArtworkLockDetailRequest{ArtworkUid: req.ArtworkUid})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtistInfoArtworkImpl.GetArtworkLockDetail Error", "查询画作信息失败")
		return
	}
	if artworkDetail.Status == 3 {
		service.Error(c, e.Failed, nil, "画作已解锁，不允许重新审批")
		return
	}
	if artworkDetail.BaseAuditStatus == 7 {
		service.Error(c, e.Failed, nil, "画作处于复审中，不允许重新审批")
		return
	}
	if artworkDetail.BaseAuditStatus == 4 {
		service.Error(c, e.Failed, nil, "画作审批状态为已通过，不允许重新审批！")
		return
	}
	fmt.Println("accInfo:", accInfo.ID, accInfo.NickName)
	_, err = service.GrpcArtistInfoArtworkImpl.UpdateArtworkAuditStatus(c, req.ConvertGrpcRequest(accInfo.ID, accInfo.NickName))
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtistInfoArtworkImpl.UpdateArtworkAuditStatus Error", "审批失败")
		return
	}
	{
		//记录操作时间
		if req.FlowIndex == 2 {
			asUser.UpdateOperationTime(c, artistinfoArtshow.OdType_artworkBaseData, req.ArtworkUid)
		} else if req.FlowIndex == 3 {
			asUser.UpdateOperationTime(c, artistinfoArtshow.OdType_artworkSupplyData, req.ArtworkUid)
		}
		//生成流转记录请求数据
		if req.AuditStatus != 4 {
			flowRecord, auditType, auditResult := generateArtworkAuditFlowIndex(req.AuditStatus, req.FlowIndex, artworkDetail, time.Now().Unix())
			fmt.Printf("flowRecord:%+v\n", flowRecord)
			_, err = service.GrpcArtistInfoArtworkImpl.AddArtworkFlowRecord(context.Background(), flowRecord)
			if err != nil {
				fmt.Println("AuditSupplement AddArtworkFlowRecord Err：", err.Error())
			}
			//发送审批通知
			userData, err := service.GrpcArtistInfoUserImpl.FindUser(context.Background(), &artistInfoUser.FindUserRequest{MgmtArtistUid: artworkDetail.ArtistUid})
			if err != nil {
				fmt.Println("AuditSupplement FindUser Err：", err.Error())
				return
			}
			artworkView, err := service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(context.Background(), &artistInfoArtwork.ArtworkViewRequest{ArtworkUids: []string{req.ArtworkUid}, PageSize: 1, Page: 1})
			if err != nil || artworkView.Total == 0 {
				fmt.Println("AuditSupplement GetArtworkViewList Err：", err.Error())
				return
			}
			//if err = asUser.ArtistInfoPushNotice.ArtworkAuditResultNotice(userData.Id, artworkView.Datas[0].ArtworkName, auditType, auditResult); err != nil {
			//	fmt.Println("AuditSupplement ArtworkAuditResultNotice Err：", err.Error())
			//}
			pusher := asPush.NewPusher()
			if err = pusher.ArtworkAuditResultNotice(userData.Id, artworkView.Datas[0].ArtworkName, auditType, auditResult); err != nil {
				fmt.Println("AuditSupplement ArtworkAuditResultNotice Err：", err.Error())
			}

		}

	}
	service.Success(c)
}

// GenerateSupplementInfo 生成画作补充信息
func (a artworkSupplement) GenerateSupplementInfo(c *gin.Context) {
	var req GenerateSupplementInfoRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	if req.ArtworkUids == nil {
		service.Error(c, e.InvalidParams, nil, "artworkUids 不能为空")
		return
	}
	err := SupplementService.GenerateSupplementInfo(req.ArtworkUids)
	if err != nil {
		service.Error(c, e.Failed, err, "生成失败")
		return
	}
	service.Success(c)
}

// ReviewBaseArtwork 画作基本信息复审列表
func (a artworkSupplement) ReviewBaseArtworkList(c *gin.Context) {
	var req GetViewReviewArtworkListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var protoReq = artistInfoArtwork.GetViewReviewArtworkListRequest{}
	asUtil.RequestDataConvert(&req, &protoReq)
	if req.History {
		history, err := service.GrpcArtistInfoArtworkImpl.GetArtworkBaseAuditHistoryList(c, &artistInfoArtwork.GetArtworkBaseAuditHistoryListRequest{
			Query: &artistInfoArtwork.ArtworkBaseAuditHistoryData{
				ArtistUid: req.ArtistUid,
				Node:      2,
			},
			Page:     1,
			PageSize: -1,
		})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "ReviewBaseArtworkList:GetArtworkBaseAuditHistoryList Err", "查询失败")
			return
		}
		var artworkUids []string
		for _, v := range history.List {
			artworkUids = append(artworkUids, "'"+v.ArtworkUid+"'")
		}
		if len(artworkUids) == 0 {
			service.ResponseList(c, []struct{}{}, service.OptionPage(req.Page, req.PageSize, history.Total), service.OptionMsg("查询成功"))
			return
		}
		protoReq.Where = fmt.Sprintf("artwork_uid in (%s)", "'"+strings.Join(artworkUids, "','")+"'")
	}
	resp, err := service.GrpcArtistInfoArtworkImpl.GetViewReviewArtworkList(c, &protoReq)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetViewReviewArtworkList Err", "查询失败")
		return
	}
	if !req.History {
		cacheData, err := service.GrpcArtistInfoArtworkImpl.GetTempSaveReviewStatusList(c, &artistInfoArtwork.GetTempSaveReviewStatusListRequest{
			CacheArtistUid: req.ArtistUid,
		})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "ReviewBaseArtworkList:GetArtworkBaseAuditHistoryList Err222", "查询失败")
			return
		}
		for _, v := range cacheData.List {
			for i, _ := range resp.List {
				if v.ArtworkUid == resp.List[i].ArtworkUid {
					resp.List[i].ReviewStatus = artistInfoArtwork.ReviewAuditStatus(v.ReviewStatus)
					resp.List[i].ReviewMark = v.ReviewMark
					resp.List[i].ReviewMark2 = v.ReviewMark2
					resp.List[i].ReviewUpdatedAt = v.OptTime
					break
				}
			}
		}
	}
	service.ResponseList(c, resp.List,
		service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"),
		service.OptionAddField_ArtshowCount("artistUid"),
	)
}

// 复审画作
func (a artworkSupplement) ReviewBaseArtwork(c *gin.Context) {
	var req artistInfoArtwork.ReviewBaseArtworkAuditRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	//获取账号信息
	accInfo, err, code := asUser.GetAccInfoWithToken(c)
	if err != nil {
		service.ErrorWithMark(c, code, err, "", "无效的登录状态")
		return
	}
	req.ApproverAccid = int32(accInfo.ID)
	req.Approver = accInfo.NickName

	//从缓存中拿去审批数据为后面添加路转记录做准备
	fmt.Printf("req.CacheArtistUid:%+v\n", req.CacheArtistUid)
	var tmpAuditData = &artistInfoArtwork.GetTempSaveReviewStatusListResp{}
	if req.CacheArtistUid != "" {
		fmt.Println("从缓存中获取审批数据111111111111111111")
		tmpAuditData, err = service.GrpcArtistInfoArtworkImpl.GetTempSaveReviewStatusList(c, &artistInfoArtwork.GetTempSaveReviewStatusListRequest{
			CacheArtistUid: req.CacheArtistUid,
		})
		fmt.Println("从缓存中获取审批数据22222", err)
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "ReviewBaseArtwork: GetTempSaveReviewStatusList Error", "审批失败，请稍后重试")
			return
		}
	}
	fmt.Println("3333333333333333333333")
	//进行审批
	fmt.Printf("tmpAuditData:%+v\n", tmpAuditData)
	resp, err := service.GrpcArtistInfoArtworkImpl.ReviewBaseArtworkAudit(c, &req)
	fmt.Printf("ReviewBaseArtworkAudit resp:%+v\n", resp)
	if err != nil {
		if utils.Contains([]string{"该画家画作已经审批完成，请勿重复提交", "请审批完后再提交", "未识别到您的审批操作，操作取消"}, err.Error()) {
			service.ErrorWithMark(c, e.Failed, err, "ReviewBaseArtwork: ReviewBaseArtwork Error", err.Error())
			return
		}
		service.ErrorWithMark(c, e.Failed, err, "ReviewBaseArtwork: ReviewBaseArtwork Error", "审批失败")
		return
	}

	fmt.Println("444444444444444444444")
	// 添加画作流转记录（如果审批通过）
	if req.ArtworkUid != "" {
		req.BatchAudit = append(req.BatchAudit, &artistInfoArtwork.BatchReviewAudit{
			ArtworkUid:   req.ArtworkUid,
			ReviewStatus: req.ReviewStatus,
			ReviewMark:   req.ReviewMark,
			ReviewMark2:  req.ReviewMark2,
		})
	}

	fmt.Println("555555555555555555")
	if tmpAuditData.List != nil && len(tmpAuditData.List) > 0 {
		for _, v := range tmpAuditData.List {
			fmt.Println("v.ArtworkUid:", v.ArtworkUid, "v.ReviewStatus:", v.ReviewStatus)
			req.BatchAudit = append(req.BatchAudit, &artistInfoArtwork.BatchReviewAudit{
				ArtworkUid:   v.ArtworkUid,
				ReviewStatus: artistInfoArtwork.ReviewAuditStatus(v.ReviewStatus),
				ReviewMark:   v.ReviewMark,
				ReviewMark2:  v.ReviewMark2,
			})
		}
	}
	fmt.Printf("准备添加流转记录：%+v\n", req.BatchAudit)
	for _, artAudit := range req.BatchAudit {
		if artAudit.ReviewStatus != artistInfoArtwork.ReviewAuditStatus_Pass {
			fmt.Println(artAudit.ArtworkUid+"没有通过，跳过流转记录添加 ，reviewStatus", artAudit.ReviewStatus)
			continue
		}
		fmt.Println(artAudit.ArtworkUid+"通过复审，添加流转记录 ，reviewStatus", artAudit.ReviewStatus)
		//查询画作锁定和审批状态
		artworkLock, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockDetail(context.Background(), &artistInfoArtwork.GetArtworkLockDetailRequest{ArtworkUid: artAudit.ArtworkUid})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "UpdateExtData: GrpcArtistInfoArtworkImpl.GetArtworkLockDetail Error", "审批失败")
			return
		}
		//if artworkLock.Status == 3 {
		//	service.Error(c, e.Failed, nil, "画作已解锁，不允许审批")
		//	return
		//}
		//生成流转记录请求数据
		flowRecord, auditType, auditResult := generateArtworkAuditFlowIndex(4, 2, artworkLock, time.Now().Unix())
		fmt.Printf("flowRecord:%+v\n", flowRecord)
		_, err = service.GrpcArtistInfoArtworkImpl.AddArtworkFlowRecord(context.Background(), flowRecord)
		if err != nil {
			fmt.Println("AuditSupplement AddArtworkFlowRecord Err：", err.Error())
		}
		//发送审批通知
		userData, err := service.GrpcArtistInfoUserImpl.FindUser(context.Background(), &artistInfoUser.FindUserRequest{MgmtArtistUid: artworkLock.ArtistUid})
		if err != nil {
			fmt.Println("AuditSupplement FindUser Err：", err.Error())
			continue
		}
		artworkView, err := service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(context.Background(), &artistInfoArtwork.ArtworkViewRequest{ArtworkUids: []string{artAudit.ArtworkUid}, PageSize: 1, Page: 1})
		if err != nil || artworkView.Total == 0 {
			fmt.Println("AuditSupplement GetArtworkViewList Err：", err.Error())
			continue
		}
		//if err = asUser.ArtistInfoPushNotice.ArtworkAuditResultNotice(userData.Id, artworkView.Datas[0].ArtworkName, auditType, auditResult); err != nil {
		//	fmt.Println("AuditSupplement ArtworkAuditResultNotice Err：", err.Error())
		//}
		pusher := asPush.NewPusher()
		if err = pusher.ArtworkAuditResultNotice(userData.Id, artworkView.Datas[0].ArtworkName, auditType, auditResult); err != nil {
			fmt.Println("AuditSupplement ArtworkAuditResultNotice Err：", err.Error())
		}
	}

	service.Success(c)
}

// GetSupplementDataListAtBackendSide 获取后台的画作补充信息列表
func (a artworkSupplement) GetSupplementDataListAtBackendSide2(c *gin.Context) {
	var req GetSupplementDataListAtBackendSideRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	//模糊查询画作名称
	var artworkUids []string
	if req.ArtworkName != "" {
		res, err := service.GrpcArtworkQueryImpl.ArtworkPreviewList(c, &artwork_query.ArtworkPreviewListRequest{ArtworkName: req.ArtworkName, ArtistUid: req.ArtistUid})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "GetArtworkPreviewListAtBackendSide: GrpcArtworkQueryImpl.ArtworkPreviewList Error", "画作服务查询失败")
		}
		for _, v := range res.Data {
			artworkUids = append(artworkUids, v.ArtworkUid)
		}
	}
	var lockRecords *artistInfoArtwork.GetArtworkViewListResponse
	var err error
	if req.History {
		lockRecords, err = service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(c, &artistInfoArtwork.ArtworkViewRequest{
			ArtistUid:             req.ArtistUid,
			QueryType:             artistInfoArtwork.ArtworkQueryMode_HistorySupplementInfo,
			ArtworkUids:           artworkUids,
			SupplementAuditStatus: int64(req.SupplementAuditStatus),
			Page:                  int64(req.Page),
			PageSize:              int64(req.PageSize),
		})
	} else {
		lockRecords, err = service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(c, &artistInfoArtwork.ArtworkViewRequest{
			ArtistUid:             req.ArtistUid,
			QueryType:             artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfSupplementing,
			ArtworkUids:           artworkUids,
			SupplementAuditStatus: int64(req.SupplementAuditStatus),
			Page:                  int64(req.Page),
			PageSize:              int64(req.PageSize),
		})
	}
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide : GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error", err.Error())
		return
	}
	//datas, err := ReplenishArtwork(datasPagination)
	//if err != nil {
	//	service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide :ReplenishArtwork Error", err.Error())
	//	return
	//}
	var returnDatas []ArtworkSupplementInfo
	for _, v := range lockRecords.Datas {
		//获取并处理一下字段数据
		var (
			editable           bool
			ArtistMarketDetail string
			ArtistMarketUrl1   string
			ArtistMarketUrl2   string
			ArtistMarketId1    int32
			ArtistMarketId2    int32
			ArtistMarketId3    int32
		)
		var lockStatus *artistInfoArtwork.CheckArtworkEditableResponse
		lockStatus, err = service.GrpcArtistInfoArtworkImpl.CheckArtworkSupplementInfoEditable(context.Background(), &artistInfoArtwork.ArtworkUidRequest{ArtworkUid: v.ArtworkUid})
		if err != nil {
			return
		}
		editable = lockStatus.Editable
		var artworkMarket *artwork.ArtworkDetailResponse
		artworkMarket, err := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{
			Type:        "2",
			ArtworkUuid: v.ArtworkUid,
		})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide : GrpcArtworkImpl.ArtworkDetail Error", err.Error())
			return
		}
		if config.Env == "test" || config.Env == "dev" {
			time.Sleep(time.Microsecond * 300)
		}
		if artworkMarket.MarketInfo != nil && len(artworkMarket.MarketInfo) > 0 {
			for _, v := range artworkMarket.MarketInfo {
				switch v.Type {
				case 0:
					ArtistMarketDetail = v.Detail
					ArtistMarketId1 = v.MarketId
				case 2:
					if ArtistMarketUrl1 == "" {
						ArtistMarketUrl1 = v.Detail
						ArtistMarketId2 = v.MarketId
					} else if ArtistMarketUrl2 == "" {
						ArtistMarketUrl2 = v.Detail
						ArtistMarketId3 = v.MarketId
						break
					}
				}
			}
		}
		returnDatas = append(returnDatas, ArtworkSupplementInfo{
			ArtworkUuid:           v.ArtworkUid,
			ArtistName:            v.ArtistName,
			ArtistUid:             v.ArtistUid,
			ArtworkName:           v.ArtworkName,
			Length:                v.Length,
			Width:                 v.Width,
			Ruler:                 v.Ruler,
			InscribeDate:          v.InscribeDate,
			Abstract:              v.SupplementAbstract,
			HdPic:                 v.HdPic,
			ArtistPhoto:           v.ArtistPhoto,
			CreatedDate:           v.CreatedDate,
			CreatedAddress:        strings.Join(v.CreatedAddress, ","),
			PriceRun:              float32(v.PriceRun),
			CreatedAt:             v.CreatedAt,
			UpdatedAt:             v.UpdatedAt,
			DeletedAt:             v.DeletedAt,
			FirstPublish:          v.FirstPublish,
			SupplementAuditStatus: v.SupplementAuditStatus,
			SupplementAuditMark:   v.SupplementAuditMark,
			SupplementAuditMark2:  v.SupplementAuditMark2,
			Editable:              editable,
			IsFirstPublish:        utils.If(v.FirstPublish == "", false, true).(bool),
			Status:                int64(v.LockStatus),
			ArtistMarketDetail:    ArtistMarketDetail,
			ArtistMarketUrl1:      ArtistMarketUrl1,
			ArtistMarketUrl2:      ArtistMarketUrl2,
			ArtistMarketId1:       ArtistMarketId1,
			ArtistMarketId2:       ArtistMarketId2,
			ArtistMarketId3:       ArtistMarketId3,
			Tfnum:                 v.Tfnum,
		})
	}
	service.ResponseList(c, returnDatas, service.OptionPage(req.Page, req.PageSize, lockRecords.Total), service.OptionMsg("查询成功"))
}

// GetSupplementDataListAtBackendSide3
// Deprecated
func (a artworkSupplement) GetSupplementDataListAtBackendSide3(c *gin.Context) {
	var req GetSupplementDataListAtBackendSideRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	//var order []string
	//if req.SortField != "" {
	//	var orderType = "asc"
	//	if req.SortOrder == "descend" {
	//		orderType = "desc"
	//	}
	//	order = append(order, fmt.Sprintf("%s %s", utils.CamelToSnake(req.SortField), orderType))
	//}
	//模糊查询画作名称
	var artworkUids []string
	if req.ArtworkName != "" {
		//res, err := service.GrpcArtworkQueryImpl.ArtworkPreviewList(c, &artwork_query.ArtworkPreviewListRequest{ArtworkName: req.ArtworkName, ArtistUid: req.ArtistUid, Order})
		res, err := service.GrpcArtworkQueryImpl.ArtworkPreviewList(c, &artwork_query.ArtworkPreviewListRequest{ArtworkName: req.ArtworkName, ArtistUid: req.ArtistUid})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "GetArtworkPreviewListAtBackendSide: GrpcArtworkQueryImpl.ArtworkPreviewList Error", "画作服务查询失败")
		}
		for _, v := range res.Data {
			artworkUids = append(artworkUids, v.ArtworkUid)
		}
	}
	//todo 下面开始改成获取画作补充信息视图列表
	var lockRecords *artistInfoArtwork.GetArtworkViewListResponse
	var err error
	if req.History {
		lockRecords, err = service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(c, &artistInfoArtwork.ArtworkViewRequest{
			ArtistUid:             req.ArtistUid,
			QueryType:             artistInfoArtwork.ArtworkQueryMode_HistorySupplementInfo,
			ArtworkUids:           artworkUids,
			SupplementAuditStatus: int64(req.SupplementAuditStatus),
			Page:                  int64(req.Page),
			PageSize:              int64(req.PageSize),
		})
	} else {
		lockRecords, err = service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(c, &artistInfoArtwork.ArtworkViewRequest{
			ArtistUid:             req.ArtistUid,
			QueryType:             artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfSupplementing,
			ArtworkUids:           artworkUids,
			SupplementAuditStatus: int64(req.SupplementAuditStatus),
			Page:                  int64(req.Page),
			PageSize:              int64(req.PageSize),
		})
	}
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetSupplementDataListAtUserSide : GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error", err.Error())
		return
	}
	var returnDatas []ArtworkSupplementInfo
	for _, v := range lockRecords.Datas {
		//获取并处理一下字段数据
		var (
			editable           bool
			ArtistMarketDetail string
			ArtistMarketUrl1   string
			ArtistMarketUrl2   string
			ArtistMarketId1    int32
			ArtistMarketId2    int32
			ArtistMarketId3    int32
		)
		var lockStatus *artistInfoArtwork.CheckArtworkEditableResponse
		lockStatus, err = service.GrpcArtistInfoArtworkImpl.CheckArtworkSupplementInfoEditable(context.Background(), &artistInfoArtwork.ArtworkUidRequest{ArtworkUid: v.ArtworkUid})
		if err != nil {
			return
		}
		editable = lockStatus.Editable

		supplyInfo, err := service.GrpcArtistInfoArtworkImpl.GetViewArtworkSupplementDetail(c, &artistInfoArtwork.GetViewArtworkSupplementByIdRequest{
			ArtworkUid: v.ArtworkUid,
		})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "assdf : GrpcArtistInfoArtworkImpl.GetViewArtworkSupplementDetail Error", err.Error())
			return
		}
		if len(supplyInfo.ArtworkMarkets) > 0 {
			tmpMarket := ConvertMarketDataToResponse(supplyInfo.ArtworkMarkets)
			ArtistMarketId1 = tmpMarket.ArtistMarketId1
			ArtistMarketId2 = tmpMarket.ArtistMarketId2
			ArtistMarketId3 = tmpMarket.ArtistMarketId3
			ArtistMarketDetail = tmpMarket.ArtistMarketDetail
			ArtistMarketUrl1 = tmpMarket.ArtistMarketUrl1
			ArtistMarketUrl2 = tmpMarket.ArtistMarketUrl2
		}
		returnDatas = append(returnDatas, ArtworkSupplementInfo{
			ArtworkUuid:           supplyInfo.ArtworkUuid,
			ArtistName:            supplyInfo.ArtistName,
			ArtistUid:             supplyInfo.ArtistUid,
			ArtworkName:           supplyInfo.ArtworkName,
			Length:                supplyInfo.Length,
			Width:                 supplyInfo.Width,
			Ruler:                 supplyInfo.Ruler,
			InscribeDate:          supplyInfo.InscribeDate,
			Abstract:              supplyInfo.Abstract,
			HdPic:                 supplyInfo.HdPic,
			ArtistPhoto:           supplyInfo.ArtistPhoto,
			CreatedDate:           supplyInfo.CreatedDate,
			CreatedAddress:        strings.Join(v.CreatedAddress, ","),
			PriceRun:              float32(v.PriceRun),
			CreatedAt:             supplyInfo.CreatedAt, //todo supplyInfo.CreatedAt 是字符串类型的数字
			UpdatedAt:             supplyInfo.UpdatedAt,
			DeletedAt:             time.Unix(supplyInfo.DeletedAt, 0).Format(stime.Format_Normal_YMDhms),
			FirstPublish:          supplyInfo.FirstPublish,
			SupplementAuditStatus: supplyInfo.SupplementAuditStatus,
			SupplementAuditMark:   supplyInfo.SupplementAuditMark,
			SupplementAuditMark2:  supplyInfo.SupplementAuditMark2,
			Editable:              editable,
			IsFirstPublish:        utils.If(v.FirstPublish == "", false, true).(bool),
			Status:                int64(v.LockStatus),
			ArtistMarketDetail:    ArtistMarketDetail,
			ArtistMarketUrl1:      ArtistMarketUrl1,
			ArtistMarketUrl2:      ArtistMarketUrl2,
			ArtistMarketId1:       ArtistMarketId1,
			ArtistMarketId2:       ArtistMarketId2,
			ArtistMarketId3:       ArtistMarketId3,
			Tfnum:                 v.Tfnum,
		})
	}
	service.ResponseList(c, returnDatas, service.OptionPage(req.Page, req.PageSize, lockRecords.Total), service.OptionMsg("查询成功"))
}

func generateArtworkAuditFlowIndex(auditStatus int64, flowIndex int64, artworkLockInfo *artistInfoArtwork.ArtworkLockInfo, timestamp int64) (record *artistInfoArtwork.AddArtworkFlowRecordRequest, auditType, auditResult string) {
	record = &artistInfoArtwork.AddArtworkFlowRecordRequest{
		ArtistUid:  artworkLockInfo.ArtistUid,
		ArtworkUid: artworkLockInfo.ArtworkUid,
		TimeStamp:  timestamp,
		Operator:   artistInfoArtwork.Operator_Backend,
	}
	if flowIndex < 3 { //基本信息审批
		auditType = "基本信息"
		switch auditStatus {
		case 4:
			auditResult = "通过"
			record.FlowState = artistInfoArtwork.FlowState_BaseInfoAuditPass
		case 3:
			auditResult = "不通过"
			record.FlowState = artistInfoArtwork.FlowState_BaseInfoAuditNoPass
		case 6:
			auditResult = "驳回"
			record.FlowState = artistInfoArtwork.FlowState_BaseInfoAuditReject
		}
	} else { //补充信息审批
		auditType = "补充信息"
		switch auditStatus {
		case 2:
			auditResult = "通过"
			record.FlowState = artistInfoArtwork.FlowState_ArtWorkSupplementPass
		case 3:
			auditResult = "不通过"
			record.FlowState = artistInfoArtwork.FlowState_ArtWorkSupplementNoPass
		}
	}
	return
}

func (a artworkSupplement) ExportArtworkReviewList(c *gin.Context) {
	var req ExportArtworkReviewListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var accId uint64
	claims, err := asUser.GetJwtInfo(c)
	if err == nil && claims != nil {
		accId = claims.ID
	}
	if req.ReviewUpdatedFrom == "" || req.ReviewUpdatedTo == "" {
		service.Error(c, e.InvalidParams, err, "请选择时间区间")
		return
	}
	resp, err := service.GrpcArtistInfoArtworkImpl.GetViewReviewArtworkList(c, &artistInfoArtwork.GetViewReviewArtworkListRequest{
		Page:          1,
		PageSize:      -1,
		SelectColumns: req.ColumnIds,
		//ArtworkUids:       req.ArtworkUids,
		ReviewUpdatedFrom: req.ReviewUpdatedFrom,
		ReviewUpdatedTo:   req.ReviewUpdatedTo,
	})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "ExportArtworkReviewList: GrpcArtistInfoUserImpl.GetBackendUserViewList", "查询失败")
		return
	}
	columnResp, err := service.GrpcArtistInfoUserImpl.GetExportFieldList(c, &artistInfoUser.GetExportFieldListRequest{
		Page:     1,
		PageSize: -1,
		Ids:      req.ColumnIds,
	})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "ExportArtworkReviewList: GetExportFieldList", "查询失败")
		return
	}
	var exportData []*ViewReviewArtworkExportData
	for _, v := range resp.List {
		temp := &ViewReviewArtworkExportData{
			ID:              v.ID,
			CreatedAt:       v.CreatedAt,
			DeletedAt:       v.DeletedAt,
			ReviewMark:      v.ReviewMark,
			ArtworkName:     v.ArtworkName,
			ArtworkUid:      v.ArtworkUid,
			Tfnum:           v.Tfnum,
			ArtistName:      v.ArtistName,
			ArtistUid:       v.ArtistUid,
			Tnum:            v.Tnum,
			Width:           v.Width,
			Length:          v.Length,
			Ruler:           v.Ruler,
			HdPic:           v.HdPic,
			ArtistPhoto:     v.ArtistPhoto,
			SealPic:         v.SealPic,
			LockStatus:      v.LockStatus,
			LockTime:        v.LockTime,
			ReviewMark2:     v.ReviewMark2,
			ReviewUpdatedAt: v.ReviewUpdatedAt,
		}
		if v.ReviewStatus != 0 {
			switch v.ReviewStatus {
			case 2:
				temp.ReviewStatus = "待审核"
			case 3:
				temp.ReviewStatus = "不通过"
			case 4:
				temp.ReviewStatus = "通过"
			default:
				temp.ReviewStatus = "无"
			}
		}
		if v.InSource != 0 {
			switch v.InSource {
			case 3:
				temp.InSource = "已导入"
			default:
				temp.InSource = "未导入"
			}
		}
		if v.ArtworkType != 0 {
			switch v.ArtworkType {
			case 1:
				temp.ArtworkType = "优秀画作"
			case 2:
				temp.ArtworkType = "赠画"
			case 3:
				temp.ArtworkType = "卷轴"
			case 4:
				temp.ArtworkType = "普通画作"
			default:
				temp.ArtworkType = "普通画作"
			}
		}

		if v.NationalExhibition != 0 {
			switch v.NationalExhibition {
			case 1:
				temp.NationalExhibition = "无"
			case 2:
				temp.NationalExhibition = "入围"
			case 3:
				temp.NationalExhibition = "入选"
			case 4:
				temp.NationalExhibition = "入围+入选"
			}
		}
		exportData = append(exportData, temp)
	}
	var headerTime = fmt.Sprintf("操作日期: %s-%s", strings.Replace(req.ReviewUpdatedFrom, "-", "/", -1), strings.Replace(req.ReviewUpdatedTo, "-", "/", -1))
	filePath, _, err := writeToExcel(headerTime, accId, exportData, columnResp.List)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "ExportBackendUserViewList: writeToExcel", "导出失败")
		return
	}
	defer func() {
		if filePath != "" {
			service.DelayDeleteFileTask.AddPendingDeleteFile(service.DelayDeleteFile{
				Path:          filePath,
				RetentionTime: time.Now().Add(2 * time.Minute),
			})
		}
	}()
	var httpType string
	if config.IsHttps {
		httpType = model.HttpsType
	} else {
		httpType = model.HttpType
	}
	var exportUrl = fmt.Sprintf("%s%s/static/tmp/%s", httpType, c.Request.Host, filepath.Base(filePath))
	service.Success(c, map[string]interface{}{"ExportUrl": exportUrl})
}

var exportExportArtworkReviewStaticLock = sync.RWMutex{}

func (a artworkSupplement) ExportArtworkReviewStatic(c *gin.Context) {
	if !exportExportArtworkReviewStaticLock.TryLock() {
		service.Error(c, e.InvalidParams, nil, "正在压缩文件，请勿重复操作!")
		return
	}
	defer exportExportArtworkReviewStaticLock.Unlock()
	var req ExportArtworkReviewListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var accId uint64
	claims, err := asUser.GetJwtInfo(c)
	if err == nil && claims != nil {
		accId = claims.ID
	}
	if req.ReviewUpdatedFrom == "" || req.ReviewUpdatedTo == "" {
		service.Error(c, e.InvalidParams, err, "请选择时间区间")
		return
	}
	//添加为文件命名时用的参数
	res, err := service.GrpcArtistInfoUserImpl.GetExportFieldList(c, &artistInfoUser.GetExportFieldListRequest{
		Query: &artistInfoUser.ExportFieldData{
			Origin: "view_review_artwork_detail",
		},
		Page:     1,
		PageSize: -1,
	})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "ExportArtworkReviewStatic：GetExportFieldList", "导出失败")
		return
	}
	for _, v := range res.List {
		if v.Column == "artist_name" || v.Column == "artwork_name" || v.Column == "tfnum" || v.Column == "tnum" {
			fmt.Println("找到了", v.Column)
			req.ColumnIds = append(req.ColumnIds, v.ID)
		}
	}
	fmt.Printf("req.ColumnIds:%+v\n", req.ColumnIds)
	resp, err := service.GrpcArtistInfoArtworkImpl.GetViewReviewArtworkList(c, &artistInfoArtwork.GetViewReviewArtworkListRequest{
		Page:              1,
		PageSize:          -1,
		SelectColumns:     req.ColumnIds,
		ReviewUpdatedFrom: req.ReviewUpdatedFrom,
		ReviewUpdatedTo:   req.ReviewUpdatedTo,
	})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "ExportArtworkReviewStatic: GetViewReviewArtworkList", "查询失败")
		return
	}
	if resp.Total > 0 {
		staticRootDir := path.Join("./runtime/tmp", fmt.Sprintf("复审画作静态资源_%d_%d", accId, time.Now().Unix()))
		if err = os.MkdirAll(staticRootDir, os.ModePerm); err != nil {
			service.ErrorWithMark(c, e.Failed, err, "文件生成失败，请稍后再试!")
			return
		}
		var (
			childDir_hdpic     = staticRootDir
			childDir_artistpic = staticRootDir
			childDir_sealpic   = staticRootDir
		)
		if len(req.ColumnIds) > 1 { //选择的图片类型数量大于1需要分目录
			childDir_hdpic = path.Join(staticRootDir, "画作高清图")
			childDir_artistpic = path.Join(staticRootDir, "画家画作合照")
			childDir_sealpic = path.Join(staticRootDir, "人名章图")

			if err = os.MkdirAll(childDir_hdpic, os.ModePerm); err != nil {
				service.ErrorWithMark(c, e.Failed, err, "文件生成失败，请稍后再试!")
				return
			}
			if err = os.MkdirAll(childDir_artistpic, os.ModePerm); err != nil {
				service.ErrorWithMark(c, e.Failed, err, "文件生成失败，请稍后再试!")
				return
			}
			if err = os.MkdirAll(childDir_sealpic, os.ModePerm); err != nil {
				service.ErrorWithMark(c, e.Failed, err, "文件生成失败，请稍后再试!")
				return
			}
		}

		var wg sync.WaitGroup
		var downloadTasks []*syncDownload.DownLoadInfo
		for _, v := range resp.List {
			//userStaticRoot := filepath.Join(staticRootDir, v.Tnum+"_"+v.RealName)
			userStaticRoot := staticRootDir
			if err = os.MkdirAll(userStaticRoot, os.ModePerm); err != nil {
				service.ErrorWithMark(c, e.Failed, err, "文件生成失败，请稍后再试!")
				return
			}
			fmt.Println("v.HdPic:", v.HdPic)
			fmt.Println("v.ArtistPhoto:", v.ArtistPhoto)
			fmt.Println("v.SealPic:", v.SealPic)
			if v.HdPic != "" {
				fileExt := filepath.Ext(v.HdPic)
				filePath := filepath.Join(childDir_hdpic, v.ArtistName+"["+v.Tnum+"]_"+v.ArtworkName+"["+v.Tfnum+"]"+fileExt)
				downloadTasks = append(downloadTasks, &syncDownload.DownLoadInfo{
					DownloadUrl: v.HdPic,
					SavePath:    filePath,
					Wg:          &wg,
				})
			}
			if v.ArtistPhoto != "" {
				fileExt := filepath.Ext(v.ArtistPhoto)
				filePath := filepath.Join(childDir_artistpic, v.ArtistName+"["+v.Tnum+"]_"+v.ArtworkName+"["+v.Tfnum+"]"+fileExt)
				downloadTasks = append(downloadTasks, &syncDownload.DownLoadInfo{
					DownloadUrl: v.ArtistPhoto,
					SavePath:    filePath,
					Wg:          &wg,
				})
			}
			if v.SealPic != "" {
				fileExt := filepath.Ext(v.SealPic)
				filePath := filepath.Join(childDir_sealpic, v.ArtistName+"["+v.Tnum+"]_"+v.ArtworkName+"["+v.Tfnum+"]"+fileExt)
				downloadTasks = append(downloadTasks, &syncDownload.DownLoadInfo{
					DownloadUrl: v.SealPic,
					SavePath:    filePath,
					Wg:          &wg,
				})
			}
		}
		wg.Add(len(downloadTasks))
		syncDownload.DownloadService.AddDownLoadTask(downloadTasks...)
		wg.Wait()
		zipPath := staticRootDir + ".zip"
		err = utils.ZipDirectory(staticRootDir, zipPath)
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "ExportBackendUserStatic:zipDirectory", "文件压缩失败")
			return
		}
		defer func() {
			if zipPath != "" || staticRootDir != "" {
				service.DelayDeleteFileTask.AddPendingDeleteFile(service.DelayDeleteFile{
					Path:          zipPath,
					RetentionTime: time.Now().Add(2 * time.Minute),
				}, service.DelayDeleteFile{
					Path:          staticRootDir,
					RetentionTime: time.Now().Add(2 * time.Minute),
				})
			}
		}()
		var httpType string
		if config.IsHttps {
			httpType = model.HttpsType
		} else {
			httpType = model.HttpType
		}
		var exportUrl = fmt.Sprintf("%s%s/static/tmp/%s", httpType, c.Request.Host, filepath.Base(zipPath))
		service.Success(c, map[string]interface{}{"ExportUrl": exportUrl})
	} else {
		service.Error(c, e.Failed, nil, "查询数据为空，无法下载")
	}
}

func writeToExcel(headerTime string, accId uint64, datas []*ViewReviewArtworkExportData, columns []*artistInfoUser.ExportFieldData) (path string, filename string, err error) {

	var (
		sheet1Columns []string
		jsonFiledList []string
	)
	for _, col := range columns {
		sheet1Columns = append(sheet1Columns, col.ColumnDesc)
		jsonFiledList = append(jsonFiledList, utils.SnakeToCamel(col.Column))
	}
	sheet1Data := excel.NewSheet("Sheet1", datas, sheet1Columns, jsonFiledList)
	var fileName = fmt.Sprintf("画作复审数据导出列表_%d.xlsx", accId)

	//path, filename, err = excel.WriteToExcel(fileName, "./runtime/tmp", "", sheet1Data)
	ex, _ := excel.NewExcelCreatorWithNewFile(fileName, "./runtime/tmp", sheet1Data)
	ex.UseOption(excel.OptionFileNameSuffixWithUnixTime)
	ex.AfterAddData(excel.AfterAddHeader1(sheet1Data, headerTime))
	path, filename, err = ex.WriteToFile()
	return
}

func (a artworkSupplement) TempSaveReviewStatus(c *gin.Context) {
	var req artistInfoArtwork.TempSaveReviewStatusData
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	if config.Env == "local" {
		req.Accid = 1
	} else {
		accInfo, err, code := asUser.GetAccInfoWithToken(c)
		if err != nil {
			service.Error(c, code, err, "登录状态失效")
			return
		}
		req.Accid = int32(accInfo.ID)
	}
	if _, err := service.GrpcArtistInfoArtworkImpl.SaveTempSaveReviewStatus(c, &req); err != nil {
		service.Error(c, e.Failed, err, "保存审批状态失败")
		return
	}
	service.Success(c)
}

func (a artworkSupplement) TempSaveReviewStatusList(c *gin.Context) {
	var req artistInfoArtwork.GetTempSaveReviewStatusListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, err.Error())
		return
	}
	if result, err := service.GrpcArtistInfoArtworkImpl.GetTempSaveReviewStatusList(c, &req); err != nil {
		service.Error(c, e.Failed, err, "查审批状态失败")
		return
	} else {
		service.ResponseList(c, result.List, service.OptionPage(result.Page, result.PageSize, result.Total))
	}
}

// 批量查询ViewReviewArtistStatic
func (a *artworkSupplement) GetViewReviewArtistStaticList(c *gin.Context) {
	var req GetViewReviewArtistStaticListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var protoReq artistInfoArtwork.GetViewReviewArtistStaticListRequest
	asUtil.RequestDataConvert(&req, &protoReq)
	switch req.Mode {
	case 1: //查询有待审核画作的画家
		protoReq.Where = "artwork_num_pending > 0"
	case 2: //查询有复审历史记录的画家
		protoReq.Query.HaveHistory = true
	}
	resp, err := service.GrpcArtistInfoArtworkImpl.GetViewReviewArtistStaticList(c, &protoReq)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetViewReviewArtistStaticList Err", "查询失败")
		return
	}
	//按徐家鸿要求修改，审核页面的画作数量和平尺数统计按照缓存中的审批数据实时展示
	if req.Mode == 1 {
		for i, thisArtist := range resp.List {
			//2. 统计各个复审状态下的画作数量
			//2.1 拿到当前待审核的画作数据
			artworkResp, err := service.GrpcArtistInfoArtworkImpl.GetViewReviewArtworkList(c, &artistInfoArtwork.GetViewReviewArtworkListRequest{
				Query:    &artistInfoArtwork.ViewReviewArtworkData{ReviewStatus: 2, ArtistUid: thisArtist.ArtistUid},
				Page:     1,
				PageSize: -1,
			})
			if err != nil {
				service.ErrorWithMark(c, e.Failed, err, "GetViewReviewArtworkList Err", "查询失败")
				return
			}
			//2.2 拿到缓存中的复审数据
			cacheData, err := service.GrpcArtistInfoArtworkImpl.GetTempSaveReviewStatusList(c, &artistInfoArtwork.GetTempSaveReviewStatusListRequest{
				CacheArtistUid: thisArtist.ArtistUid,
			})
			if err != nil {
				service.ErrorWithMark(c, e.Failed, err, "ReviewBaseArtworkList:GetArtworkBaseAuditHistoryList Err222", "查询失败")
				return
			}
			//2.4 缓存数据合并到artworkResp
			for cacheIndex, cache := range cacheData.List {
				for realIndex, _ := range artworkResp.List {
					if cache.ArtworkUid == artworkResp.List[realIndex].ArtworkUid {
						artworkResp.List[realIndex].ReviewStatus = artistInfoArtwork.ReviewAuditStatus(cacheData.List[cacheIndex].ReviewStatus)
						artworkResp.List[realIndex].ReviewMark = cacheData.List[cacheIndex].ReviewMark
						artworkResp.List[realIndex].ReviewMark2 = cacheData.List[cacheIndex].ReviewMark2
						artworkResp.List[realIndex].ReviewUpdatedAt = cacheData.List[cacheIndex].OptTime
						break
					}
				}
			}
			//2.5 重新统计当前审批列表中的信息
			resp.List[i].RulerTotal = 0
			resp.List[i].RulerTotalPassed = 0
			resp.List[i].RulerTotalNoPassed = 0
			resp.List[i].RulerTotalPending = 0
			resp.List[i].ArtworkNumAll = 0
			resp.List[i].ArtworkNumNoPassed = 0
			resp.List[i].ArtworkNumPassed = 0
			resp.List[i].ArtworkNumPending = 0
			for _, v := range artworkResp.List {
				resp.List[i].RulerTotal += v.Ruler
				resp.List[i].ArtworkNumAll++
				switch v.ReviewStatus {
				case artistInfoArtwork.ReviewAuditStatus_Pass:
					resp.List[i].RulerTotalPassed += v.Ruler
					resp.List[i].ArtworkNumPassed++
				case artistInfoArtwork.ReviewAuditStatus_Failed:
					resp.List[i].RulerTotalNoPassed += v.Ruler
					resp.List[i].ArtworkNumNoPassed++
				case artistInfoArtwork.ReviewAuditStatus_Pending:
					resp.List[i].RulerTotalPending += v.Ruler
					resp.List[i].ArtworkNumPending++
				}
			}
		}
	} else if req.Mode == 2 { //复审历史记录页面
		for i, thisArtist := range resp.List {
			//2. 统计各个复审状态下的画作数量
			//2.1 拿到当前待审核的画作数据
			history, err := service.GrpcArtistInfoArtworkImpl.GetArtworkBaseAuditHistoryList(c, &artistInfoArtwork.GetArtworkBaseAuditHistoryListRequest{
				Query: &artistInfoArtwork.ArtworkBaseAuditHistoryData{
					ArtistUid: thisArtist.ArtistUid,
					Node:      2,
				},
				Page:     1,
				PageSize: -1,
			})
			if err != nil {
				service.ErrorWithMark(c, e.Failed, err, "GetViewReviewArtistStaticList:GetArtworkBaseAuditHistoryList Err", "查询失败")
				return
			}
			var artworkUids []string
			for _, v := range history.List {
				artworkUids = append(artworkUids, "'"+v.ArtworkUid+"'")
			}
			var req2 = &artistInfoArtwork.GetViewReviewArtworkListRequest{Page: 1, PageSize: -1}
			req2.Where = fmt.Sprintf("artwork_uid in (%s)", strings.Join(artworkUids, ","))
			artworkResp, err := service.GrpcArtistInfoArtworkImpl.GetViewReviewArtworkList(c, req2)
			if err != nil {
				service.ErrorWithMark(c, e.Failed, err, "GetViewReviewArtistStaticList:GetViewReviewArtworkList Err", "查询失败")
				return
			}
			//2.5 统计当前审批的画作数量
			resp.List[i].RulerTotal = 0
			resp.List[i].RulerTotalPassed = 0
			resp.List[i].RulerTotalNoPassed = 0
			resp.List[i].RulerTotalPending = 0
			resp.List[i].ArtworkNumAll = 0
			resp.List[i].ArtworkNumNoPassed = 0
			resp.List[i].ArtworkNumPassed = 0
			resp.List[i].ArtworkNumPending = 0
			for _, v := range artworkResp.List {
				resp.List[i].RulerTotal += v.Ruler
				resp.List[i].ArtworkNumAll++
				switch v.ReviewStatus {
				case artistInfoArtwork.ReviewAuditStatus_Pass:
					resp.List[i].RulerTotalPassed += v.Ruler
					resp.List[i].ArtworkNumPassed++
				case artistInfoArtwork.ReviewAuditStatus_Failed:
					resp.List[i].RulerTotalNoPassed += v.Ruler
					resp.List[i].ArtworkNumNoPassed++
				case artistInfoArtwork.ReviewAuditStatus_Pending:
					resp.List[i].RulerTotalPending += v.Ruler
					resp.List[i].ArtworkNumPending++
				}
			}
		}
	}
	service.ResponseList(c, resp.List,
		service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"),
		service.OptionAddField_ArtshowCount("artistUid"))
}

// 批量查询ArtworkBaseAuditHistory
func (a *artworkSupplement) GetArtworkBaseAuditHistoryList(c *gin.Context) {
	var req GetArtworkBaseAuditHistoryListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var protoReq artistInfoArtwork.GetArtworkBaseAuditHistoryListRequest
	asUtil.RequestDataConvert(&req, &protoReq)
	protoReq.Where = "(node=1 AND audit_status=7) OR node=2"
	resp, err := service.GrpcArtistInfoArtworkImpl.GetArtworkBaseAuditHistoryList(c, &protoReq)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetArtworkBaseAuditHistoryList Err", "查询失败")
		return
	}
	service.ResponseList(c, resp.List,
		service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"),
		service.OptionAddField_ArtshowCount("artistUid"),
	)
}

// 批量查询ViewArtworkSupplementDetail
func (a *artworkSupplement) GetViewArtworkSupplementDetailList(c *gin.Context) {
	var req GetViewArtworkSupplementDetailListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}

	var protoReq = artistInfoArtwork.GetViewArtworkSupplementDetailListRequest{Query: &artistInfoArtwork.ViewArtworkSupplementDetailData{}}
	asUtil.RequestDataConvert(&req, &protoReq)
	if req.SupplementAuditStatus != 0 {
		protoReq.Query.SupplementAuditStatus = req.SupplementAuditStatus
	}
	// 配置排序
	var order []string
	if req.SortField != "" {
		var orderType = "asc"
		if req.SortOrder == "descend" {
			orderType = "desc"
		}
		order = append(order, fmt.Sprintf("%s %s", utils.CamelToSnake(req.SortField), orderType))
		protoReq.Order = strings.Join(order, ",")
	}
	switch req.History {
	case 1:
		protoReq.Query.LockStatus = 2
	case 2:
		protoReq.Query.LockStatus = 3
	}
	resp, err := service.GrpcArtistInfoArtworkImpl.GetViewArtworkSupplementDetailList(c, &protoReq)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetViewArtworkSupplementDetailList Err", "查询失败")
		return
	}
	service.ResponseList(c, resp.List,
		service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"),
		service.OptionAddField_ArtshowCount("artistUid"),
	)
}

// 批量查询ReviewAuditMessage
func (a *artworkSupplement) GetReviewAuditMessageList(c *gin.Context) {
	var req GetReviewAuditMessageListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var protoReq = artistInfoArtwork.GetReviewAuditMessageListRequest{Query: &artistInfoArtwork.ReviewAuditMessageData{}}
	asUtil.RequestDataConvert(&req, &protoReq)
	protoReq.Query.History = &artistInfoArtwork.ArtworkBaseAuditHistoryData{
		ArtworkName: req.ArtworkName,
		ArtistName:  req.ArtistName,
		ArtistUid:   req.ArtistUid,
		ArtworkUid:  req.ArtworkUid,
		Tnum:        req.Tnum,
		Tfnum:       req.Tfnum,
	}
	resp, err := service.GrpcArtistInfoArtworkImpl.GetReviewAuditMessageList(c, &protoReq)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetReviewAuditMessageList Err", "查询失败")
		return
	}
	if resp != nil && resp.Total > 0 {
		//查询画家的画展次数
		var artistUidList []string
		for _, v := range resp.List {
			if v.History != nil && v.History.ArtistUid != "" {
				artistUidList = append(artistUidList, v.History.ArtistUid)
			}
		}
		countList, _ := service.GrpcArtShowImpl.ArtistExhibitionCount(context.Background(), &artShow.ArtistExhibitionCountReq{ArtistUid: artistUidList})
		//增加artistShowCount字段
		jsonBytes, _ := json.Marshal(resp.List)
		var mapList []map[string]any
		json.Unmarshal(jsonBytes, &mapList)
		fmt.Println("mapList len: ", len(mapList))
		fmt.Println("resp.list len: ", len(resp.List))
		for i, v := range mapList {
			if v["history"] != nil {
				artistUid := v["history"].(map[string]any)["artistUid"].(string)
				found := false
				for _, countInfo := range countList.ArtistShowCount {
					if countInfo.ArtistUid == artistUid {
						found = true
						mapList[i]["history"].(map[string]any)["artistShowCount"] = fmt.Sprintf("%s(%d)",
							mapList[i]["history"].(map[string]any)["artistName"], countInfo.ShowCount)
						break
					}
				}
				if !found {
					mapList[i]["history"].(map[string]any)["artistShowCount"] = fmt.Sprintf("%s(0)",
						mapList[i]["history"].(map[string]any)["artistName"])
				}
			}
		}
		service.ResponseList(c, mapList, service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"))
	} else {
		service.ResponseList(c, resp.List, service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"))
	}

}

func (a *artworkSupplement) GetReviewAuditMessageStatic(c *gin.Context) {
	//var req GetReviewAuditMessageListRequest
	//if err := c.ShouldBindJSON(&req); err != nil {
	//	service.Error(c, e.InvalidParams, err, "无效参数")
	//	return
	//}
	//var protoReq = artistInfoArtwork.GetReviewAuditMessageListRequest{Query: &artistInfoArtwork.ReviewAuditMessageData{}}
	//asUtil.RequestDataConvert(&req, &protoReq)
	resp, err := service.GrpcArtistInfoArtworkImpl.GetReviewAuditMessageStatic(c, &artistInfoArtwork.GetReviewAuditMessageStaticRequest{})
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GetReviewAuditMessageList Err", "查询失败")
		return
	}
	if resp == nil {
		resp = &artistInfoArtwork.GetReviewAuditMessageStaticResp{}
	}
	service.Success(c, resp)
}

// 更新ReviewAuditMessage
func (a *artworkSupplement) UpdateReviewAuditMessage(c *gin.Context) {
	var req artistInfoArtwork.ReviewAuditMessageData
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	_, err := service.GrpcArtistInfoArtworkImpl.UpdateReviewAuditMessage(c, &req)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "GrpcArtistInfoArtworkImpl.UpdateReviewAuditMessage Err", "更新失败")
		return
	}
	service.Success(c)
}

// 删除ReviewAuditMessage
func (a *artworkSupplement) DeleteReviewAuditMessage(c *gin.Context) {
	var req artistInfoArtwork.DeleteReviewAuditMessageRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	_, err := service.GrpcArtistInfoArtworkImpl.DeleteReviewAuditMessage(c, &req)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "DeleteReviewAuditMessage Err", "删除失败")
		return
	}
	service.Success(c)
}