fonchain-artistinfo/cmd/internal/logic/artistinfo_artwork.go

// Package logic -----------------------------
// @file      : artistinfo_artwork.go
// @author    : JJXu
// @contact   : wavingbear@163.com
// @time      : 2023/2/24 22:26
// -------------------------------------------
package logic

import (
	"context"
	"errors"
	"github.com/fonchain/fonchain-artistinfo/cmd/internal/dao"
	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	"github.com/fonchain/fonchain-artistinfo/pb/artistInfoArtwork"
	"github.com/fonchain/fonchain-artistinfo/pb/artwork_query"
	"github.com/fonchain/fonchain-artistinfo/pkg/m"
	"github.com/fonchain/fonchain-artistinfo/pkg/service"
	"strings"
)

type IArtistInfoArtwork interface {
	GetArtworkLockDetail(request *artistInfoArtwork.GetArtworkLockDetailRequest) (res *artistInfoArtwork.ArtistLockInfo, err error)
	CreateArtworkLockRecord(req *artistInfoArtwork.CreateArtworkLockRecordReq) (res *artistInfoArtwork.ArtworkCommonNoParams, err error)
	ArtworkLockAction(req *artistInfoArtwork.ArtworkLockActionRequest) (res *artistInfoArtwork.ArtworkCommonNoParams, err error)
	GetArtworkLockRecords(req *artistInfoArtwork.GetArtworkLockRecordsRequest) (res *artistInfoArtwork.ArtworkLockList, err error)
	GetArtworkLockHistoryGroup(request *artistInfoArtwork.GetArtworkLockHistoryRequest) (res *artistInfoArtwork.GetArtworkLockHistoryResponse, err error)
	DeleteArtworkRecord(req *artistInfoArtwork.DeleteArtworkRecordRequest) (res *artistInfoArtwork.ArtworkCommonNoParams, err error)
}

var _ IArtistInfoArtwork = new(ArtistInfoArtworkLogic)

type ArtistInfoArtworkLogic struct{}

func (a ArtistInfoArtworkLogic) GetArtworkLockDetail(request *artistInfoArtwork.GetArtworkLockDetailRequest) (res *artistInfoArtwork.ArtistLockInfo, err error) {
	data, err := dao.GetArtworkLockDetail(request.ArtworkUid)
	if err != nil {
		return
	}
	res = &artistInfoArtwork.ArtistLockInfo{
		ArtistUid:  data.ArtistUid,
		ArtworkUid: data.ArtworkUid,
		Status:     data.Status,
		LockTime:   data.LockTime,
		CreatedAt:  data.CreatedAt.Unix(),
		UpdatedAt:  data.UpdatedAt.Unix(),
		DeletedAt:  int64(data.DeletedAt),
	}
	return
}
func (ArtistInfoArtworkLogic) CreateArtworkLockRecord(req *artistInfoArtwork.CreateArtworkLockRecordReq) (res *artistInfoArtwork.ArtworkCommonNoParams, err error) {
	err = dao.CreateArtworkLockRecord(&model.ArtworkLockRecord{
		ArtistUid:  req.ArtistUid,
		ArtworkUid: req.ArtworkUid,
		Status:     req.Status,
		LockTime:   req.LockTime,
	})
	return
}

func (ArtistInfoArtworkLogic) ArtworkLockAction(req *artistInfoArtwork.ArtworkLockActionRequest) (res *artistInfoArtwork.ArtworkCommonNoParams, err error) {
	switch req.Lock {
	case 2:
		err = dao.BatchLockArtworks(req.ArtistUid)
	case 3:
		err = dao.BatchUnlockArtworks(req.ArtistUid)
	default:
		err = errors.New("lock值错误")
	}
	return
}

func (ArtistInfoArtworkLogic) GetArtworkLockRecords(req *artistInfoArtwork.GetArtworkLockRecordsRequest) (res *artistInfoArtwork.ArtworkLockList, err error) {
	res = &artistInfoArtwork.ArtworkLockList{}
	res, err = dao.GetArtworkLockRecords(req)
	return
}

func (a ArtistInfoArtworkLogic) GetArtworkLockHistoryGroup(request *artistInfoArtwork.GetArtworkLockHistoryRequest) (res *artistInfoArtwork.GetArtworkLockHistoryResponse, err error) {
	// 查询解锁的画作
	unlockArtworkList, err := dao.GetArtworkLockRecords(&artistInfoArtwork.GetArtworkLockRecordsRequest{
		ArtistUid: request.ArtistUid,
		QueryType: artistInfoArtwork.ArtworkQueryMode_AllUnlockArtwork,
	})
	if err != nil {
		return nil, err
	}
	if len(unlockArtworkList.Data) == 0 {
		return nil, nil
	}
	res = &artistInfoArtwork.GetArtworkLockHistoryResponse{}
	var artworkUidList []string
	for _, v := range unlockArtworkList.Data {
		artworkUidList = append(artworkUidList, v.ArtworkUid)
	}
	//查询画作预览列表
	previewListRes, err := service.ArtworkQueryImpl.ArtworkPreviewList(context.Background(), &artwork_query.ArtworkPreviewListRequest{
		Page:        1,
		PageSize:    -1,
		ArtworkUids: artworkUidList,
	})
	if err != nil {
		return nil, err
	}
	var thisLockTime = ""
	var groupIndex = -1
	for _, v := range unlockArtworkList.Data {
		var newGroup bool
		if thisLockTime != v.LockTime {
			thisLockTime = v.LockTime
			newGroup = true
			groupIndex++
		}
		if newGroup {
			res.GroupList = append(res.GroupList, &artistInfoArtwork.ArtworkLockRecord{
				LockGroup: v.LockTime,
				DataList:  []*artistInfoArtwork.ArtworkPreviewInfo{},
			})
		}
		for _, artwork := range previewListRes.Data {
			res.GroupList[groupIndex].DataList = append(res.GroupList[groupIndex].DataList, &artistInfoArtwork.ArtworkPreviewInfo{
				ArtistUuid:     artwork.ArtistUuid,
				ArtworkName:    artwork.ArtworkName,
				Length:         artwork.Length,
				Width:          artwork.Width,
				Ruler:          artwork.Ruler,
				CreatedAddress: strings.Split(artwork.CreatedAddress, "，"),
				ArtistPhoto:    artwork.ArtistPhoto,
				HdPic:          artwork.HdPic,
				ArtworkUid:     artwork.ArtworkUid,
				CreatedDate:    artwork.CreateDate,
				LockStatus:     int32(v.Status),
				AuditStatus:    v.AuditStatus,
				AuditMark:      v.AuditMark,
				AuditMark2:     v.AuditMark2,
				CreatedAt:      v.CreatedAt,
				UpdatedAt:      v.UpdatedAt,
				DeletedAt:      v.DeletedAt,
			})
		}
	}
	return
}

func (ArtistInfoArtworkLogic) DeleteArtworkRecord(req *artistInfoArtwork.DeleteArtworkRecordRequest) (res *artistInfoArtwork.ArtworkCommonNoParams, err error) {
	//检查画作锁定情况
	for _, v := range req.ArtworkUids {
		if dao.HasBeenLocked(v) {
			return nil, errors.New(m.ERROR_ISLOCK)
		}
	}
	err = dao.DeletedArtworkLockRecord(req.ArtworkUids...)
	return
}

func (a ArtistInfoArtworkLogic) UpdateArtworkAuditStatus(request *artistInfoArtwork.UpdateArtworkAuditStatusRequest) (res *artistInfoArtwork.ArtworkCommonNoParams, err error) {
	err = dao.UpdateAuditStatus(request.ArtworkUid, request.AuditStatus, request.AuditMark, request.AuditMark2)
	return
}