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

1271 lines
44 KiB
Go
Raw Normal View History

2025-02-19 06:24:15 +00:00
package asArtwork
import (
"bufio"
"dubbo.apache.org/dubbo-go/v3/common/logger"
"encoding/json"
"errors"
"fmt"
"github.com/fonchain_enterprise/fonchain-main/pkg/config"
"github.com/fonchain_enterprise/fonchain-main/pkg/model"
"github.com/fonchain_enterprise/fonchain-main/pkg/service/artistInfo/asUser"
"github.com/jinzhu/copier"
"go.uber.org/zap"
"golang.org/x/net/context"
"log"
"os"
"path"
"path/filepath"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/fonchain_enterprise/fonchain-main/api/artistInfoContract"
"github.com/fonchain_enterprise/fonchain-main/api/artist"
"github.com/fonchain_enterprise/fonchain-main/api/artistInfoArtwork"
"github.com/fonchain_enterprise/fonchain-main/api/artistInfoUser"
"github.com/fonchain_enterprise/fonchain-main/api/artwork"
"github.com/fonchain_enterprise/fonchain-main/api/artwork_query"
"github.com/fonchain_enterprise/fonchain-main/pkg/e"
"github.com/fonchain_enterprise/fonchain-main/pkg/service"
"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
"github.com/fonchain_enterprise/fonchain-main/pkg/utils/stime"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
func CreateWorkProfile(c *gin.Context) {
var req AddArtWorkRequest
var err error
if err = c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, err.Error())
}
//ArtistUid 默认从token获取
if req.ArtistUuid == "" {
userInfo, err, code := asUser.GetUserInfoWithToken(c)
if err != nil {
service.ErrorWithMark(c, code, err, "AddArtwork:GetUserInfoWithToken", err.Error())
return
}
req.ArtistUuid = userInfo.MgmtArtistUid
}
if req.ArtworkType == 0 {
req.ArtworkType = 4 //默认画作类型为:普通画作
}
if req.CreateSource == 0 {
req.CreateSource = 2 //默认来源:画家宝
}
// 跳过画作微端的名称不能为空校验
if req.ArtworkName == "" {
req.ArtworkName = " "
}
req.CreatedDate = stime.TimeToString(time.Now(), stime.Format_Normal_YMD)
artistProfile, err := service.GrpcArtistImpl.ArtistInfo(c, &artist.ArtistInfoRequest{Uid: req.ArtistUuid})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "AddArtwork:GrpcArtistImpl.ArtistInfo Error", err.Error())
return
}
if req.ArtistName == "" {
req.ArtistName = utils.If(artistProfile.ProfileInfo.Name == "", " ", artistProfile.ProfileInfo.Name).(string)
}
// 创建画作
artworkRes, err := service.GrpcArtworkImpl.CreateArtworkProfile(c, req.ProtoRequest())
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "AddArtwork:CreateArtworkProfile Error", err.Error())
return
}
//记录画作锁定状态
_, err = service.GrpcArtistInfoArtworkImpl.CreateArtworkLockRecord(c, &artistInfoArtwork.CreateArtworkLockRecordReq{
ArtistUid: req.ArtistUuid,
ArtworkUid: artworkRes.Data.ArtworkUuid,
})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "AddArtwork:GrpcArtistInfoArtworkImpl.CreateArtworkLockRecord", err.Error())
return
}
service.Success(c)
return
}
// UpdateArtwork 更新画作
func UpdateArtwork(c *gin.Context) {
//查询用户信息
userInfo, err, code := asUser.GetUserInfoWithToken(c)
if err != nil {
service.Error(c, code, err, err.Error())
return
}
//检查用户锁
_, err = service.GrpcArtistInfoUserImpl.CheckUserLock(c, &artistInfoUser.CheckUserLockRequest{
Id: int64(userInfo.Id),
})
if err != nil {
service.Error(c, e.Failed, errors.New("用户已被锁定"))
return
}
// 解析请求参数
var req AddArtWorkRequest
if err = c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
service.Error(c, e.InvalidParams, err, err.Error())
return
}
//更新数据
_, err = service.GrpcArtworkImpl.UpdateArtworkProfile(c, req.ProtoRequest())
if err != nil {
service.Error(c, e.Failed, err, err.Error())
return
}
service.Success(c)
}
// UpdateArtwork 更新画作(根据页面进行了优化)
func UpdateArtwork2(c *gin.Context) {
//查询用户信息
//userInfo, err, code := asAccount.GetUserInfoWithToken(c)
//if err != nil {
// service.Error(c, code, err, err.Error())
// return
//}
//检查用户锁
//_, err = service.GrpcArtistInfoUserImpl.CheckUserLock(c, &asUser.CheckUserLockRequest{
// Id: int64(userInfo.Id),
//})
//if err != nil {
// service.Error(c, e.Failed, errors.New("用户已被锁定"))
// return
//}
// 解析请求参数
var req AddArtWorkRequest
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
service.Error(c, e.InvalidParams, err, err.Error())
return
}
//检查画作锁定状态
artworkLock, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockDetail(c, &artistInfoArtwork.GetArtworkLockDetailRequest{ArtworkUid: req.ArtworkUuid})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "UpdateArtwork2: GetArtworkLockDetail Error", err.Error())
return
}
if artworkLock.BaseAuditStatus != 1 && artworkLock.BaseAuditStatus != 3 {
service.ErrorWithMark(c, e.Failed, err, fmt.Sprintf("UpdateArtwork2: GetArtworkLockDetail artworkLock.BaseAuditStatus:%s", AuditStatus(artworkLock.BaseAuditStatus)), fmt.Sprintf("画作当前状态为[%s],不允许修改", AuditStatus(artworkLock.BaseAuditStatus)))
return
}
//获取详情
detailRes, err := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{Type: "1", ArtworkUuid: req.ArtworkUuid})
if err != nil {
service.ErrorWithMark(c, e.InvalidParams, err, "UpdateArtwork2: ArtworkDetail Error", err.Error())
return
}
detailRes.ProfileInfo.ArtworkName = req.ArtworkName
detailRes.ProfileInfo.Length = req.Length
detailRes.ProfileInfo.Width = req.Width
detailRes.ProfileInfo.Ruler = req.Ruler
detailRes.ProfileInfo.CreatedAddress = strings.Join(req.CreatedAddress, "")
detailRes.ProfileInfo.ArtistPhoto = req.ArtistPhoto
detailRes.ProfileInfo.HdPic = req.HdPic
//更新数据
_, err = service.GrpcArtworkImpl.UpdateArtworkProfile(c, req.ProtoRequest())
if err != nil {
service.Error(c, e.Failed, err, err.Error())
return
}
if artworkLock.BaseAuditStatus == 3 || artworkLock.SupplementAuditStatus == 3 {
var flowIndex int64 = 3
if artworkLock.BaseAuditStatus == 3 {
flowIndex = 2
}
if _, err = service.GrpcArtistInfoArtworkImpl.UpdateArtworkAuditStatus(c, &artistInfoArtwork.UpdateArtworkAuditStatusRequest{
ArtworkUid: req.ArtworkUuid,
AuditStatus: 2,
FlowIndex: flowIndex,
}); err != nil {
service.ErrorWithMark(c, e.Failed, err, "UpdateArtwork2 :GrpcArtistInfoArtworkImpl.UpdateArtworkAuditStatus Error", err.Error())
return
}
}
service.Success(c)
}
// GetArtworkProfile 获取画作
func GetArtworkProfile(c *gin.Context) {
var req ArtworkDetailRequest
if err := c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "参数错误")
return
}
if req.ArtworkUuid == "" {
service.Error(c, e.InvalidParams, errors.New("artworkUuid不能为空"), "参数错误")
return
}
req.Type = "1" //1为查询首选项
res, err := service.GrpcArtworkImpl.ArtworkDetail(c, req.ProtoRequest())
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GetArtworkProfile GrpcArtworkImpl.ArtworkDetail Error", err.Error())
return
}
artworkLock, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockDetail(c, &artistInfoArtwork.GetArtworkLockDetailRequest{ArtworkUid: req.ArtworkUuid})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GetArtworkProfile GrpcArtistInfoArtworkImpl.GetArtworkLockDetail Error", err.Error())
return
}
var response = ArtworkDetailResponse{}
response.Convert(res, artworkLock)
service.Success(c, response)
}
// GetArtworkList 获取画作列表
//
// func GetArtworkList(c *gin.Context) {
// var req artwork_query.ArtworkPreviewListRequest
// if err := c.ShouldBindJSON(&req); err != nil {
// service.Error(c, e.InvalidParams, err, "无效参数")
// return
// }
// res, err := service.GrpcArtworkQueryImpl.ArtworkPreviewList(c, &req)
// if err != nil {
// service.ErrorWithMark(c, e.Failed, err, "GetArtworkList:ArtworkList", "查询失败")
// return
// }
// var respList = []ArtworkListResponse{}
// if len(res.Data) > 0 {
// for _, v := range res.Data {
// //todo 最好通过列表接口返回需要的字段
// artworkDetail, err := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{ArtworkUuid: v.ArtworkUid, Type: "1"})
// if err != nil {
// log.Println("rpcArtworkImpl.ArtworkDetail ERROR", err.Error())
// }
// var inscribeDate string
// if artworkDetail != nil && artworkDetail.ProfileInfo != nil {
// inscribeDate = artworkDetail.ProfileInfo.InscribeDate
// }
// var item = ArtworkListResponse{
// ArtistUid: v.ArtistUuid,
// ArtworkName: v.ArtworkName,
// Length: v.Length,
// Width: v.Width,
// Ruler: v.Ruler,
// CreatedAddress: v.CreatedAddress,
// ArtistPhoto: v.ArtistPhoto,
// HdPic: v.HdPic,
// ArtworkUid: v.ArtworkUid,
// CreateDate: v.CreateDate,
// InscribeDate: inscribeDate,
// }
// respList = append(respList, item)
// }
// }
// service.ResponseList(c, respList, service.OptionPage(res.Page.Page, res.Page.PageSize, res.Page.Total), service.OptionMsg("查询成功"))
// }
// 第二版画作列表接口
func GetArtworkList2(c *gin.Context) {
var req GetArtworkListRequest
if err := c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "无效参数")
return
}
// 从画家宝查询画作
var err error
var artworks *artistInfoArtwork.ArtworkLockList
var artworkUids []string
switch req.SearchMode {
case 1: //查询锁定的画作
artworks, err = service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords(c, &artistInfoArtwork.GetArtworkLockRecordsRequest{
ArtistUid: req.ArtistUid,
QueryType: artistInfoArtwork.ArtworkQueryMode_NowLockedArtwork,
})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GetArtworkList2:GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error 1")
}
case 2: //查询解锁的画作
artworks, err = service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords(c, &artistInfoArtwork.GetArtworkLockRecordsRequest{
ArtistUid: req.ArtistUid,
QueryType: artistInfoArtwork.ArtworkQueryMode_AllUnlockArtwork,
})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GetArtworkList2:GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error 2")
}
default: //所有画作
artworks, err = service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords(c, &artistInfoArtwork.GetArtworkLockRecordsRequest{
ArtistUid: req.ArtistUid,
})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GetArtworkList2:GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error 3")
}
// artworks.Data = append(artworks.Data, artworks2.Data...)
}
for _, v := range artworks.Data {
artworkUids = append(artworkUids, v.ArtworkUid)
}
var total int64 = int64(len(artworkUids))
if total == 0 {
service.ResponseList(c, nil, service.OptionPage(req.Page, req.PageSize, total), service.OptionMsg("查询成功"))
return
}
//从画作服务查询画作数据
res, err := service.GrpcArtworkQueryImpl.ArtworkPreviewList(c, &artwork_query.ArtworkPreviewListRequest{
Page: 1,
PageSize: int32(len(artworkUids)),
ArtworkUids: artworkUids,
})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GetArtworkList:ArtworkList", "查询失败")
return
}
var respList = []ArtworkListResponse{}
if len(res.Data) > 0 {
for k, v := range res.Data {
if int64(k) >= req.PageSize*(req.Page-1) && int64(k) < req.PageSize*req.Page {
//todo 最好通过列表接口返回需要的字段
artworkDetail, err := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{ArtworkUuid: v.ArtworkUid, Type: "1"})
if err != nil {
log.Println("rpcArtworkImpl.ArtworkDetail ERROR", err.Error())
}
var inscribeDate string
if artworkDetail != nil && artworkDetail.ProfileInfo != nil {
inscribeDate = artworkDetail.ProfileInfo.InscribeDate
}
var (
auditFlowIndex = "无"
auditStatus = "无"
updatedAt string
createdAt string
)
for _, auditRecord := range artworks.Data {
if auditRecord.ArtworkUid == v.ArtworkUid {
auditFlowIndex, auditStatus = DescriptionAuidtStatusAtNow(auditRecord)
updatedAt = time.Unix(auditRecord.UpdatedAt, 0).Format(stime.Format_Normal_YMDhms)
createdAt = time.Unix(auditRecord.CreatedAt, 0).Format(stime.Format_Normal_YMDhms)
}
}
//获取画作合同状态
getContractStateRespond, err := service.GrpcArtistInfoContracImpl.GetContractState(c, &artistInfoContract.GetContractStateRequest{AristUid: v.ArtistUuid, ArtworkUid: v.ArtworkUid})
if err != nil {
return
}
if getContractStateRespond != nil {
var item = ArtworkListResponse{
CreatedAt: createdAt,
UpdatedAt: updatedAt,
ArtistUid: v.ArtistUuid,
ArtworkName: v.ArtworkName,
Length: v.Length,
Width: v.Width,
Ruler: v.Ruler,
CreatedAddress: v.CreatedAddress,
ArtistPhoto: v.ArtistPhoto,
HdPic: v.HdPic,
ArtworkUid: v.ArtworkUid,
CreateDate: v.CreateDate,
InscribeDate: inscribeDate,
FolwIndexAtNow: auditFlowIndex,
AuditStatusStr: auditStatus,
FirstState: getContractStateRespond.FirstState,
SecondState: getContractStateRespond.SecondState,
ThirdState: getContractStateRespond.ThirdState,
Tfnum: v.Tfnum,
}
respList = append(respList, item)
}
}
}
}
sort.Slice(respList, func(i, j int) bool {
return respList[i].Tfnum < respList[j].Tfnum
})
service.ResponseList(c, respList, service.OptionPage(req.Page, req.PageSize, total), service.OptionMsg("查询成功"))
}
// GetArtworkPreviewList 获取画作预览列表(画作管理中的列表)
func GetArtworkPreviewListAtUserSide(c *gin.Context) {
userInfo, err, code := asUser.GetUserInfoWithToken(c)
if err != nil {
service.Error(c, code, err, err.Error())
return
}
var req GetArtworkPreviewListReq
if err = c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "无效参数")
return
}
if req.ArtistUid == "" {
req.ArtistUid = userInfo.MgmtArtistUid
}
//获取当前暂存或经锁定的画作
GetArtworkPreviewList(c, &req, artistInfoArtwork.ArtworkQueryMode_NowPreSaveAndLocked)
}
func GetArtworkHistoryList(c *gin.Context) {
var req = artwork_query.ArtworkPreviewListRequest{}
if err := c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "无效参数")
return
}
if req.ArtistUid == "" {
userInfo, err, code := asUser.GetUserInfoWithToken(c)
if err != nil {
service.Error(c, code, err, err.Error())
return
}
req.ArtistUid = userInfo.MgmtArtistUid
}
// 获取画作历史记录
records, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockHistoryGroup(c, &artistInfoArtwork.GetArtworkLockHistoryRequest{
ArtistUid: req.ArtistUid,
})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GetArtworkList:GrpcArtistInfoArtworkImpl.GetArtworkLockRecords", "查询失败")
return
}
if len(records.GroupList) == 0 {
service.ResponseList(c, []struct{}{}, service.OptionPage(req.Page, req.PageSize, 0), service.OptionMsg("查询成功"))
return
}
var returData = ArtworkLockRecordList{}
returData.ConvertData(records.GroupList)
service.ResponseList(c, returData.Data, service.OptionPage(1, len(records.GroupList), len(records.GroupList)), service.OptionMsg("查询成功"))
}
// DelArtwork 删除画作
func DelArtwork(c *gin.Context) {
//查询用户信息
userInfo, err, code := asUser.GetUserInfoWithToken(c)
if err != nil {
service.Error(c, code, err, err.Error())
return
}
//检查用户锁
_, err = service.GrpcArtistInfoUserImpl.CheckUserLock(c, &artistInfoUser.CheckUserLockRequest{
Id: int64(userInfo.Id),
})
if err != nil {
service.Error(c, e.Failed, errors.New("用户已被锁定"))
return
}
var req DelAwRequest
if err := c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "参数错误")
return
}
if req.ArtworkUuid == "" {
service.Error(c, e.InvalidParams, errors.New("artworkUid不能为空"), "参数错误")
return
}
//删除画作
res, err := service.GrpcArtworkQueryImpl.DelArtwork(c, req.ProtoRequest())
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "DelArtwork: ArtworkQueryImpl.DelArtwork Error", res.Msg)
return
}
//删除锁定记录
_, err = service.GrpcArtistInfoArtworkImpl.DeleteArtworkRecord(c, &artistInfoArtwork.DeleteArtworkRecordRequest{ArtworkUids: []string{req.ArtworkUuid}})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "DelArtwork: GrpcArtistInfoArtworkImpl.DeleteArtworkRecord Error", res.Msg)
return
}
service.Success(c)
return
}
func UploadArtwork(c *gin.Context) {
//创建一个UserLoginService对象
//var req asArtwork.UploadArtworkRequest
//claims, err := utils.ParseToken(c.GetHeader("Authorization"))
//if err != nil {
// service.Error(c, e.Failed, err)
// return
//}
//if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
// service.Error(c, e.InvalidParams, err, err.Error())
// return
//}
//var userLock = artistinfo.CheckUserLockRequest{
// Id: int64(claims.ID),
//}
//_, err = service.GrpcArtistInfoUserImpl.CheckUserLock(c, &userLock)
//fmt.Println("?????")
//if err != nil {
// fmt.Println("!!!!!")
// fmt.Println(err.Error())
// service.Error(c, e.InvalidParams, err, err.Error())
// return
//}
//res, err := service.GrpcArtworkImpl.UploadArtwork(c, &req)
//if err != nil {
// service.Error(c, e.InvalidParams, err, err.Error())
// return
//}
//service.Success(c, res)
}
func ImportArtowrkToArtworkService(c *gin.Context) {
var req artwork.UpdateInsourceReq
if err := c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "无效参数")
return
}
if req.ArtworkUid == "" && len(req.ArtworkUids) == 0 {
service.Error(c, e.InvalidParams, nil, "参数不能为空")
return
}
if req.InSource == artwork.InSource_InsourceNone {
req.InSource = artwork.InSource_InSourceManagerAndBox
}
fmt.Printf("导入画作:artwork_uid =%v insource=%d\n", req.ArtworkUid, req.InSource)
_, err := service.GrpcArtworkImpl.UpdateInsource(c, &req)
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "ImportArtowrkToArtworkService GrpcArtworkImpl.UpdateInsource", "更新失败")
return
}
//按业务部需求导入后要将尺寸相关设置为0
var artistUid string
if req.InSource == 3 {
artworkProfile, err := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{ArtworkUuid: req.ArtworkUid, Type: "1"})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "ImportArtowrkToArtworkService GrpcArtworkImpl.ArtworkDetail 111", "画作信息查询失败")
return
}
artistUid = artworkProfile.ProfileInfo.ArtistUuid
artworkProfile.ProfileInfo.Length = 0
artworkProfile.ProfileInfo.Width = 0
artworkProfile.ProfileInfo.Ruler = 0
_, err = service.GrpcArtworkImpl.UpdateArtworkProfile(c, artworkProfile.ProfileInfo)
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "ImportArtowrkToArtworkService GrpcArtworkImpl.ArtworkDetail 222", "清除画作尺寸失败")
return
}
}
//根据画家锁定状态,提供提示
if artistUid != "" {
userInfo, err := service.GrpcArtistInfoUserImpl.FindUser(c, &artistInfoUser.FindUserRequest{MgmtArtistUid: artistUid})
if err != nil || (err == nil && userInfo.IsLock) {
service.Success(c)
} else if err == nil && !userInfo.IsLock {
service.ResponseQuickMsg(c, 0, "注意:画家尚未锁定,画作处于可删除状态!", nil)
}
} else {
service.Success(c)
}
}
func GetArtworkPreviewListAtBackendSide2(c *gin.Context) {
var req GetArtworkPreviewListReq
if err := c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "无效参数")
return
}
result, err := handleArtworkPreviewList(&req, c)
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GrpcArtistInfoArtworkImpl.GetArtworkViewList Err", err.Error())
return
}
var resp []ArtworkViewDetailListType
copier.Copy(&resp, &result.Datas)
if len(resp) > 0 {
//获取释义补充信息
for i, v := range resp {
detail, errs := service.GrpcArtworkImpl.ArtworkDetail(c, &artwork.ArtworkDetailRequest{Type: "7", ArtworkUuid: v.ArtworkUid})
if errs != nil {
continue
}
resp[i].CommentData = detail.CopyRightInfo.Supplement
time.Sleep(50 * time.Millisecond)
}
}
service.ResponseList(c, resp,
service.OptionPage(req.Page, req.PageSize, result.Total), service.OptionMsg("查询成功"),
service.OptionAddField_ArtshowCount("artistUid"),
)
}
func handleArtworkPreviewList(req *GetArtworkPreviewListReq, c *gin.Context) (datas *artistInfoArtwork.GetArtworkViewListResponse, err error) {
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 where string
if req.QueryUnfinishedAudit == 1 {
where = "(base_audit_status < 3 or base_audit_status = 7)"
}
if req.QueryHaveProof == 1 {
if where != "" {
where += " AND "
}
where += "national_exhibition_proof !='' "
}
if req.NationalExhibition != 0 {
if where != "" {
where += " AND "
}
where += fmt.Sprintf("national_exhibition = %d ", req.NationalExhibition)
}
if req.RulerStart != nil {
if where != "" {
where += " AND "
}
where += fmt.Sprintf("ruler >= %d", *req.RulerStart)
}
if req.RulerEnd != nil {
if where != "" {
where += " AND "
}
where += fmt.Sprintf("ruler <= %d", *req.RulerEnd)
}
if req.BaseAuditStatus == 10 {
//查询所有画作
req.BaseAuditStatus = 0
if where != "" {
where += " AND "
}
where += "(base_audit_status<4 or base_audit_status=7)"
}
var mode artistInfoArtwork.ArtworkQueryMode
if req.History {
//查询历史画作
mode = artistInfoArtwork.ArtworkQueryMode_AllUnlockArtwork
} else if req.BaseAuditStatus == 1 {
//查询暂存的画作
mode = artistInfoArtwork.ArtworkQueryMode_NowPreSaveArtwork
} else {
//查询当前处于画作补充信息审批流程中的画作(未完成的画作)
mode = artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfBase
}
if req.PageSize <= 500 {
datas, err = service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(c, &artistInfoArtwork.ArtworkViewRequest{
ArtistUid: req.ArtistUid,
QueryType: mode,
BaseAuditStatus: req.BaseAuditStatus,
SupplementAuditStatus: int64(req.SupplementAuditStatus),
ArtworkUids: req.ArtworkUids,
Page: int64(req.Page),
PageSize: int64(req.PageSize),
Order: order,
ArtworkName: req.ArtworkName,
ArtistName: req.ArtistName,
Status: nil,
Tfnum: req.Tfnum,
StartBaseInfoArtistUpdateAt: req.StartBaseInfoArtistUpdateAt,
EndBaseInfoArtistUpdateAt: req.EndBaseInfoArtistUpdateAt,
Where: where,
})
} else if req.PageSize == 9999 {
fmt.Println("分页遍历获取全量数据")
//分页遍历获取全量数据
datas = &artistInfoArtwork.GetArtworkViewListResponse{}
var page int64 = 1
var pageSize int64 = 500
var total int64 = 0
fmt.Println("page", page)
data1, err2 := service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(c, &artistInfoArtwork.ArtworkViewRequest{
ArtistUid: req.ArtistUid,
QueryType: mode,
BaseAuditStatus: req.BaseAuditStatus,
SupplementAuditStatus: int64(req.SupplementAuditStatus),
ArtworkUids: req.ArtworkUids,
Page: page,
PageSize: pageSize,
Order: order,
ArtworkName: req.ArtworkName,
ArtistName: req.ArtistName,
Status: nil,
Tfnum: req.Tfnum,
StartBaseInfoArtistUpdateAt: req.StartBaseInfoArtistUpdateAt,
EndBaseInfoArtistUpdateAt: req.EndBaseInfoArtistUpdateAt,
Where: where,
})
if err2 != nil {
err = err2
return
}
total = data1.Total
fmt.Println("total", total)
datas.Total = data1.Total
datas.PageSize = int32(data1.Total)
datas.Page = 1
datas.Datas = append(datas.Datas, data1.Datas...)
for page*pageSize < total {
page++
fmt.Println("page", page)
data1, err = service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(c, &artistInfoArtwork.ArtworkViewRequest{
ArtistUid: req.ArtistUid,
QueryType: mode,
BaseAuditStatus: req.BaseAuditStatus,
SupplementAuditStatus: int64(req.SupplementAuditStatus),
ArtworkUids: req.ArtworkUids,
Page: page,
PageSize: pageSize,
Order: order,
ArtworkName: req.ArtworkName,
ArtistName: req.ArtistName,
Tfnum: req.Tfnum,
StartBaseInfoArtistUpdateAt: req.StartBaseInfoArtistUpdateAt,
EndBaseInfoArtistUpdateAt: req.EndBaseInfoArtistUpdateAt,
})
if err != nil {
return
}
datas.Datas = append(datas.Datas, data1.Datas...)
}
} else {
err = errors.New("数据量过大,请缩小分页再试")
}
return datas, err
}
func GetArtworkPreviewDetailAtBackendSide2(c *gin.Context) {
var req GetArtworkPreviewDetailReq
if err := c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "无效参数")
return
}
datas, err := service.GrpcArtistInfoArtworkImpl.GetArtworkViewList(c, &artistInfoArtwork.ArtworkViewRequest{
ArtworkUids: []string{req.ArtworkUid},
Page: 1,
PageSize: 1,
})
if err != nil {
service.ErrorWithMark(c, e.Failed, err, "GrpcArtistInfoArtworkImpl.GetArtworkViewList Err", err.Error())
return
}
//var returnData = &artistInfoArtwork.ArtworkViewDetail{}
//if len(datas.Datas) > 0 {
// returnData = datas.Datas[0]
//}
//service.ResponseData(c, returnData, service.OptionMsg("查询成功"))
var tempData []map[string]any
if len(datas.Datas) > 0 {
jsonBytes, _ := json.Marshal(datas.Datas)
_ = json.Unmarshal(jsonBytes, &tempData)
service.FillArtshowCount(tempData, "artistUid")
service.ResponseData(c, tempData[0], service.OptionMsg("查询成功"))
} else {
service.ResponseData(c, nil, service.OptionMsg("查询成功"))
}
}
// GetArtworkPreviewListAtBackendSide
// Deprecated
func GetArtworkPreviewListAtBackendSide(c *gin.Context) {
var req GetArtworkPreviewListReq
if err := c.ShouldBindJSON(&req); err != nil {
service.Error(c, e.InvalidParams, err, "无效参数")
return
}
if req.ArtistUid == "" {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
return
}
//使用画作名称模糊查询画作列表
var isSearhArtwork bool
if req.ArtworkName != "" {
isSearhArtwork = true
var artworkUids []string
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)
}
req.ArtworkUids = artworkUids
}
if isSearhArtwork && len(req.ArtworkUids) == 0 {
service.ResponseList(c, []struct{}{}, service.OptionPage(req.Page, req.PageSize, 0), service.OptionMsg("查询成功"))
return
}
if req.History {
//查询历史画作
GetArtworkPreviewList(c, &req, artistInfoArtwork.ArtworkQueryMode_AllUnlockArtwork)
} else if req.BaseAuditStatus == 1 {
//查询暂存的画作
GetArtworkPreviewList(c, &req, artistInfoArtwork.ArtworkQueryMode_NowPreSaveArtwork)
} else {
//查询当前处于画作补充信息审批流程中的画作(未完成的画作)
GetArtworkPreviewList(c, &req, artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfBase)
}
}
// GetArtworkPreviewListAtBackendSideExport
// Deprecated
func GetArtworkPreviewListAtBackendSideExport(c *gin.Context) {
var req GetArtworkPreviewExportReq
var exportUrl string
if err := c.ShouldBindJSON(&req); err != nil {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
return
}
if req.ColumnId == "" {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
return
}
//if req.ArtistUid == "" {
// service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
// return
//}
//根据ID查询导出字段信息
var exportFileReq artistInfoArtwork.ExportFieldDataReq
exportFileReq.ColumnId = req.ColumnId
exportDataResp, err := service.GrpcArtistInfoArtworkImpl.ExportFieldData(context.Background(), &exportFileReq)
if err != nil {
service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
return
}
if exportDataResp == nil || exportDataResp.Data == nil || len(exportDataResp.Data) == 0 {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.NOTDATA), nil)
return
}
//使用画作名称模糊查询画作列表
var isSearhArtwork bool
if req.ArtworkName != "" {
isSearhArtwork = true
var artworkUids []string
res, err := service.GrpcArtworkQueryImpl.ArtworkPreviewList(c, &artwork_query.ArtworkPreviewListRequest{ArtworkName: req.ArtworkName, ArtistUid: req.ArtistUid})
if err != nil {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.NOTDATA), nil)
return
}
for _, v := range res.Data {
artworkUids = append(artworkUids, v.ArtworkUid)
}
req.ArtworkUids = artworkUids
}
if req.ArtworkUuids != nil && len(req.ArtworkUuids) != 0 {
req.ArtworkUids = req.ArtworkUuids
}
if isSearhArtwork && len(req.ArtworkUids) == 0 {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.NOTDATA), nil)
return
}
var result []ArtworkPreviewResponse
var listReq GetArtworkPreviewListReq
_ = copier.Copy(&listReq, &req)
if req.History {
//查询历史画作
result, err = GetArtworkPreviewListData(&listReq, artistInfoArtwork.ArtworkQueryMode_AllUnlockArtwork)
} else if req.BaseAuditStatus == 1 {
//查询暂存的画作
result, err = GetArtworkPreviewListData(&listReq, artistInfoArtwork.ArtworkQueryMode_NowPreSaveArtwork)
} else {
//查询当前处于画作补充信息审批流程中的画作(未完成的画作)
result, err = GetArtworkPreviewListData(&listReq, artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfBase)
}
if err != nil {
//service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
service.ErrorWithMark(c, e.Failed, err, "GetArtworkPreviewListAtBackendSideExport:GetArtworkPreviewListData", "查询失败")
return
}
if len(result) == 0 {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.NOTDATA), nil)
return
}
// 如果字段有画家名字或者笔名
var selectArtistInfo bool
var columns, columnStruct, columnDesc []string
for _, v := range exportDataResp.Data {
columns = append(columns, v.ColumnDesc)
columnStruct = append(columnStruct, v.StructName)
columnDesc = append(columnDesc, v.ColumnDesc)
if v.StructName == "ArtistName" || v.StructName == "PenName" {
selectArtistInfo = true
}
}
fmt.Println("1")
//var exportData []ArtworkPreviewExport
//copier.Copy(&exportData, result)
var artistUuids []string
for k, _ := range result {
//result[k].ArtistName = req.ArtistName
//result[k].PenName = req.PenName
if selectArtistInfo {
artistUuids = append(artistUuids, result[k].ArtistUuid)
}
}
fmt.Println("2")
if len(artistUuids) > 0 {
getInfoResp, errS := service.GrpcArtistImpl.ArtistData(context.Background(), &artist.ArtistDataRequest{Uids: artistUuids})
if errS != nil {
service.ResponseQuickMsg(c, e.Failed, errS.Error(), nil)
return
}
if getInfoResp.Data != nil && len(getInfoResp.Data) > 0 {
for k, v := range result {
for _, vv := range getInfoResp.Data {
if vv.ProfileInfo.Uid == v.ArtistUuid {
result[k].ArtistName = vv.ProfileInfo.Name
result[k].PenName = vv.ProfileInfo.PenName
}
}
}
}
}
fmt.Println("3")
var adminId uint64
if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
userInfo := mLoginInfoAny.(model.LoginInfo)
adminId = userInfo.ID
}
if req.ExportType == 1 {
fileName := fmt.Sprintf("%s%d%s", model.EXPORT_ARTISTARTWORK_FILENAME, adminId, model.EXCEL_FILE_SUFFIX)
filePath := fmt.Sprintf("./runtime/%s", fileName)
_ = excelData(c, result, columnStruct, columns, filePath)
exportUrl = fileName
} else {
exportUrl, err = RegroupArtworkDownloadData(result, columnStruct, columnDesc, adminId, model.DownloadFile, model.EXPORT_ARTISTARTWORK_FILE_FILENAME)
if err != nil {
service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
return
}
}
fmt.Println("4")
var httpType string
if config.IsHttps {
httpType = model.HttpsType
} else {
httpType = model.HttpType
}
exportUrl = fmt.Sprintf("%s%s/static/%s", httpType, c.Request.Host, exportUrl)
service.ResponseQuickMsg(c, e.Ok, "", &ExportData{ExportUrl: exportUrl})
return
}
func GetArtworkPreviewListAtBackendSideExport2(c *gin.Context) {
var req GetArtworkPreviewExportReq
var exportUrl string
if err := c.ShouldBindJSON(&req); err != nil {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
return
}
if req.ColumnId == "" {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
return
}
//if req.ArtistUid == "" {
// service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
// return
//}
//根据ID查询导出字段信息
var exportFileReq artistInfoArtwork.ExportFieldDataReq
exportFileReq.ColumnId = req.ColumnId
exportDataResp, err := service.GrpcArtistInfoArtworkImpl.ExportFieldData(context.Background(), &exportFileReq)
if err != nil {
service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
return
}
if exportDataResp == nil || exportDataResp.Data == nil || len(exportDataResp.Data) == 0 {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.NOTDATA), nil)
return
}
var isSearhArtwork bool
if req.ArtworkName != "" {
isSearhArtwork = true
var artworkUids []string
res, err := service.GrpcArtworkQueryImpl.ArtworkPreviewList(c, &artwork_query.ArtworkPreviewListRequest{ArtworkName: req.ArtworkName, ArtistUid: req.ArtistUid})
if err != nil {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.NOTDATA), nil)
return
}
for _, v := range res.Data {
artworkUids = append(artworkUids, v.ArtworkUid)
}
req.ArtworkUids = artworkUids
}
if isSearhArtwork && len(req.ArtworkUids) == 0 {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.NOTDATA), nil)
return
}
var result []ArtworkPreviewResponse
var listReq GetArtworkPreviewListReq
_ = copier.Copy(&listReq, &req)
if req.ArtworkUuids != nil && len(req.ArtworkUuids) != 0 {
listReq.ArtworkUids = req.ArtworkUuids
}
previewData, err := handleArtworkPreviewList(&listReq, c)
if err != nil {
if strings.HasPrefix(err.Error(), "grpc: received message larger than max") {
service.ErrorWithMark(c, e.Failed, err, "export:handleArtworkPreviewList", "数据量过大,请分页导出")
} else if "数据量过大,请缩小分页再试" == err.Error() {
service.ErrorWithMark(c, e.Failed, err, "export:handleArtworkPreviewList", "数据量过大,请缩小分页再试")
} else {
service.ErrorWithMark(c, e.Failed, err, "export:handleArtworkPreviewList", "查询失败")
}
return
}
if previewData.Total == 0 {
service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.NOTDATA), nil)
return
}
//数据清晰
for _, v := range previewData.Datas {
result = append(result, ArtworkPreviewResponse{
//DeletedAt: v.DeletedAt,
//PenName: v.pEN,
//Id: v,
ArtistUuid: v.ArtistUid,
ArtworkName: v.ArtworkName,
Length: v.Length,
Width: v.Width,
Ruler: v.Ruler,
CreatedAddress: v.CreatedAddress,
ArtistPhoto: v.ArtistPhoto,
HdPic: v.HdPic,
ArtworkUid: v.ArtworkUid,
CreatedDate: v.CreatedDate,
LockStatus: int64(v.LockStatus),
CreatedAt: v.CreatedAt,
UpdatedAt: v.UpdatedAt,
BaseAuditStatus: v.BaseAuditStatus,
BaseAuditMark: v.BaseAuditMark,
BaseAuditMark2: v.BaseAuditMark2,
SupplementAuditStatus: v.SupplementAuditStatus,
SupplementAuditMark: v.SupplementAuditMark,
SupplementAuditMark2: v.SupplementAuditMark2,
AuditFlowIndex: v.AuditFlowIndex,
Insource: v.InSource,
NationalExhibition: int64(v.NationalExhibition),
TfNum: v.Tfnum,
ArtworkType: v.ArtworkType,
ArtistName: v.ArtistName,
BaseInfoArtistUpdateAt: v.BaseInfoArtistUpdateAt,
BaseInfoLatestOperator: v.BaseInfoLatestOperator,
BaseInfoLatestOperationTime: v.BaseInfoLatestOperationTime,
SupplyInfoArtistUpdateAt: v.SupplyInfoArtistUpdateAt,
SupplyInfoLatestOperator: v.SupplyInfoLatestOperator,
SupplyInfoLatestOperationTime: v.SupplyInfoLatestOperationTime,
NationalExhibitionProof: v.NationalExhibitionProof,
})
}
// 如果字段有画家名字或者笔名
var selectArtistInfo bool
var columns, columnStruct, columnDesc []string
for _, v := range exportDataResp.Data {
columns = append(columns, v.ColumnDesc)
columnStruct = append(columnStruct, v.StructName)
columnDesc = append(columnDesc, v.ColumnDesc)
if v.StructName == "ArtistName" || v.StructName == "PenName" {
selectArtistInfo = true
}
}
fmt.Println("1")
//var exportData []ArtworkPreviewExport
//copier.Copy(&exportData, result)
var artistUuids []string
for k, _ := range result {
//result[k].ArtistName = req.ArtistName
//result[k].PenName = req.PenName
if selectArtistInfo {
artistUuids = append(artistUuids, result[k].ArtistUuid)
}
}
fmt.Println("2 更新画家信息")
if len(artistUuids) > 0 {
getInfoResp, errS := service.GrpcArtistImpl.ArtistData(context.Background(), &artist.ArtistDataRequest{Uids: artistUuids})
if errS != nil {
service.ResponseQuickMsg(c, e.Failed, errS.Error(), nil)
return
}
if getInfoResp.Data != nil && len(getInfoResp.Data) > 0 {
for k, v := range result {
for _, vv := range getInfoResp.Data {
if vv.ProfileInfo.Uid == v.ArtistUuid {
result[k].ArtistName = vv.ProfileInfo.Name
result[k].PenName = vv.ProfileInfo.PenName
}
}
}
}
}
fmt.Println("3")
var adminId uint64
if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
userInfo := mLoginInfoAny.(model.LoginInfo)
adminId = userInfo.ID
}
if req.ExportType == 1 {
fileName := fmt.Sprintf("%s%d%s", model.EXPORT_ARTISTARTWORK_FILENAME, adminId, model.EXCEL_FILE_SUFFIX)
_ = utils.CreateDirPath("./runtime")
filePath := fmt.Sprintf("./runtime/%s", fileName)
_ = excelData(c, result, columnStruct, columns, filePath)
exportUrl = fileName
} else {
exportUrl, err = RegroupArtworkDownloadData(result, columnStruct, columnDesc, adminId, model.DownloadFile, model.EXPORT_ARTISTARTWORK_FILE_FILENAME)
if err != nil {
service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
return
}
}
fmt.Println("4")
var httpType string
if config.IsHttps {
httpType = model.HttpsType
} else {
httpType = model.HttpType
}
exportUrl = fmt.Sprintf("%s%s/static/%s", httpType, c.Request.Host, exportUrl)
service.ResponseQuickMsg(c, e.Ok, "", &ExportData{ExportUrl: exportUrl})
return
}
func excelData(c *gin.Context, result []ArtworkPreviewResponse, columnStruct []string, columns []string, filePath string) (err error) {
data, _ := RegroupArtistInfoArtworkExcelData(result, columnStruct, nil)
_, _ = utils.ToExcelByType(columns, data, "slice", filePath)
return
}
func RegroupArtistInfoArtworkExcelData(sourceData []ArtworkPreviewResponse, columnStruct []string, tagInfo map[int32]string) (data []interface{}, err error) {
if len(sourceData) > 0 {
for _, v := range sourceData {
//vData, err := utils.SimpleStructField(v)
//fmt.Println(err)
vData := utils.StructToMap(v)
//查询标签信息
var temp []string
for _, keyName := range columnStruct {
//if strings.Count(allColumns, fmt.Sprintf("%s,", columnStruct[i])) > 0 {
// keyName := columnStruct[i]
columnVal := fmt.Sprintf("%v", vData[keyName])
// 如果是需要处理的字段 则特殊处理
switch keyName {
case "ArtworkType":
typeId, _ := strconv.Atoi(columnVal)
columnVal = model.ArtworkTypeMap[uint8(typeId)]
case "Insource":
typeId, _ := strconv.Atoi(columnVal)
columnVal = model.ArtworkInSource[uint8(typeId)]
case "NationalExhibition":
typeId, _ := strconv.Atoi(columnVal)
columnVal = model.NationalExhibitionMap[uint8(typeId)]
case "BaseAuditStatus":
typeId, _ := strconv.Atoi(columnVal)
columnVal = model.BaseAuditStatusMap[uint8(typeId)]
}
if columnVal == "<nil>" {
columnVal = ""
}
temp = append(temp, columnVal)
//}
}
data = append(data, &temp)
}
}
return
}
func RegroupArtworkDownloadData(sourceData []ArtworkPreviewResponse, columnStruct []string, columnDesc []string, adminId uint64, downloadType uint, downloadFileName string) (zipPath string, err error) {
var downloadDir string = fmt.Sprintf("%s/%s", "runtime/tmp/artworks", "download")
//var downloadPath = fmt.Sprintf("%s/%v", downloadDir, adminId)
var downloadPath = filepath.Join(downloadDir, fmt.Sprintf("%v", adminId))
var fileNum int32
if len(sourceData) > 0 {
var downloadImgPathArtwork string
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
for _, v := range sourceData {
//wg.Add(1)
//go func(v *artist.ExportArtistResponse_Info) {
//defer wg.Done()
var downloadHashPathArtwork = fmt.Sprintf("%s/%v", downloadPath, v.TfNum)
vData := utils.StructToMap(v)
//查询标签信息
for key, keyName := range columnStruct {
downloadImgPathArtwork = fmt.Sprintf("%s", downloadPath)
columnVal := fmt.Sprintf("%v", vData[keyName])
if columnVal != "" {
switch downloadType {
case model.DownloadFile:
if len(columnVal) > 8 && columnVal[:4] == "http" {
fileNum++
downloadImgPathArtwork = fmt.Sprintf("%s/%s", downloadImgPathArtwork, columnDesc[key])
_, _ = utils.SaveUrlFileDisk(columnVal, downloadImgPathArtwork, fmt.Sprintf("%v_%v%v", v.TfNum, v.ArtworkName, path.Ext(columnVal)))
}
case model.DownloadHash:
//downloadFileName = "画作物权hash"
if err = utils.CreateDirPath(downloadPath); err != nil {
zap.L().Error("SaveUrlFileDisk err ", zap.Error(err))
return
}
downloadHashPathArtwork = fmt.Sprintf("%s.txt", downloadHashPathArtwork)
file, err := os.OpenFile(downloadHashPathArtwork, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
return
}
defer file.Close()
wr := bufio.NewWriter(file)
_, _ = wr.WriteString(columnVal)
_ = wr.Flush()
fileNum++
}
}
}
}
}()
//要加入Excel 导出 画家的姓名 编号 画作名称
err = regroup(sourceData, downloadPath)
wg.Wait()
if fileNum == 0 {
err = errors.New(e.GetMsg(e.ERROR_NO_FILE))
return
}
fmt.Println(222222222, time.Now().Unix())
//zipFilepath := filepath.Join(downloadDir, fmt.Sprintf("%s%v.zip", downloadFileName, adminId))
zipFilepath := filepath.Join("runtime", fmt.Sprintf("%s%v.zip", downloadFileName, adminId))
//zipFilepath := fmt.Sprintf("%s/%s%v.zip", downloadDir, downloadFileName, adminId)
defer os.RemoveAll(downloadPath)
if err = utils.ZipFile(downloadPath, zipFilepath); err != nil {
logger.Errorf("utils.ZipFile err", err)
err = errors.New(e.GetMsg(e.ERROR_ZIP))
return
}
fmt.Println(333333333, time.Now().Unix())
zipPath = fmt.Sprintf("%s%v.zip", downloadFileName, adminId)
} else {
err = errors.New(e.GetMsg(e.NOTDATA))
return
}
return
}
func regroup(sourceData []ArtworkPreviewResponse, downloadPath string) (err error) {
artworkKy := map[string][]*model.ExportArtworkInfo{}
if len(sourceData) > 0 {
for _, v := range sourceData {
var temp model.ExportArtworkInfo
temp.ArtistUuid = v.ArtistUuid
temp.Uuid = v.ArtworkUid
temp.Tfnum = v.TfNum
//temp.Seqnum = v.se
temp.ArtworkName = v.ArtworkName
//temp.RealrightHash = v.RealrightHash
artworkKy[v.ArtistUuid] = append(artworkKy[v.ArtistUuid], &temp)
}
}
fmt.Println(artworkKy)
//_ = artistkyExcel(downloadPath, artworkKy)
fmt.Println(artworkKy)
return
}