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"
	"fmt"
	"strings"

	"github.com/fonchain/fonchain-artistinfo/cmd/internal/dao"
	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	"github.com/fonchain/fonchain-artistinfo/pb/artist"
	"github.com/fonchain/fonchain-artistinfo/pb/artistInfoArtwork"
	"github.com/fonchain/fonchain-artistinfo/pb/artistInfoUser"
	"github.com/fonchain/fonchain-artistinfo/pb/artwork_query"
	"github.com/fonchain/fonchain-artistinfo/pkg/m"
	"github.com/fonchain/fonchain-artistinfo/pkg/service"
	"github.com/fonchain/fonchain-artistinfo/pkg/util/stime"
	"google.golang.org/protobuf/types/known/emptypb"
)

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),
		BaseAuditStatus:       int32(data.BaseAuditStatus),
		BaseAuditMark:         data.BaseAuditMark,
		BaseAuditMark2:        data.BaseAuditMark2,
		SupplementAuditStatus: int32(data.SupplementAuditStatus),
		SupplementAuditMark:   data.SupplementAuditMark,
		SupplementAuditMark2:  data.SupplementAuditMark2,
		AuditFlowIndex:        int32(data.AuditFlowIndex),
		BaseEditable:          data.BaseEditable(),
		SupplementEditable:    data.SupplementEditable(),
	}
	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, req.LockTime)
	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)
	}
	fmt.Println("artworkUidList", artworkUidList)
	//查询画作预览列表
	previewListRes, err := service.ArtworkQueryImpl.ArtworkPreviewList(context.Background(), &artwork_query.ArtworkPreviewListRequest{
		Page:        1,
		PageSize:    -1,
		ArtworkUids: artworkUidList,
	})
	if err != nil {
		return nil, err
	}
	fmt.Println("previewListRes count", len(previewListRes.Data))
	var thisLockTime = ""
	var groupIndex = -1
	for _, v := range unlockArtworkList.Data {
		var newGroup bool
		if thisLockTime != v.LockTime {
			thisLockTime = v.LockTime
			newGroup = true
			groupIndex++
		} else {
			continue
		}
		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),
				BaseAuditStatus:       v.BaseAuditStatus,
				BaseAuditMark:         v.BaseAuditMark,
				BaseAuditMark2:        v.BaseAuditMark2,
				SupplementAuditStatus: v.SupplementAuditStatus,
				SupplementAuditMark:   v.SupplementAuditMark,
				SupplementAuditMark2:  v.SupplementAuditMark2,
				AuditFlowIndex:        v.AuditFlowIndex,
				CreatedAt:             v.CreatedAt,
				UpdatedAt:             v.UpdatedAt,
				DeletedAt:             v.DeletedAt,
			})
		}
	}
	fmt.Println("previewListRes count", len(previewListRes.Data))
	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) {
	if request.ArtworkUid != "" {
		err = dao.UpdateAuditStatus(request.ArtworkUid, request.AuditStatus, request.AuditMark, request.AuditMark2, request.FlowIndex)

	} else if request.ArtworkUids != nil && len(request.ArtworkUids) > 0 {
		err = dao.BatchUpdateAuditStatus(request.ArtworkUids, request.AuditStatus, request.AuditMark, request.AuditMark2, request.FlowIndex)
	} else {
		return nil, errors.New("画作uid不能为空")
	}
	return
}

// CheckArtworkEditable 检查画作的可编辑状态
// followIndex   2：基本信息审核 3补充信息审核
func (a ArtistInfoArtworkLogic) CheckArtworkEditable(request *artistInfoArtwork.ArtworkUidRequest, followIndex int) (res *artistInfoArtwork.CheckArtworkEditableResponse, err error) {
	res = &artistInfoArtwork.CheckArtworkEditableResponse{}
	lockDetail, err := dao.GetArtworkLockDetail(request.ArtworkUid)
	if err != nil {
		return nil, err
	}
	if followIndex == 2 {
		res.Editable = lockDetail.BaseEditable()
	} else if followIndex == 3 {
		res.Editable = lockDetail.SupplementEditable()
	}
	return
}
func (a ArtistInfoArtworkLogic) GenerateArtworkSupplementInfo(request *artistInfoArtwork.ArtworkUidsRequest) (*emptypb.Empty, error) {
	//更新画作流程
	err := dao.GenerateArtworkSupplementInfo(request.ArtworkUids)
	return nil, err
}

func (a ArtistInfoArtworkLogic) ArtworkStatic(request *artistInfoArtwork.ArtistArtworkStaticRequest) (res *artistInfoArtwork.ArtistArtworkStaticResponse, err error) {
	//查询画家宝中认证成功的用户
	userList, total, err := dao.GetViewUserList(&artistInfoUser.FindUsersRequest{
		// ArtistRealName: request.ArtistKeyWords,
		Keyword:  request.ArtistKeyWords,
		Page:     int32(request.Page),
		PageSize: int32(request.PageSize),
		IsArtist: true,
	})
	if err != nil {
		return nil, err
	}
	if len(userList) == 0 {
		return nil, nil
	}
	var artistUids []string
	for _, v := range userList {
		artistUids = append(artistUids, v.ArtistUid)
	}
	//查询对应的画家信息
	var gender int32 = -1
	if request.ArtistGender == 1 {
		gender = 0
	} else if request.ArtistGender == 2 {
		gender = 1
	}
	//查询匹配的画家数据列表
	artistList, err := service.GrpcArtistImpl.ArtistList(context.Background(), &artist.ArtistListRequest{
		// Keyword:  request.ArtistKeyWords,
		Page:     1,
		PageSize: -1,
		Gender:   gender,
		Uids:     artistUids, //直接搜会导致Count值不对，手动筛选
	})
	if err != nil {
		return nil, err
	}

	//查询这些画家审核通过的画作数据统计
	res = &artistInfoArtwork.ArtistArtworkStaticResponse{
		Page:     int64(artistList.Page),
		PageSize: int64(request.PageSize),
		Total:    total,
	}
	viewDatas, err := dao.PassedArtworkStatic(request, artistUids)
	if err != nil {
		return nil, err
	}
	for i, v := range viewDatas {
		var (
			penName            string
			stageName          string
			artworkTotal       int64
			rulerTotal         int64
			passedRulerTotal   int64
			passedArtworkTotal int64
		)
		//统计画家素有画作的总数和总平尺数
		artworkTotal, rulerTotal = dao.CountAllArtworkTotal(v.ArtistUid)
		//统计审核通过的画作总数和平尺总数
		passedArtworkTotal, passedRulerTotal = dao.CountArtworkTotalWhichAuditPassed(v.ArtistUid)
		//补充画家信息
		for _, artistData := range artistList.Data {
			if artistData.Uid == v.ArtistUid {
				penName = artistData.PenName
				stageName = artistData.StageName
			}
		}
		//补充画作信息
		res.Data = append(res.Data, &artistInfoArtwork.ArtistArtworkStaticStaticData{
			Idx:                int64(i + 1),
			IsLock:             v.IsLock,
			ArtistUid:          v.ArtistUid,
			LatestLockTime:     v.LatestLockTime,
			LatestUpdatedAt:    stime.TimeToString(v.LatestUpdatedAt, stime.Format_Normal_YMDhms),
			RealName:           v.RealName,
			PenName:            penName,
			StageName:          stageName,
			ArtworkTotal:       artworkTotal,
			RulerTotal:         rulerTotal,
			PassedRulerTotal:   passedRulerTotal,
			PassedArtworkTotal: passedArtworkTotal,
		})
	}
	return
}