package service

import (
	"context"
	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"errors"
	"fmt"
	_ "github.com/Workiva/go-datastructures/threadsafe/err"
	service "github.com/fonchain_enterprise/fonchain-main/api"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/approval"
	artShow "github.com/fonchain_enterprise/fonchain-main/api/artShow"
	"github.com/fonchain_enterprise/fonchain-main/api/artist"
	"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/api/artwork_third_party"
	"github.com/fonchain_enterprise/fonchain-main/api/position"
	"github.com/fonchain_enterprise/fonchain-main/api/rule"
	"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/model/login"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils/secret"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils/stime"
	"github.com/gin-gonic/gin"
	"github.com/jinzhu/copier"
	"go.uber.org/zap"
	"sort"
	"strings"
	"sync"
	"time"
)

func CreateShow(c *gin.Context) {
	var saveShowReq artShow.SaveShowReq
	if err := c.ShouldBind(&saveShowReq); err != nil {
		logger.Errorf("CreateShow ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	saveShowRes, err := GrpcArtShowImpl.CreateShow(context.Background(), &saveShowReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	out := serializer.BuildSyncArtShowUID(&saveShowReq, saveShowRes.ShowUID, nil)
	if len(out.Data) > 0 {
		syncArtShowIDRes, err := GrpcArtworkQueryImpl.SyncArtShowId(context.Background(), &out)
		if err != nil {
			logger.Errorf("SyncArtShowId Response err", err)
			ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    syncArtShowIDRes.Msg,
				Status: e.Failed,
			})
			return
		}
	}

	// 更新 推荐人信息
	if saveShowRes.ShowUID != "" {
		bindAndGetArtPackageRequest := new(artistinfoArtshow.BindAndGetArtPackageRequest)
		bindAndGetArtPackageRequest.ArtPackageUid = saveShowRes.ShowUID
		bindAndGetArtPackageRequest.ArtistUid = saveShowReq.ArtistUID
		bindAndGetArtPackageResponse, err := GrpcArtistInfoArtshowImpl.BindAndGetArtPackageAndBrokerSupplement(context.Background(), bindAndGetArtPackageRequest)
		if err != nil {
			goto end
		}
		if bindAndGetArtPackageResponse.Data.Name != "" {
			artShowAgent := new(artShow.ArtShowAgent)
			artShowAgent.Agent = bindAndGetArtPackageResponse.Data.Name
			artShowAgent.ShowUID = saveShowRes.ShowUID
			updateArtShowAgentReq := new(artShow.UpdateArtShowAgentReq)
			updateArtShowAgentReq.Data = make([]*artShow.ArtShowAgent, 0)
			updateArtShowAgentReq.Data = append(updateArtShowAgentReq.Data, artShowAgent)
			_, err := GrpcArtShowImpl.UpdateArtShowAgent(context.Background(), updateArtShowAgentReq)
			if err != nil {
				goto end
			}

		}
	}
end:
	// 发起核验有单独的接口 updated by jjxu 2024-03-01
	////画家核验状态更新为待发起
	//_, err = GrpcArtistImpl.OneQueryAudit(c, &artist.OneQueryAuditReq{ArtistUid: saveShowReq.ArtistUID, CheckStatus: 1})
	//if err != nil {
	//	logger.Errorf("CreateShow--GrpcArtistImpl.OneQueryAudit Err%v", err)
	//}

	//返回成功
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    saveShowRes.Msg,
		Status: e.Ok,
	})
}

func UpdateShow(c *gin.Context) {
	var saveShowReq artShow.SaveShowReq
	if err := c.ShouldBind(&saveShowReq); err != nil {
		logger.Errorf("UpdateShow ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	approvalReq := new(approval.ArtShowApprovalListReq)
	approvalReq.ShowUid = saveShowReq.ShowUID
	result, err := ApprovalProvider.ListApprovalByShowUID(context.Background(), approvalReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    "查询画展包审批状态失败",
			Status: e.Failed,
		})
		return
	}
	fmt.Println("=====================================画展包审批")
	fmt.Println(result)

	//if len(result.Data) > 0 {

	//	ResponseMsg(c, e.SUCCESS, serializer.Response{
	//		Msg:    "该画展包状态不可修改",
	//		Status: e.Failed,
	//	})
	//	return
	//}
	zap.L().Info("===================================================updateShowUid" + saveShowReq.ShowUID)
	saveShowRes, err := GrpcArtShowImpl.UpdateShow(context.Background(), &saveShowReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	out := serializer.BuildSyncArtShowUID(&saveShowReq, saveShowRes.ShowUID, nil)
	if len(out.Data) > 0 {
		syncArtShowIDRes, err := GrpcArtworkQueryImpl.SyncArtShowId(context.Background(), &out)
		if err != nil {
			logger.Errorf("SyncArtShowId Response err", err)
			ResponseMsg(c, e.InvalidParams, serializer.Response{
				Msg:    syncArtShowIDRes.Msg,
				Status: e.Failed,
			})
			return
		}
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    saveShowRes.Msg,
		Status: e.Ok,
	})
}

func DelShow(c *gin.Context) {
	var delShowReq artShow.DelShowReq
	if err := c.ShouldBind(&delShowReq); err != nil {
		logger.Errorf("DelShow ShouldBind err", err)
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	commonRes, err := GrpcArtShowImpl.DelShow(context.Background(), &delShowReq)
	if err != nil {
		logger.Errorf("DelShow err", err)
		fmt.Println("DelShow Response err ==== ", err)
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if len(delShowReq.ShowUID) > 0 {
		showUidS := make([]string, 0)
		for i := 0; i < len(delShowReq.ShowUID); i++ {
			showDetailRes, err := GrpcArtShowImpl.ShowDetail(context.Background(), &artShow.ShowDetailReq{ShowUID: []string{delShowReq.ShowUID[i]}})
			if err != nil {
				ResponseMsg(c, e.SUCCESS, serializer.Response{
					Msg:    err.Error(),
					Status: e.Failed,
				})
				return
			}
			if len(showDetailRes.Data) > 0 {
				showUidS = append(showUidS, delShowReq.ShowUID[i])
			}
		}
		out := serializer.BuildSyncArtShowUID(nil, "", showUidS)
		if len(out.ArtShowUuids) > 0 {
			syncArtShowIDRes, err := GrpcArtworkQueryImpl.SyncArtShowId(context.Background(), &out)
			if err != nil {
				fmt.Println("SyncArtShowId Response err ==== ", err)
				logger.Errorf("SyncArtShowId Response err ==== ", err)
				ResponseMsg(c, e.SUCCESS, serializer.Response{
					Msg:    syncArtShowIDRes.Msg,
					Status: e.Failed,
				})
				return
			}
		}

	}

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    commonRes.Msg,
		Status: e.Ok,
	})
}

func ShowList(c *gin.Context) {
	var showListReq artShow.ShowListReq
	if err := c.ShouldBind(&showListReq); err != nil {
		logger.Errorf("ShowList ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	showListRes, err := GrpcArtShowImpl.ShowList(context.Background(), &showListReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showListRes.Msg,
		Data:   showListRes,
		Status: e.Ok,
	})
}

func ShowListWithRel(c *gin.Context) {
	var showListReq artShow.ShowListReq
	if err := c.ShouldBind(&showListReq); err != nil {
		logger.Errorf("ShowList ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	// 获取 当前用户是否有限期
	isShow := hasExhibitionAuthV2(c, 0)
	fmt.Println("isShow ===== ", isShow)
	if len(isShow) < 1 {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    e.GetMsg(e.ErrorAuthInsufficientAuthority),
			Status: e.Failed,
		})
		return
	}

	/*
		    1、传入 showListReq is_show == nil  以权限为准
			2、传入 showListReq is_show != nil  , is_show in 权限   取 is_show  ;  is_show over 权限   报错
	*/
	if len(showListReq.IsShow) < 1 {
		showListReq.IsShow = make([]int32, 0)
		for i := 0; i < len(isShow); i++ {
			showListReq.IsShow = append(showListReq.IsShow, int32(isShow[i]))
			fmt.Println("is_show ====== ", isShow[i])
		}
	} else {
		isExist := false
		for i := 0; i < len(showListReq.IsShow); i++ {
			fmt.Println("showListReq.IsShow ====== ", showListReq.IsShow[i])
			for j := 0; j < len(isShow); j++ {
				if showListReq.IsShow[i] == int32(isShow[j]) {
					isExist = true
					break
				} else {
					isExist = false
				}
			}
		}
		if isExist == false {
			ResponseMsg(c, e.SUCCESS, serializer.Response{
				Data:   nil,
				Msg:    e.GetMsg(e.ErrorAuthInsufficientAuthority),
				Status: e.Failed,
			})
			return
		}
	}

	if showListReq.StartShowTime != "" && showListReq.EndShowTime != "" && (showListReq.StartShowTime == showListReq.EndShowTime) {
		showListReq.StartShowTime = showListReq.StartShowTime + " 00:00:00"
		showListReq.EndShowTime = showListReq.EndShowTime + " 23:59:59"
	}

	canShow := hasCanShowAuth(c)
	if canShow != 0 {
		showListReq.CanShow = canShow
	}

	showListRes, err := GrpcArtShowImpl.ShowListWithRel(context.Background(), &showListReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	//推荐人不要了
	// 查询 推荐人信息  展示并 更新到 画展包
	//updateArtShowAgentReq := new(artShow.UpdateArtShowAgentReq)
	//updateArtShowAgentReq.Data = make([]*artShow.ArtShowAgent, 0)
	//for i := 0; i < len(showListRes.Data); i++ {
	//	if showListRes.Data[i].Agent == "" {
	//		bindAndGetArtPackageRequest := new(artistinfoArtshow.BindAndGetArtPackageRequest)
	//		bindAndGetArtPackageRequest.ArtPackageUid = showListRes.Data[i].ShowUID
	//		bindAndGetArtPackageRequest.ArtistUid = showListRes.Data[i].ArtistUID
	//		fmt.Printf("request BindAndGetArtPackageAndBrokerSupplement info is : %+v\n", bindAndGetArtPackageRequest)
	//		bindAndGetArtPackageResponse, err := GrpcArtistInfoArtshowImpl.BindAndGetArtPackageAndBrokerSupplement(context.Background(), bindAndGetArtPackageRequest)
	//		if err != nil {
	//			continue
	//		}
	//		if bindAndGetArtPackageResponse.Data.Name != "" {
	//			fmt.Println("agent 获取 ========================================= 开始")
	//			fmt.Println("agent is : ", bindAndGetArtPackageResponse.Data.Name)
	//			fmt.Println("agent 获取 ========================================= 结束")
	//			artShowAgent := new(artShow.ArtShowAgent)
	//			artShowAgent.Agent = bindAndGetArtPackageResponse.Data.Name
	//			artShowAgent.ShowUID = showListRes.Data[i].ShowUID
	//			updateArtShowAgentReq.Data = append(updateArtShowAgentReq.Data, artShowAgent)
	//			// 保存到展示的列表中
	//			showListRes.Data[i].Agent = bindAndGetArtPackageResponse.Data.Name
	//		}
	//	}
	//}
	//
	//if len(updateArtShowAgentReq.Data) > 0 {
	//	commonRes, err := GrpcArtShowImpl.UpdateArtShowAgent(context.Background(), updateArtShowAgentReq)
	//	if err != nil {
	//		logger.Errorf("UpdateArtShowAgent Response err", err)
	//		ResponseMsg(c, e.SUCCESS, serializer.Response{
	//			Msg:    commonRes.Msg,
	//			Status: e.Failed,
	//		})
	//		return
	//	}
	//}
	//
	//newShowListRes := new(artShow.ShowListRes)
	//newShowListRes.Msg = showListRes.Msg
	//newShowListRes.Data = make([]*artShow.ShowDetail, 0)
	//
	//// 排序 (查看画展包详情中，将已存在经纪人信息但尚未存在底价数据的画展包置顶)
	////fmt.Println("is_detail :", showListReq.IsDetail)
	//if showListReq.IsDetail == "1" {
	//	hasAgentShowList := make([]*artShow.ShowDetail, 0)
	//	notHasAgentShowList := make([]*artShow.ShowDetail, 0)
	//	for i := 0; i < len(showListRes.Data); i++ {
	//		if showListRes.Data[i].Price == 0 && showListRes.Data[i].Agent != "" {
	//			fmt.Println("添加 排序 ==== 开始 ===")
	//			fmt.Printf("showDetail : %+v", showListRes.Data[i])
	//			fmt.Println("添加 排序 ==== 结束 ===")
	//			hasAgentShowList = append(hasAgentShowList, showListRes.Data[i])
	//		} else {
	//			notHasAgentShowList = append(notHasAgentShowList, showListRes.Data[i])
	//		}
	//	}
	//	newShowListRes.Data = append(newShowListRes.Data, hasAgentShowList...)
	//	newShowListRes.Data = append(newShowListRes.Data, notHasAgentShowList...)
	//} else {
	//	newShowListRes.Data = showListRes.Data
	//}
	//
	//newShowListRes.Total = showListRes.Total
	//newShowListRes.TotalPackageNum = showListRes.TotalPackageNum
	//newShowListRes.TotalArtistNum = showListRes.TotalArtistNum

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showListRes.Msg,
		Data:   showListRes,
		Status: e.Ok,
	})
}

func ShowListApply(c *gin.Context) {
	var showListReq artShow.ShowListReq
	if err := c.ShouldBind(&showListReq); err != nil {
		logger.Errorf("ShowList ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	fmt.Println("==============当前用户是否有限期==================")
	// 获取 当前用户是否有限期
	isShow := hasExhibitionAuthV2(c, 0)
	fmt.Println("isShow ===== ", isShow)
	if len(isShow) < 1 {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    e.GetMsg(e.ErrorAuthInsufficientAuthority),
			Status: e.Failed,
		})
		return
	}
	if len(showListReq.IsShow) < 1 {
		showListReq.IsShow = make([]int32, 0)
		for i := 0; i < len(isShow); i++ {
			showListReq.IsShow = append(showListReq.IsShow, int32(isShow[i]))
			fmt.Println("is_show ====== ", isShow[i])
		}
	} else {
		isExist := false
		for i := 0; i < len(showListReq.IsShow); i++ {
			fmt.Println("showListReq.IsShow ====== ", showListReq.IsShow[i])
			for j := 0; j < len(isShow); j++ {
				if showListReq.IsShow[i] == int32(isShow[j]) {
					isExist = true
					break
				} else {
					isExist = false
				}
			}
		}
		if isExist == false {
			ResponseMsg(c, e.SUCCESS, serializer.Response{
				Data:   nil,
				Msg:    e.GetMsg(e.ErrorAuthInsufficientAuthority),
				Status: e.Failed,
			})
			return
		}
	}

	//推荐人不要了
	//// 查询 推荐人信息  展示并 更新到 画展包
	//updateArtShowAgentReq := new(artShow.UpdateArtShowAgentReq)
	//updateArtShowAgentReq.Data = make([]*artShow.ArtShowAgent, 0)
	//for i := 0; i < len(showListRes.Data); i++ {
	//	if showListRes.Data[i].Agent == "" {
	//		bindAndGetArtPackageRequest := new(artistinfoArtshow.BindAndGetArtPackageRequest)
	//		bindAndGetArtPackageRequest.ArtPackageUid = showListRes.Data[i].ShowUID
	//		bindAndGetArtPackageRequest.ArtistUid = showListRes.Data[i].ArtistUID
	//		fmt.Printf("request BindAndGetArtPackageAndBrokerSupplement info is : %+v\n", bindAndGetArtPackageRequest)
	//		bindAndGetArtPackageResponse, err := GrpcArtistInfoArtshowImpl.BindAndGetArtPackageAndBrokerSupplement(context.Background(), bindAndGetArtPackageRequest)
	//		if err != nil {
	//			continue
	//		}
	//		if bindAndGetArtPackageResponse.Data.Name != "" {
	//			fmt.Println("agent 获取 ========================================= 开始")
	//			fmt.Println("agent is : ", bindAndGetArtPackageResponse.Data.Name)
	//			fmt.Println("agent 获取 ========================================= 结束")
	//			artShowAgent := new(artShow.ArtShowAgent)
	//			artShowAgent.Agent = bindAndGetArtPackageResponse.Data.Name
	//			artShowAgent.ShowUID = showListRes.Data[i].ShowUID
	//			updateArtShowAgentReq.Data = append(updateArtShowAgentReq.Data, artShowAgent)
	//			// 保存到展示的列表中
	//			showListRes.Data[i].Agent = bindAndGetArtPackageResponse.Data.Name
	//		}
	//	}
	//}
	//
	//if len(updateArtShowAgentReq.Data) > 0 {
	//	commonRes, err := GrpcArtShowImpl.UpdateArtShowAgent(context.Background(), updateArtShowAgentReq)
	//	if err != nil {
	//		logger.Errorf("UpdateArtShowAgent Response err", err)
	//		ResponseMsg(c, e.SUCCESS, serializer.Response{
	//			Msg:    commonRes.Msg,
	//			Status: e.Failed,
	//		})
	//		return
	//	}
	//}

	//过滤审批中的画展包
	applyListReq := new(approval.ListRequest)
	applyListReq.Status = 1
	if showListReq.IsShow[0] == 2 {
		applyListReq.Type = "exhibition"
	} else if showListReq.IsShow[0] == 3 {
		applyListReq.Type = "artExhibitionReward"
	} else if showListReq.IsShow[0] == 4 {
		applyListReq.Type = "bundlePayPrice"
	}
	applyListReq.Domain = "all"
	//查询正在审批中的画展包list
	fmt.Println("==============查询正在审批中的画展包list==================")
	fmt.Println(applyListReq)
	applyShowList, err := ApprovalProvider.ApprovalList(context.Background(), applyListReq)
	if err != nil {
		logger.Error("查询审批中的画展包  ApprovalList err", err.Error())
		return
	}
	fmt.Println("==============applyShowList==================")
	fmt.Println(applyShowList)
	applyListReq.Status = 2
	applyShowList1, err1 := ApprovalProvider.ApprovalList(context.Background(), applyListReq)
	if err1 != nil {
		logger.Error("查询审批通过的画展包  applyShowList1 err", err1.Error())
		return
	}
	fmt.Println("==============applyShowList1==================")
	fmt.Println(applyShowList1)
	applyListReq.Status = 6
	applyShowList2, err2 := ApprovalProvider.ApprovalList(context.Background(), applyListReq)
	if err2 != nil {
		logger.Error("查询撤销中画展包  applyShowList1 err", err2.Error())
		return
	}
	fmt.Println("==============applyShowList2==================")
	fmt.Println(applyShowList2)
	if len(applyShowList1.Data) > 0 {
		applyShowList.Data = append(applyShowList.Data, applyShowList1.Data...)
	}
	if len(applyShowList2.Data) > 0 {
		applyShowList.Data = append(applyShowList.Data, applyShowList2.Data...)
	}

	showIds := make([]string, 0)
	if len(applyShowList.Data) > 0 {

		for _, item := range applyShowList.Data {
			if applyListReq.Type == "bundlePayPrice" {
				if item.BundlePayPrice != nil {
					showIds = append(showIds, item.BundlePayPrice.ShowUid)
				}
			} else {
				if item.Exhibition != nil {
					for _, exhibition := range item.Exhibition.ApprovalExhibitions {
						if exhibition.ArtExhibitionDetail != nil {
							showIds = append(showIds, exhibition.ArtExhibitionDetail.ShowUID)
						}
					}
				}
			}

		}

		//通过showUid过滤
		//filterList := make([]*artShow.ShowDetail, 0)
		//for _, newShow := range showListRes.Data {
		//	isFilter := false
		//	for _, id := range showIds {
		//		if newShow.ShowUID == id {
		//			isFilter = true
		//			break
		//		}
		//	}
		//	if !isFilter {
		//		filterList = append(filterList, newShow)
		//	}
		//}
		//showListRes.Data = filterList
	}
	fmt.Println("==============查询画展包列表==================")
	showListReq.ShowUid = showIds
	showListRes, err := GrpcArtShowImpl.ShowListApply(context.Background(), &showListReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	fmt.Println(showListRes)
	showListRes.Total = int64(len(showListRes.Data))

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showListRes.Msg,
		Data:   showListRes,
		Status: e.Ok,
	})
}

type ShowListRespData struct {
	*artShow.ShowDetail
	InviteStatus int    `json:"InviteStatus"` //邀请函状态  1=待发送 2=待回复 3=已同意 4=已拒绝 5=不可发起
	LetterUid    string `json:"LetterUid"`    //邀请函uid
}

func ShowListWithRelLately(c *gin.Context) {
	var showListReq artShow.ShowListReq
	if err := c.ShouldBind(&showListReq); err != nil {
		logger.Errorf("ShowList ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	// 获取 当前用户是否有限期
	isShow := hasExhibitionAuthV2(c, 0)
	fmt.Println("isShow ===== ", isShow)
	if len(isShow) < 1 {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    e.GetMsg(e.ErrorAuthInsufficientAuthority),
			Status: e.Failed,
		})
		return
	}

	/*
		    1、传入 showListReq is_show == nil  以权限为准
			2、传入 showListReq is_show != nil  , is_show in 权限   取 is_show  ;  is_show over 权限   报错
	*/
	if len(showListReq.IsShow) < 1 {
		showListReq.IsShow = make([]int32, 0)
		for i := 0; i < len(isShow); i++ {
			showListReq.IsShow = append(showListReq.IsShow, int32(isShow[i]))
			fmt.Println("is_show ====== ", isShow[i])
		}
	} else {
		isExist := false
		for i := 0; i < len(showListReq.IsShow); i++ {
			fmt.Println("showListReq.IsShow ====== ", showListReq.IsShow[i])
			for j := 0; j < len(isShow); j++ {
				if showListReq.IsShow[i] == int32(isShow[j]) {
					isExist = true
					break
				} else {
					isExist = false
				}
			}
		}
		if isExist == false {
			ResponseMsg(c, e.SUCCESS, serializer.Response{
				Data:   nil,
				Msg:    e.GetMsg(e.ErrorAuthInsufficientAuthority),
				Status: e.Failed,
			})
			return
		}
	}

	showListRes, err := GrpcArtShowImpl.ShowListWithRelLately(context.Background(), &showListReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	// 查询 推荐人信息  展示并 更新到 画展包
	updateArtShowAgentReq := new(artShow.UpdateArtShowAgentReq)
	updateArtShowAgentReq.Data = make([]*artShow.ArtShowAgent, 0)
	for i := 0; i < len(showListRes.Data); i++ {
		if showListRes.Data[i].Agent == "" {
			bindAndGetArtPackageRequest := new(artistinfoArtshow.BindAndGetArtPackageRequest)
			bindAndGetArtPackageRequest.ArtPackageUid = showListRes.Data[i].ShowUID
			bindAndGetArtPackageRequest.ArtistUid = showListRes.Data[i].ArtistUID
			fmt.Printf("request BindAndGetArtPackageAndBrokerSupplement info is : %+v\n", bindAndGetArtPackageRequest)
			bindAndGetArtPackageResponse, err := GrpcArtistInfoArtshowImpl.BindAndGetArtPackageAndBrokerSupplement(context.Background(), bindAndGetArtPackageRequest)
			if err != nil {
				continue
			}
			if bindAndGetArtPackageResponse.Data.Name != "" {
				fmt.Println("agent 获取 ========================================= 开始")
				fmt.Println("agent is : ", bindAndGetArtPackageResponse.Data.Name)
				fmt.Println("agent 获取 ========================================= 结束")
				artShowAgent := new(artShow.ArtShowAgent)
				artShowAgent.Agent = bindAndGetArtPackageResponse.Data.Name
				artShowAgent.ShowUID = showListRes.Data[i].ShowUID
				updateArtShowAgentReq.Data = append(updateArtShowAgentReq.Data, artShowAgent)
				// 保存到展示的列表中
				showListRes.Data[i].Agent = bindAndGetArtPackageResponse.Data.Name
			}
		}
	}

	if len(updateArtShowAgentReq.Data) > 0 {
		commonRes, err := GrpcArtShowImpl.UpdateArtShowAgent(context.Background(), updateArtShowAgentReq)
		if err != nil {
			logger.Errorf("UpdateArtShowAgent Response err", err)
			ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    commonRes.Msg,
				Status: e.Failed,
			})
			return
		}
	}

	newShowListRes := struct {
		artShow.ShowListRes
		Data []*ShowListRespData
	}{}
	newShowListRes.Msg = showListRes.Msg
	newShowListRes.Data = make([]*ShowListRespData, 0)

	// 排序 (查看画展包详情中，将已存在经纪人信息但尚未存在底价数据的画展包置顶)
	//fmt.Println("is_detail :", showListReq.IsDetail)
	if showListReq.IsDetail == "1" {
		hasAgentShowList := make([]*ShowListRespData, 0)
		notHasAgentShowList := make([]*ShowListRespData, 0)
		for i := 0; i < len(showListRes.Data); i++ {
			if showListRes.Data[i].Price == 0 && showListRes.Data[i].Agent != "" {
				fmt.Println("添加 排序 ==== 开始 ===")
				fmt.Printf("showDetail : %+v", showListRes.Data[i])
				fmt.Println("添加 排序 ==== 结束 ===")
				hasAgentShowList = append(hasAgentShowList, &ShowListRespData{ShowDetail: showListRes.Data[i]})
			} else {
				notHasAgentShowList = append(notHasAgentShowList, &ShowListRespData{ShowDetail: showListRes.Data[i]})
			}
		}
		newShowListRes.Data = append(newShowListRes.Data, hasAgentShowList...)
		newShowListRes.Data = append(newShowListRes.Data, notHasAgentShowList...)
	} else {
		for i, _ := range showListRes.Data {
			newShowListRes.Data = append(newShowListRes.Data, &ShowListRespData{ShowDetail: showListRes.Data[i]})
		}
	}

	newShowListRes.Total = showListRes.Total
	newShowListRes.TotalPackageNum = showListRes.TotalPackageNum
	newShowListRes.TotalArtistNum = showListRes.TotalArtistNum
	newShowListRes.CurrentShowTime = showListRes.CurrentShowTime
	newShowListRes.EndShowTime = showListRes.EndShowTime
	newShowListRes.StartShowTime = showListRes.StartShowTime

	//检查是否已发送邀请函
	if len(newShowListRes.Data) > 0 {
		var where = "show_uid in ("
		for i, v := range newShowListRes.Data {
			where += "'" + v.ShowUID + "'"
			if i < len(newShowListRes.Data)-1 {
				where += ","
			}
		}
		where += ")"
		if config.Env == "test" || config.Env == "dev" {
			time.Sleep(time.Millisecond * 200)
		}
		letterRes, err := GrpcArtistImpl.GetInvitationLetterList(c, &artist.GetInvitationLetterListRequest{Page: 1, PageSize: -1, Where: where})
		if err != nil {
			ErrorWithMark(c, e.Failed, err, "GetArtistOneQueryCheckRecordList Err")
			return
		}
		currentTime := stime.Currentime(stime.Format_Normal_YMDhm)
		fmt.Println("currentTime", currentTime)
		//查询当前数据中所有画家的邀请函
		var allArtistUids []string
		for _, t := range newShowListRes.Data {
			allArtistUids = append(allArtistUids, t.ArtistUID)
		}
		if config.Env == "test" || config.Env == "dev" {
			time.Sleep(time.Millisecond * 200)
		}
		allArtistLetters, errs := GrpcArtistImpl.GetInvitationLetterList(context.Background(), &artist.GetInvitationLetterListRequest{Page: 1, PageSize: -1, Where: "artist_uuid in ('" + strings.Join(allArtistUids, "','") + "')"})
		if errs != nil {
			ErrorWithMark(c, e.Failed, errs, "获取画家所有数据失败 GetInvitationLetterList Err")
			return
		}
		for i, v1 := range newShowListRes.Data {
			newShowListRes.Data[i].InviteStatus = 1
			foundLetter := false
			for _, v2 := range letterRes.List {
				v2 := v2
				if v1.ShowUID == v2.ShowUid {
					foundLetter = true
					newShowListRes.Data[i].LetterUid = v2.Uuid
					switch {
					case v2.IsCome == 0:
						newShowListRes.Data[i].InviteStatus = 2
					case v2.IsCome == 1:
						if v2.IsPreload == 1 {
							//预发起邀请函时，画家如果同意前往，则状态为填写信息
							newShowListRes.Data[i].InviteStatus = 6
						} else {
							newShowListRes.Data[i].InviteStatus = 3 //已同意
						}
					case v2.IsCome == 2:
						newShowListRes.Data[i].InviteStatus = 4
					}
					break
				}
			}
			fmt.Println("foundLetter", foundLetter)
			if !foundLetter {
				//newShowListRes.Data[i].InviteStatus = 5
				//查询已发起邀请函的画展包的画展时间是否超过当前时间,超过则可发起邀请函否则不可发起
				if config.Env == "test" || config.Env == "dev" {
					time.Sleep(time.Millisecond * 200)
				} else {
					time.Sleep(time.Millisecond * 50)
				}
				//改为从所有刚才数据中筛选当前画家的
				//artistLetters, errs := GrpcArtistImpl.GetInvitationLetterList(context.Background(), &artist.GetInvitationLetterListRequest{Page: 1, PageSize: -1, Query: &artist.InvitationLetterData{ArtistUuid: v1.ArtistUID}})
				//if errs != nil {
				//	ErrorWithMark(c, e.Failed, errs, "GetInvitationLetterList Err")
				//	return
				//}
				//if artistLetters.Total == 0 {
				//	continue
				//}
				//var showUids []string
				//for _, v := range artistLetters.List {
				//	showUids = append(showUids, v.ShowUid)
				//}
				var artistLetters []*artist.InvitationLetterData
				for _, v := range allArtistLetters.List {
					if v.ArtistUuid == v1.ArtistUID {
						v := v
						artistLetters = append(artistLetters, v)
					}
				}
				if len(artistLetters) == 0 {
					continue
				}
				var showUids []string
				for _, v := range artistLetters {
					showUids = append(showUids, v.ShowUid)
				}
				if config.Env == "test" || config.Env == "dev" {
					time.Sleep(time.Millisecond * 200)
				} else {
					time.Sleep(time.Millisecond * 50)
				}
				showTimeList, errs := GrpcArtShowImpl.GetShowTimeWithShowUid(context.Background(), &artShow.GetShowTimeWithShowUidReq{ShowUids: showUids})
				if errs != nil {
					ErrorWithMark(c, e.Failed, errs, "GetShowTimeWithShowUid Err")
					return
				}
				for _, v := range showTimeList.Data {
					if v.ShowTime != "" {
						if v.ShowTime > currentTime {
							fmt.Println("画展时间未超过当前时间")
							newShowListRes.Data[i].InviteStatus = 5
							break
						}
					} else if v.PreTime != "" {
						if v.PreTime > currentTime {
							fmt.Println("预计画展时间未超过当前时间")
							newShowListRes.Data[i].InviteStatus = 5
							break
						}
					}
				}
			}
		}
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    newShowListRes.Msg,
		Data:   newShowListRes,
		Status: e.Ok,
	})
}

func ShowArtworkInfo(c *gin.Context) {
	var artworkDetailReq artShow.ArtworkDetailReq
	if err := c.ShouldBind(&artworkDetailReq); err != nil {
		logger.Errorf("ShowInfo ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	showArtworkDetailRes, err := GrpcArtShowImpl.ShowArtworkInfo(context.Background(), &artworkDetailReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	artworkUids := make([]string, 0)
	for i := 0; i < len(showArtworkDetailRes.Data); i++ {
		if showArtworkDetailRes.Data[i].SmallPic == "" {
			artworkUids = append(artworkUids, showArtworkDetailRes.Data[i].ArtworkUID)
		}
	}

	if len(artworkUids) > 0 {
		artworkPreviewListResp, err := GrpcArtworkQueryImpl.ArtworkPreviewList(context.Background(), &artwork_query.ArtworkPreviewListRequest{
			ArtworkUids: artworkUids,
		})

		if err != nil {
			ResponseMsg(c, e.InvalidParams, serializer.Response{
				Msg:    err.Error(),
				Status: e.Failed,
			})
			return
		}

		for i := 0; i < len(showArtworkDetailRes.Data); i++ {
			if showArtworkDetailRes.Data[i].SmallPic != "" { // 如果 画展包里面的 smallPic 不为 ""  则 跳过
				continue
			}
			for j := 0; j < len(artworkPreviewListResp.Data); j++ {
				if showArtworkDetailRes.Data[i].ArtworkUID == artworkPreviewListResp.Data[j].ArtworkUid {
					if artworkPreviewListResp.Data[j].DigiArtImg != "" {
						showArtworkDetailRes.Data[i].SmallPic = artworkPreviewListResp.Data[j].DigiArtImg
						continue
					}

					if artworkPreviewListResp.Data[j].HdPic != "" {
						showArtworkDetailRes.Data[i].SmallPic = artworkPreviewListResp.Data[j].HdPic
						continue
					}

					if artworkPreviewListResp.Data[j].PhotoPic != "" {
						showArtworkDetailRes.Data[i].SmallPic = artworkPreviewListResp.Data[j].PhotoPic
						continue
					}
				}
			}
		}

	}

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showArtworkDetailRes.Msg,
		Data:   showArtworkDetailRes,
		Status: e.Ok,
	})
}

func ShowDetail(c *gin.Context) {
	var showDetailReq artShow.ShowDetailReq
	if err := c.ShouldBind(&showDetailReq); err != nil {
		logger.Errorf("ShowInfo ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	showDetailRes, err := GrpcArtShowImpl.ShowDetail(context.Background(), &showDetailReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showDetailRes.Msg,
		Data:   showDetailRes,
		Status: e.Ok,
	})
}

func ShowStatisticalInfo(c *gin.Context) {
	var showStatisticalInfoReq artShow.ShowStatisticalInfoReq
	if err := c.ShouldBind(&showStatisticalInfoReq); err != nil {
		logger.Errorf("ShowStatisticalInfo ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	showStatisticalInfoRes, err := GrpcArtShowImpl.ShowStatisticalInfo(context.Background(), &showStatisticalInfoReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showStatisticalInfoRes.Msg,
		Data:   showStatisticalInfoRes,
		Status: e.Ok,
	})
}

func ArtworkPrice(c *gin.Context) {
	var artworkPriceReq artShow.ArtworkPriceReq
	if err := c.ShouldBind(&artworkPriceReq); err != nil {
		logger.Errorf("ArtworkPrice ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	artworkPriceRes, err := GrpcArtShowImpl.ArtworkPrice(context.Background(), &artworkPriceReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    artworkPriceRes.Msg,
		Data:   artworkPriceRes,
		Status: e.Ok,
	})
}

func CreateApply(c *gin.Context) {
	var saveApplyReq artShow.SaveApplyReq
	if err := c.ShouldBind(&saveApplyReq); err != nil {
		logger.Errorf("CreateApply ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	saveApplyRes, err := GrpcArtShowImpl.CreateApply(context.Background(), &saveApplyReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    saveApplyRes.Msg,
		Status: e.Ok,
	})
}

func UpdateApply(c *gin.Context) {
	var saveApplyReq artShow.SaveApplyReq
	if err := c.ShouldBind(&saveApplyReq); err != nil {
		logger.Errorf("UpdateApply ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	saveApplyRes, err := GrpcArtShowImpl.UpdateApply(context.Background(), &saveApplyReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    saveApplyRes.Msg,
		Status: e.Ok,
	})
}

func DelApply(c *gin.Context) {
	var delApplyReq artShow.DelApplyReq
	if err := c.ShouldBind(&delApplyReq); err != nil {
		logger.Errorf("DelApply ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	commonRes, err := GrpcArtShowImpl.DelApply(context.Background(), &delApplyReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    commonRes.Msg,
		Status: e.Ok,
	})
}

func ShowListWithApply(c *gin.Context) {
	var showListReq artShow.ShowListReq
	if err := c.ShouldBind(&showListReq); err != nil {
		logger.Errorf("ShowListWithApply ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	showListRes, err := GrpcArtShowImpl.ShowListWithApply(context.Background(), &showListReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showListRes.Msg,
		Data:   showListRes,
		Status: e.Ok,
	})
}

func UpdateApplyStatus(c *gin.Context) {
	var updateApplyStatusReq artShow.UpdateApplyStatusReq
	if err := c.ShouldBind(&updateApplyStatusReq); err != nil {
		logger.Errorf("UpdateApplyStatus ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	commonRes, err := GrpcArtShowImpl.UpdateApplyStatus(context.Background(), &updateApplyStatusReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    commonRes.Msg,
		Status: e.Ok,
	})
}

func ApplyList(c *gin.Context) {
	var applyListReq artShow.ApplyListReq
	if err := c.ShouldBind(&applyListReq); err != nil {
		logger.Errorf("ApplyList ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	applyListRes, err := GrpcArtShowImpl.ApplyList(context.Background(), &applyListReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    applyListRes.Msg,
		Data:   applyListRes,
		Status: e.Ok,
	})
}

func ApplyRelInfoDetail(c *gin.Context) {
	var applyShowReq artShow.ApplyShowReq
	if err := c.ShouldBind(&applyShowReq); err != nil {
		logger.Errorf("ApplyRelInfoDetail ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	applyShowRes, err := GrpcArtShowImpl.ApplyDetail(context.Background(), &applyShowReq)
	//fmt.Println(applyShowRes.Show)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    applyShowRes.Msg,
		Data:   applyShowRes.Show,
		Status: e.Ok,
	})
}

func ShowListForArtwork(c *gin.Context) {
	var showListForArtworkReq artShow.ShowListForArtworkReq
	if err := c.ShouldBind(&showListForArtworkReq); err != nil {
		logger.Errorf("ShowListForArtwork ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	showListForArtworkRes, err := GrpcArtShowImpl.ShowListForArtwork(context.Background(), &showListForArtworkReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showListForArtworkRes.Msg,
		Data:   showListForArtworkRes,
		Status: e.Ok,
	})
}

func CancelShow(c *gin.Context) {
	var cancelShowReq artShow.CancelShowReq
	if err := c.ShouldBind(&cancelShowReq); err != nil {
		logger.Errorf("CancelShow ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	queryArtShowStatusReq := new(artwork_third_party.ArtShowStatusReq)
	queryArtShowStatusReq.ArtShowIds = append(queryArtShowStatusReq.ArtShowIds, cancelShowReq.ShowUID...)

	res, err := GrpcArtworkThirdPartyImpl.GetArtShowStatus(context.Background(), queryArtShowStatusReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if len(res.Data) < 0 {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    "查询画作系统画展包状态错误",
			Status: e.Failed,
		})
		return
	}
	for _, showStatus := range res.Data {
		if showStatus.StorageStatus > model.StorageStatusAuth {
			ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    "无法删除已出库画展包",
				Status: e.Failed,
			})
			return
		}
	}

	commonRes, err := GrpcArtShowImpl.CancelShow(context.Background(), &cancelShowReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    commonRes.Msg,
		Status: e.Ok,
	})
}

func QuerySaleAddress(c *gin.Context) {
	var saleAddressRes artShow.SaleAddressReq
	if err := c.ShouldBind(&saleAddressRes); err != nil {
		logger.Errorf("CancelShow ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := GrpcArtShowImpl.QuerySaleAddress(c, &saleAddressRes)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    res.Msg,
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res.Address,
		Status: e.Ok,
	})
}

// HasExhibitionAuthV2 获取画展宝权限(departmentId不指定可以传0) 内部1  画展2,3
func hasExhibitionAuthV2(c *gin.Context, departmentId uint64) []uint8 {

	var authCodes []uint8
	userInfo := login.GetUserInfoFromC(c)

	//内部
	req := position.DoIHavaAuthRequest{
		UserId:       userInfo.ID,
		Url:          e.ExhibitionInsideKey,
		DepartmentID: departmentId,
	}

	res, err := PositionProvider.DoIHavaAuth(c, &req)

	if err == nil && res.Hava == true {
		authCodes = append(authCodes, 1)
	}

	req = position.DoIHavaAuthRequest{
		UserId:       userInfo.ID,
		Url:          e.ExhibitionShowKey,
		DepartmentID: departmentId,
	}

	res, err = PositionProvider.DoIHavaAuth(c, &req)

	if err == nil && res.Hava == true {
		authCodes = append(authCodes, 2)
		authCodes = append(authCodes, 3)
		authCodes = append(authCodes, 4)
	}

	fmt.Println(authCodes)
	return authCodes

}

// HasExhibitionAuth 获取画展宝权限(departmentId不指定可以传0) 内部1  画展2,3
func hasExhibitionAuth(c *gin.Context, departmentId uint64) []uint8 {

	var authCodes []uint8
	userInfo := login.GetUserInfoFromC(c)

	if departmentId == 0 {
		departmentId = userInfo.PositionUsers[0].DepartmentId
	}

	fmt.Println(userInfo)
	//内部
	req := position.DoIHavaAuthRequest{
		UserId:       userInfo.ID,
		Url:          e.ExhibitionInsideKey,
		DepartmentID: departmentId,
	}

	res, err := PositionProvider.DoIHavaAuth(c, &req)

	if err == nil && res.Hava == true {
		authCodes = append(authCodes, 1)
	}

	req = position.DoIHavaAuthRequest{
		UserId:       userInfo.ID,
		Url:          e.ExhibitionShowKey,
		DepartmentID: departmentId,
	}

	res, err = PositionProvider.DoIHavaAuth(c, &req)

	if err == nil && res.Hava == true {
		authCodes = append(authCodes, 2)
		authCodes = append(authCodes, 3)
		authCodes = append(authCodes, 4)
	}

	fmt.Println(authCodes)
	return authCodes

}

func QueryShowDate(c *gin.Context) {
	var showListReq artShow.ShowListReq
	if err := c.ShouldBind(&showListReq); err != nil {
		logger.Errorf("ShowList ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	// 获取 当前用户是否有限期
	isShow := hasExhibitionAuthV2(c, 0)
	fmt.Println("isShow ===== ", isShow)
	if len(isShow) < 1 {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    e.GetMsg(e.ErrorAuthInsufficientAuthority),
			Status: e.Failed,
		})
		return
	}

	/*
		    1、传入 showListReq is_show == nil  以权限为准
			2、传入 showListReq is_show != nil  , is_show in 权限   取 is_show  ;  is_show over 权限   报错
	*/
	if len(showListReq.IsShow) < 1 {
		showListReq.IsShow = make([]int32, 0)
		for i := 0; i < len(isShow); i++ {
			showListReq.IsShow = append(showListReq.IsShow, int32(isShow[i]))
			fmt.Println("is_show ====== ", isShow[i])
		}
	} else {
		isExist := false
		for i := 0; i < len(showListReq.IsShow); i++ {
			fmt.Println("showListReq.IsShow ====== ", showListReq.IsShow[i])
			for j := 0; j < len(isShow); j++ {
				if showListReq.IsShow[i] == int32(isShow[j]) {
					isExist = true
					break
				} else {
					isExist = false
				}
			}
		}
		if isExist == false {
			ResponseMsg(c, e.SUCCESS, serializer.Response{
				Data:   nil,
				Msg:    e.GetMsg(e.ErrorAuthInsufficientAuthority),
				Status: e.Failed,
			})
			return
		}
	}

	showListRes, err := GrpcArtShowImpl.ShowListWithRel(context.Background(), &showListReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	dateMap := make(map[string]string, 0)

	if len(showListRes.Data) > 0 {
		for i := 0; i < len(showListRes.Data); i++ {
			if showListRes.Data[i].ShowTime != "" {
				date := strings.Split(showListRes.Data[i].ShowTime, " ")
				if len(date) == 1 {
					date = strings.Split(showListRes.Data[i].ShowTime, "T")
				}
				dateMap[date[len(date)-len(date)]] = date[len(date)-len(date)]
			} else if showListRes.Data[i].ShowTime == "" && showListRes.Data[i].PreTime != "" {
				date := strings.Split(showListRes.Data[i].PreTime, " ")
				dateMap[date[len(date)-len(date)]] = date[len(date)-len(date)]
			}
		}
	}

	dates := make([]string, 0)
	if len(dateMap) > 0 {
		for _, v := range dateMap {
			dates = append(dates, v)
		}
	}

	sort.Strings(dates)

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    showListRes.Msg,
		Data:   dates,
		Status: e.Ok,
	})

}

func ShowListNoPriceNum(c *gin.Context) {
	req := artShow.ShowStatisticalInfoReq{IsShow: 2}
	res, err := GrpcArtShowImpl.ShowStatisticalInfo(context.Background(), &req)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res.Data.NoPriceNum,
		Status: e.Ok,
	})
}

func ShowTimeList(c *gin.Context) {
	timesReq := new(artShow.TimesReq)
	if err := c.ShouldBind(&timesReq); err != nil {
		logger.Errorf("ShowTimeList err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Ok,
		})
		return
	}
	res, err := GrpcArtShowImpl.ShowTimeList(context.Background(), timesReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
}

func AllTimeList(c *gin.Context) {
	timesReq := new(artShow.TimesReq)
	if err := c.ShouldBind(&timesReq); err != nil {
		logger.Errorf("AllTimeList err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	res, err := GrpcArtShowImpl.AllTimeList(context.Background(), timesReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Ok,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
}

func FindEntertainment(c *gin.Context) {
	timesReq := new(artShow.TimesReq)
	if err := c.ShouldBind(&timesReq); err != nil {
		logger.Errorf("FindEntertainment err", err)

		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := GrpcArtShowImpl.FindEntertainment(context.Background(), timesReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Ok,
		})
		return
	}

	if len(res.Data) == 0 {
		goto ret
	} else {
		artistMap := make(map[string]string)
		artistDataReq := new(artist.ArtistDataRequest)
		artistDataReq.Uids = make([]string, 0)
		for i := 0; i < len(res.Data); i++ {
			artistDataReq.Uids = append(artistDataReq.Uids, res.Data[i].ArtistUID)
		}

		artistDataRes, err := GrpcArtistImpl.ArtistData(context.Background(), artistDataReq)
		if err != nil {
			ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    e.ErrorQueryArtistData,
				Status: e.Ok,
			})
			return
		}

		for i := 0; i < len(artistDataRes.Data); i++ {
			artistMap[artistDataRes.Data[i].ProfileInfo.Uid] = artistDataRes.Data[i].ProfileInfo.Phone
		}

		for i := 0; i < len(res.Data); i++ {
			res.Data[i].TelNum = artistMap[res.Data[i].ArtistUID]
		}
	}

ret:
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
}

func SaveEntertainment(c *gin.Context) {
	timesReq := new(artShow.ArtistEntertainment)
	if err := c.ShouldBind(&timesReq); err != nil {
		logger.Errorf("SaveEntertainment err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	//获取操作人的名字
	if timesReq.UpdatedBy == "" {
		accInfo, err, _ := GetAccInfoWithToken(c)
		if err != nil {
			timesReq.UpdatedBy = "backend"
		} else {
			timesReq.UpdatedBy = utils.If(accInfo.NickName == "", "backend", accInfo.NickName).(string)
		}
	}
	fmt.Println("timesReq.UpdatedBy", timesReq.UpdatedBy)
	if timesReq.TravelWay == 1 {
		timesReq.Transportation = ""
	}
	res, err := GrpcArtShowImpl.UpdateEntertainment(context.Background(), timesReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Ok,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
}

func FindNoPriceShow(c *gin.Context) {
	req := new(artShow.CommonReq)
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("FindNoPriceShow err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if req.Page == 0 {
		req.Page = 1
	}
	if req.PageSize == 0 {
		req.PageSize = 20
	}

	res, err := GrpcArtShowImpl.QueryNoPriceShow(context.Background(), req)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	for _, resItem := range res.Data {
		if resItem.Price == 0 {
			detail, err := GrpcArtistInfoArtshowImpl.GetArtshowArtistRulerFloorPriceDetail(context.Background(), &artistinfoArtshow.GetArtshowArtistRulerFloorPriceByIdRequest{
				ArtistUid: resItem.ArtistUID,
			})
			if err != nil {
				ResponseMsg(c, e.SUCCESS, serializer.Response{
					Msg:    "获取(" + resItem.ArtistName + ")画家平尺单价失败",
					Status: e.Failed,
				})
				return
			}
			if detail.FloorPrice != 0 {
				resItem.Price = int64(float32(resItem.Ruler) * detail.FloorPrice)
				resItem.IsCalPrice = 1
			}
		}
	}

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
}

func UpdateShowPrice(c *gin.Context) {
	req := new(artShow.UpdateShowPriceReq)
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("SaveEntertainment err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := GrpcArtShowImpl.UpdateShowPrice(context.Background(), req)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
}

func UpdateArtShowHost(c *gin.Context) {
	req := new(artShow.UpdateArtShowHostReq)
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("UpdateArtShowHost err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	_, err := GrpcArtShowImpl.UpdateArtShowHost(context.Background(), req)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Ok,
		})
		return
	}

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    e.GetMsg(e.SUCCESS),
		Status: e.Ok,
	})
}

func OnQueryShowList(c *gin.Context) {
	oneQueryShowListReq := new(artShow.OneQueryShowListReq)
	if err := c.ShouldBind(&oneQueryShowListReq); err != nil {
		logger.Errorf("oneQueryShowListReq ShouldBind err", err)
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if oneQueryShowListReq.Permission == "auth_search_warehouse" || oneQueryShowListReq.Permission == "auth_search_training" || oneQueryShowListReq.Permission == "auth_search_publicize" {
		oneQueryShowListReq.IsShow = append(oneQueryShowListReq.IsShow, []int32{e.ARTSHOW_SALE_ADDRESS_PASS, e.ARTSHOW_REWARD_PASS}...)
	} else {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    e.ErrorNotAllow,
			Status: e.Failed,
		})
		return
	}

	userInfo := login.GetUserInfoFromC(c)

	ruleReq := new(rule.RulesRequest)
	ruleReq.AccountID = userInfo.ID
	ruleResp, err := RuleProvider.Rules(context.Background(), ruleReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrorQueryRules,
			Status: e.Failed,
		})
		return
	}
	authMap := make(map[string]string, 0)
	for i := 0; i < len(ruleResp.MyButtonAuths); i++ {
		authMap[ruleResp.MyButtonAuths[i].Url] = ruleResp.MyButtonAuths[i].Url
	}

	if authMap["r_onesearch_artshow_nolimit"] == "r_onesearch_artshow_nolimit" {
		oneQueryShowListReq.Permission = ""
	} else {
		oneQueryShowListReq.Permission = "r_onesearch_artshow_nolimit"
	}

	showListRes, err := GrpcArtShowImpl.OneQueryShowList(context.Background(), oneQueryShowListReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   showListRes,
		Status: e.Ok,
	})
}

func FindEntertainmentGroupField(c *gin.Context) {
	req := new(artShow.CommonReq)
	res, err := GrpcArtShowImpl.FindEntertainmentFieldGroup(context.Background(), req)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
}

func ArtworkPriceWholeInfo(c *gin.Context) {
	var artworkPriceWholeInfoReq model.ArtworkPriceWholeInfoReq
	if err := c.ShouldBind(&artworkPriceWholeInfoReq); err != nil {
		logger.Errorf("ArtworkPriceWholeInfo ShouldBind err", err)
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	var artworkPriceWholeInfoResp model.ArtworkPriceWholeInfoResp
	var artworkPriceReq artShow.ArtworkPriceReq
	artworkPriceReq.Tfnum = artworkPriceWholeInfoReq.Tfnum

	artworkPriceRes, err := GrpcArtShowImpl.ArtworkPriceWholeInfo(context.Background(), &artworkPriceReq)
	if err != nil {
		ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	_ = copier.CopyWithOption(&artworkPriceWholeInfoResp, artworkPriceRes, copier.Option{DeepCopy: true})

	zap.L().Info(" dci 文件上传 :", zap.Any("GetUploadUrlResponse :", artworkPriceRes))

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   artworkPriceWholeInfoResp,
		Status: e.Ok,
	})

}

func SavePolicy(c *gin.Context) {
	var policy artShow.PricePolicy
	if err := c.ShouldBind(&policy); err != nil {
		logger.Errorf("PricePolicy ShouldBind err", err)
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	honorCountReq := new(artist.HonorCountReq)
	honorCountReq.ArtistUid = policy.ArtistUID
	honorCountResp, err := GrpcArtistImpl.HonorCount(c, honorCountReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrorQueryHonorInfo,
			Status: e.Failed,
		})
		return
	}

	fmt.Println("=============== honorCount 1 =========================")
	fmt.Printf("honorCountResp %+v\n ", honorCountResp)
	fmt.Println("=============== honorCount 2 =========================")

	if honorCountResp != nil {
		policy.Factor = new(artShow.PricePolicyFactor)
		//policy.Factor.PaintingCount = showDetailRes.Data[i].ArtworkNum
		//policy.Factor.AverageCanvasSize = float32(math.Round(float64(showDetailRes.Data[i].Ruler / showDetailRes.Data[i].ArtworkNum)))
		//policy.Factor.TaifengExhibitionCount = float32(honorCountResp.CaaJoinYear)
		policy.Factor.MeixieYears = float32(honorCountResp.CaaJoinYear)
		policy.Factor.ExternalExhibitionCount = float32(honorCountResp.Exhibition)
		policy.Factor.ArtistProfessionalismIndex = float32(honorCountResp.Professionalism)
		policy.Factor.ArtistCollectibilityIndex = float32(honorCountResp.Collectible)
		policy.Factor.ArtistExperienceEducationIndex = float32(honorCountResp.Education)
		policy.Factor.ArtistInfluencePopularityIndex = float32(honorCountResp.Influence)
		policy.Factor.StudyAbroadExperienceCount = float32(honorCountResp.StudyTourCount)
		policy.Factor.AwardExperienceCount = float32(honorCountResp.AwardCount)
		policy.Factor.NationalTitleCount = float32(honorCountResp.NationTitleCount)
		policy.Factor.ProvincialTitleCount = float32(honorCountResp.ProvinceTitleCount)
		policy.Factor.OtherTitleCount = float32(honorCountResp.OtherTitleCount)
		policy.Factor.PublishedPaintingCount = float32(honorCountResp.ArtworkPublishCount)
		policy.Factor.ExternalExhibitionCount = float32(honorCountResp.OutsidePublishCount)
		policy.Factor.AcademicPublicationCount = float32(honorCountResp.AcademicPublishCount)
		policy.Factor.ThirdPartyCuratorComment = float32(honorCountResp.ThirdCommentCount)
	}

	fmt.Println("=============== policy 1 =========================")
	fmt.Printf("policy %+v\n ", policy)
	fmt.Println("=============== policy 2 =========================")

	_, err = GrpcArtShowImpl.CreatePricePolicy(context.Background(), &policy)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    e.GetMsg(e.Success),
		Status: e.Ok,
	})

}

func QueryPolicy(c *gin.Context) {
	var queryPolicyReq artShow.QueryPolicyReq
	if err := c.ShouldBind(&queryPolicyReq); err != nil {
		logger.Errorf("QueryPolicyReq ShouldBind err", err)
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	policy, err := GrpcArtShowImpl.QueryPricePolicy(context.Background(), &queryPolicyReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	honorCountReq := new(artist.HonorCountReq)
	honorCountReq.ArtistUid = policy.ArtistUID
	honorCountResp, err := GrpcArtistImpl.HonorCount(c, honorCountReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrorQueryHonorInfo,
			Status: e.Failed,
		})
		return
	}

	fmt.Println("=============== honorCount 1 =========================")
	fmt.Printf("honorCountResp %+v\n ", honorCountResp)
	fmt.Println("=============== honorCount 2 =========================")

	if honorCountResp != nil {
		//policy.Factor = new(artShow.PricePolicyFactor)
		//policy.Factor.PaintingCount = showDetailRes.Data[i].ArtworkNum
		//policy.Factor.AverageCanvasSize = float32(math.Round(float64(showDetailRes.Data[i].Ruler / showDetailRes.Data[i].ArtworkNum)))
		//policy.Factor.TaifengExhibitionCount = float32(honorCountResp.CaaJoinYear)
		policy.Factor.MeixieYears = float32(honorCountResp.CaaJoinYear)
		policy.Factor.ExternalExhibitionCount = float32(honorCountResp.Exhibition)
		policy.Factor.ArtistProfessionalismIndex = float32(honorCountResp.Professionalism)
		policy.Factor.ArtistCollectibilityIndex = float32(honorCountResp.Collectible)
		policy.Factor.ArtistExperienceEducationIndex = float32(honorCountResp.Education)
		policy.Factor.ArtistInfluencePopularityIndex = float32(honorCountResp.Influence)
		policy.Factor.StudyAbroadExperienceCount = float32(honorCountResp.StudyTourCount)
		policy.Factor.AwardExperienceCount = float32(honorCountResp.AwardCount)
		policy.Factor.NationalTitleCount = float32(honorCountResp.NationTitleCount)
		policy.Factor.ProvincialTitleCount = float32(honorCountResp.ProvinceTitleCount)
		policy.Factor.OtherTitleCount = float32(honorCountResp.OtherTitleCount)
		policy.Factor.PublishedPaintingCount = float32(honorCountResp.ArtworkPublishCount)
		policy.Factor.ExternalExhibitionCount = float32(honorCountResp.OutsidePublishCount)
		policy.Factor.AcademicPublicationCount = float32(honorCountResp.AcademicPublishCount)
		policy.Factor.ThirdPartyCuratorComment = float32(honorCountResp.ThirdCommentCount)
	}

	fmt.Println("=============== policy 1 =========================")
	fmt.Printf("policy %+v\n ", policy)
	fmt.Println("=============== policy 2 =========================")

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   policy,
		Status: e.Ok,
	})

}

func CanShow(c *gin.Context) {
	var canShowReq artShow.CanShowReq
	if err := c.ShouldBind(&canShowReq); err != nil {
		logger.Errorf("CanShow ShouldBind err", err)
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	approvalReq := new(approval.ArtShowApprovalListReq)
	approvalReq.ShowUid = canShowReq.ShowUID
	result, err := ApprovalProvider.ListApprovalByShowUID(context.Background(), approvalReq)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    "查询画展包审批状态失败",
			Status: e.Failed,
		})
		return
	}

	if result.Count > 0 {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    "该画展包状态不可修改",
			Status: e.Failed,
		})
		return
	}

	_, err1 := GrpcArtShowImpl.CanShow(context.Background(), &canShowReq)
	if err1 != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrorUpdateCanShowStatus,
			Status: e.Failed,
		})
		return
	}

	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Status: e.Ok,
	})
}

// 是否 只有查看 可画展画展包权限
func hasCanShowAuth(c *gin.Context) (canShow int32) {

	canShow = 0
	userInfo := login.GetUserInfoFromC(c)

	fmt.Println(userInfo)
	//内部
	req := position.DoIHavaAuthRequest{
		UserId: userInfo.ID,
		Url:    e.QueryCanShow,
		//DepartmentID: departmentId,
	}

	res, err := PositionProvider.DoIHavaAuth(c, &req)

	if err == nil && res.Hava == true {
		canShow = e.CanShow
	}

	return canShow

}

// 发起画展包核验
var ongoingRequests sync.Map

func ShowStartCheck(c *gin.Context) {
	var req = struct {
		ShowUid   string `json:"showUid"`
		ArtistUid string `json:"artistUid"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Errorf("ShowStartCheck ShouldBindJSON err", err)
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if req.ShowUid == "" {
		ErrorWithMark(c, e.InvalidParams, nil, "", "画展uid不能为空")
		return
	}
	if req.ArtistUid == "" {
		ErrorWithMark(c, e.InvalidParams, nil, "", "画家uid不能为空")
		return
	}
	// 一个画展包同一时间，只能请求一次
	// 检查是否已经有正在进行的请求
	if _, ongoing := ongoingRequests.LoadOrStore(req.ShowUid, true); ongoing {
		// 如果有正在进行的请求，则返回错误
		service.Error(c, e.Failed, errors.New("警告：请勿重复提交！"))
		return
	}
	//showDetail, err := GrpcArtShowImpl.GetArtShowData(c, &artShow.GetArtShowRequest{ShowUid: req.ShowUid})
	//if err != nil {
	//	service.Error(c, e.Failed, err)
	//	return
	//}
	//if showDetail.IsSend == 2 {
	//	service.Error(c, e.Failed, errors.New("已发起审核：请勿重复提交！"))
	//	return
	//}
	// 执行完成删除记录
	defer ongoingRequests.Delete(req.ShowUid)
	fmt.Println("ShowStartCheck 11111111111111111")
	// 创建画家的一键审批记录
	artistDataRes, err := GrpcArtistImpl.ArtistDetail(c, &artist.DetailRequest{Uid: req.ArtistUid})
	if err != nil {
		logger.Error("GrpcArtistImpl.ArtistDetail err", zap.Error(err))
		ErrorWithMark(c, e.Failed, err, " GrpcArtistImpl.ArtistDetail Error:"+err.Error(), "查询失败")
		return
	}
	//if artistDataRes.ProfileInfo.Resume == "" {
	//	ErrorWithMark(c, e.Failed, err, "artistDataRes.ProfileInfo.Resume == \"\"", "请填写画家个人简介后再发起核验")
	//	return
	//}
	fmt.Printf("resum1:%s\n", artistDataRes.ProfileInfo.Resume)
	_, err = GrpcArtistImpl.CreateArtistOneQueryCheckRecord(c, &artist.ArtistOneQueryCheckRecordData{
		ArtistUID: req.ArtistUid,
		ShowUid:   req.ShowUid,
		Resume1:   artistDataRes.ProfileInfo.Resume,
	})
	if err != nil {
		logger.Error("GrpcArtistImpl.CreateArtistOneQueryCheckRecord err", err)
		ErrorWithMark(c, e.Failed, err, "GrpcArtistImpl.CreateArtistOneQueryCheckRecord Error:"+err.Error(), "查询失败")
		return
	}
	fmt.Println("ShowStartCheck 3333333333333333333333333")
	// 修改画作的审批状态为待核验
	showInfo, err := GrpcArtShowImpl.ShowWithArtwork(c, &artShow.ArtworkDetailReq{
		ShowUID: req.ShowUid,
	})
	if err != nil {
		logger.Errorf("GrpcArtShowImpl.ShowArtworkInfo err", err)
		ErrorWithMark(c, e.Failed, err, "GrpcArtShowImpl.ShowArtworkInfo Error:"+err.Error(), "查询失败")
		return
	}
	fmt.Println("ShowStartCheck 222222222222222222222")
	if len(showInfo.ArtworkUIDs) > 0 {
		_, err = GrpcArtworkImpl.OneQueryAudit(c, &artwork.OneQueryAuditReq{
			ArtworkUidList: showInfo.ArtworkUIDs,
			CheckStatus:    2,
		})
		if err != nil {
			logger.Error("GrpcArtworkImpl.OneQueryAudit err:", err)
			ErrorWithMark(c, e.Failed, err, "GrpcArtworkImpl.OneQueryAudit Error:"+err.Error(), "查询失败")
			return
		}
	}
	fmt.Println("ShowStartCheck 444444444444444444444444")

	//画展包审发起状态改为已发起
	resp, err := GrpcArtShowImpl.IsSend(c, &artShow.IsSendReq{
		ShowUID: req.ShowUid,
		IsSend:  2,
	})
	fmt.Println("ShowStartCheck 555555555555555555555")
	if err != nil {
		logger.Error("GrpcArtShowImpl.IsSend err", err)
		if resp != nil && resp.Msg != "" {
			ErrorWithMark(c, e.Failed, err, " GrpcArtShowImpl.IsSend Error:"+err.Error(), resp.Msg)
			return
		}
		ErrorWithMark(c, e.Failed, err, " GrpcArtShowImpl.IsSend Error:"+err.Error(), "查询失败")
		return
	}
	Success(c)
}

func GetAccInfoWithToken(ctx *gin.Context) (accInfo *account.AccountInfo, err error, code int) {
	authorization := ctx.GetHeader(e.Authorization)
	if authorization == "" {
		err = errors.New("登录状态失效")
		code = e.NotLogin
		return
	}

	jwt, err := secret.GetJwtFromStr(authorization)
	if err != nil {
		err = errors.New("登录状态失效")
		code = e.NotLogin
		return
	}

	//0 解密
	info, err := AccountProvider.DecryptJwt(ctx, &account.DecryptJwtRequest{
		Token: jwt,
	})
	if err != nil {
		err = errors.New("登录状态失效")
		code = e.NotLogin
		return
	}
	//1 获取用户的账号信息
	infoRes, err := AccountProvider.Info(ctx, &account.InfoRequest{
		ID: info.ID,
	})
	if err != nil {
		err = errors.New("登录状态失效")
		code = e.NotLogin
		return
	}
	accInfo = infoRes.Info
	return
}

func ArtworkPriceListV2(ctx *gin.Context) {
	var (
		artworkListReq *artShow.ArtworkPriceListV2Req
		artworkListRes *artShow.ArtworkPriceListRes
		err            error
	)
	if err = ctx.ShouldBind(&artworkListReq); err != nil {
		zap.L().Error("ArtworkPriceListV2 err ShouldBind", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	if artworkListRes, err = GrpcArtShowImpl.ArtworkPriceListV2(context.Background(), artworkListReq); err != nil {
		zap.L().Error("ArtworkPriceListV2 err query", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), artworkListRes)
	return
}

func UpdateArtworkPriceV2(ctx *gin.Context) {
	var (
		updateReq *artShow.UpdateArtworkPriceV2Req
		updateRes *artShow.UpdateArtworkPriceV2Res
		err       error
	)
	if err = ctx.ShouldBind(&updateReq); err != nil {
		zap.L().Error("UpdateArtworkPriceV2 err ShouldBind", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	if updateRes, err = GrpcArtShowImpl.UpdateArtworkPriceV2(context.Background(), updateReq); err != nil {
		zap.L().Error("UpdateArtworkPriceV2 err query", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), updateRes)
	return
}

func CalPriceSingle(ctx *gin.Context) {
	var (
		calReq *artShow.UpdateArtworkPriceV2Req
		calRes *artShow.ArtworkPriceListRes
		err    error
	)
	if err = ctx.ShouldBind(&calReq); err != nil {
		zap.L().Error("CalPriceSingle err ShouldBind", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	if calRes, err = GrpcArtShowImpl.CalPrice(context.Background(), calReq); err != nil {
		zap.L().Error("CalPriceSingle err query", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), calRes)
	return
}

func TalentAgencyList(ctx *gin.Context) {
	var (
		req *artShow.TalentAgencyListReq
		res *artShow.TalentAgencyListRes
		err error
	)
	if err = ctx.ShouldBind(&req); err != nil {
		zap.L().Error("TalentAgencyList err ShouldBind", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	if res, err = GrpcArtShowImpl.TalentAgencyList(context.Background(), req); err != nil {
		zap.L().Error("TalentAgencyList err query", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), res)
	return
}