360 lines
13 KiB
Go
360 lines
13 KiB
Go
// Package dao -----------------------------
|
|
// @file : artwork.go
|
|
// @author : JJXu
|
|
// @contact : wavingbear@163.com
|
|
// @time : 2023/2/24 18:23
|
|
// -------------------------------------------
|
|
package dao
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/fonchain/fonchain-artistinfo/cmd/model"
|
|
"github.com/fonchain/fonchain-artistinfo/pb/artistInfoArtwork"
|
|
"github.com/fonchain/fonchain-artistinfo/pb/artwork_query"
|
|
db "github.com/fonchain/fonchain-artistinfo/pkg/db"
|
|
"github.com/fonchain/fonchain-artistinfo/pkg/service"
|
|
"github.com/fonchain/fonchain-artistinfo/pkg/util/stime"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func CreateArtworkLockRecord(in *model.ArtworkLockRecord) error {
|
|
var data = model.ArtworkLockRecord{
|
|
ArtistUid: in.ArtistUid,
|
|
ArtworkUid: in.ArtworkUid,
|
|
Status: in.Status,
|
|
LockTime: in.LockTime,
|
|
}
|
|
return db.DB.Create(&data).Error
|
|
}
|
|
|
|
func UpdateArtworkLockRecord(in *model.ArtworkLockRecord) error {
|
|
var data = model.ArtworkLockRecord{
|
|
ArtistUid: in.ArtistUid,
|
|
ArtworkUid: in.ArtworkUid,
|
|
Status: in.Status,
|
|
LockTime: in.LockTime,
|
|
BaseAuditStatus: in.BaseAuditStatus,
|
|
BaseAuditMark: in.BaseAuditMark,
|
|
BaseAuditMark2: in.BaseAuditMark2,
|
|
SupplementAuditStatus: in.SupplementAuditStatus,
|
|
SupplementAuditMark: in.SupplementAuditMark,
|
|
SupplementAuditMark2: in.SupplementAuditMark2,
|
|
}
|
|
var thisData model.ArtworkLockRecord
|
|
err := db.DB.Where("artist_uid = ?", in.ArtworkUid).First(&thisData).Error
|
|
if err != nil {
|
|
if err != gorm.ErrRecordNotFound {
|
|
return errors.New("画作数据未找到")
|
|
} else {
|
|
return err
|
|
}
|
|
}
|
|
data.Model = model.Model{
|
|
ID: thisData.ID,
|
|
CreatedAt: thisData.CreatedAt,
|
|
}
|
|
return db.DB.Updates(&data).Error
|
|
}
|
|
|
|
func DeletedArtworkLockRecord(artworkUid ...string) error {
|
|
if len(artworkUid) == 0 {
|
|
return nil
|
|
} else if len(artworkUid) == 1 {
|
|
return db.DB.Where("artwork_uid = ? AND status != 2 ", artworkUid[0]).Delete(&model.ArtworkLockRecord{}).Error
|
|
} else {
|
|
return db.DB.Where("artwork_uid in ? AND status != 2 ", artworkUid).Delete(&model.ArtworkLockRecord{}).Error
|
|
}
|
|
}
|
|
|
|
func BatchLockArtworks(artistUid string, lockTime string) error {
|
|
var artworkUids []string
|
|
db.DB.Model(model.ArtworkLockRecord{}).
|
|
Where("status = 1 AND lock_time=''").Where(" artist_uid = ?", artistUid).
|
|
Pluck("artwork_uid", &artworkUids)
|
|
if artworkUids == nil {
|
|
return nil
|
|
}
|
|
if lockTime == "" {
|
|
lockTime = stime.TimeToString(time.Now(), stime.Format_Normal_YMDhms)
|
|
}
|
|
var updateMap = map[string]any{
|
|
"status": 2,
|
|
"lock_time": lockTime,
|
|
"base_audit_status": model.AuditType_Pending, //基本数据审批
|
|
"audit_flow_index": 2, //进入基本信息审批流程
|
|
}
|
|
return db.DB.Model(model.ArtworkLockRecord{}).Where("artwork_uid in ?", artworkUids).Updates(&updateMap).Error
|
|
}
|
|
|
|
func BatchUnlockArtworks(artistUid string) error {
|
|
//var artworkUids []string
|
|
// 查询用户当前锁定的时间点
|
|
//var nowLockTime string
|
|
//err := db.DB.Model(model.ArtworkLockRecord{}).Select("MAX(lock_time)").Where("artist_uid = %s AND lock_time !='' AND STATUS =2", artistUid).Scan(&nowLockTime).Error
|
|
//if err != nil {
|
|
// return err
|
|
//}
|
|
////查询此时间节点内的所有画作
|
|
//db.DB.Model(model.ArtworkLockRecord{}).
|
|
// //Where("lock_time = (SELECT MAX(lock_time) FROM artwork_lock_record where artist_uid = %s AND lock_time !='' AND STATUS =2)", artistUid).
|
|
// //Joins("LEFT JOIN (lock_time = (select max(lock_time) form artwork_lock_record WHERE artist_uid = ?) lt", artistUid).
|
|
// //Where(fmt.Sprintf("lock_time = (select max(lock_time) form artwork_lock_record WHERE artist_uid = %s)", artistUid)).
|
|
// Where("status = 2").
|
|
// Pluck("artwork_uid", &artworkUids)
|
|
//if artworkUids == nil {
|
|
// return nil
|
|
//}
|
|
return db.DB.Model(model.ArtworkLockRecord{}).Where("artist_uid = ? AND status =2 AND lock_time !=''", artistUid).Update("status", 3).Error
|
|
}
|
|
|
|
func GetArtworkLockDetail(artworkUid string) (data model.ArtworkLockRecord, err error) {
|
|
err = db.DB.Where("artwork_uid = ?", artworkUid).First(&data).Error
|
|
return
|
|
}
|
|
|
|
func GetArtworkLockRecords(req *artistInfoArtwork.GetArtworkLockRecordsRequest) (resp *artistInfoArtwork.ArtworkLockList, err error) {
|
|
var (
|
|
datas = []model.ArtworkLockRecord{}
|
|
tx = db.DB.Model(model.ArtworkLockRecord{}).Order("lock_time desc")
|
|
)
|
|
if req.Page == 0 || req.PageSize == 0 {
|
|
req.Page = 1
|
|
req.PageSize = -1
|
|
}
|
|
resp = &artistInfoArtwork.ArtworkLockList{}
|
|
if req.ArtistUid != "" {
|
|
tx = tx.Where("artist_uid = ?", req.ArtistUid)
|
|
}
|
|
switch req.QueryType {
|
|
case artistInfoArtwork.ArtworkQueryMode_NowPreSaveArtwork: //当前暂存的画作
|
|
tx = tx.Where("status = 1")
|
|
case artistInfoArtwork.ArtworkQueryMode_NowLockedArtwork: //当前已锁定的画作
|
|
tx = tx.Where("status = 2")
|
|
case artistInfoArtwork.ArtworkQueryMode_NowPreSaveAndLocked: //当前暂存和已锁定的画作（也就是用户端画作管理中的数据）
|
|
tx = tx.Where("status =1 OR status =2")
|
|
case artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfBase: //当前处于基本信息审批阶段的画作(包括进入其它流程的画作)
|
|
tx = tx.Where("status = 1 OR status=2") // 现要求暂存和锁定的画作都能进行审批和展示
|
|
case artistInfoArtwork.ArtworkQueryMode_NowAuditFlowOfSupplementing: //当前处于补充信息审批阶段的画作
|
|
tx = tx.Where("status =2 AND audit_flow_index = 3")
|
|
case artistInfoArtwork.ArtworkQueryMode_AllUnlockArtwork: //所有已解锁的画作(历史画作)
|
|
tx = tx.Where("status = 3").Order("lock_time desc")
|
|
//case artistInfoArtwork.ArtworkQueryMode_AllHistoryArtwork: //所有历史画作
|
|
// tx = tx.Where("status > 1")
|
|
case artistInfoArtwork.ArtworkQueryMode_AllAuditPassArtwork: //所有审核通过的画作
|
|
tx = tx.Where("supplement_audit_status = 4").Order("lock_time desc")
|
|
}
|
|
if req.BaseAuditStatus != 0 {
|
|
if req.BaseAuditStatus == 2 {
|
|
//现要求暂存的画作也支持在待审核列表展示和审批
|
|
tx = tx.Where("base_audit_status = ? OR base_audit_status =1", req.BaseAuditStatus)
|
|
} else if req.BaseAuditStatus != 1 { //排除暂存状态,需求修改后，这个字段的暂存状态无法作为判断条件了
|
|
tx = tx.Where("base_audit_status = ?", req.BaseAuditStatus)
|
|
}
|
|
|
|
}
|
|
if req.SupplementAuditStatus != 0 {
|
|
tx = tx.Where("supplement_audit_status = ?", req.SupplementAuditStatus)
|
|
}
|
|
if len(req.ArtworkUids) > 0 {
|
|
tx = tx.Where("artwork_uid in ?", req.ArtworkUids)
|
|
}
|
|
err = tx.Count(&resp.Total).Scopes(db.Pagination(req.Page, req.PageSize)).Find(&datas).Error
|
|
for _, v := range datas {
|
|
resp.Data = append(resp.Data, &artistInfoArtwork.ArtistLockInfo{
|
|
ArtistUid: v.ArtistUid,
|
|
ArtworkUid: v.ArtworkUid,
|
|
Status: v.Status,
|
|
LockTime: v.LockTime,
|
|
BaseAuditStatus: int32(v.BaseAuditStatus),
|
|
BaseAuditMark: v.BaseAuditMark,
|
|
BaseAuditMark2: v.BaseAuditMark2,
|
|
SupplementAuditStatus: int32(v.SupplementAuditStatus),
|
|
SupplementAuditMark: v.SupplementAuditMark,
|
|
SupplementAuditMark2: v.SupplementAuditMark2,
|
|
AuditFlowIndex: int32(v.AuditFlowIndex),
|
|
CreatedAt: v.CreatedAt.Unix(),
|
|
UpdatedAt: v.UpdatedAt.Unix(),
|
|
DeletedAt: int64(v.DeletedAt),
|
|
})
|
|
}
|
|
|
|
resp.Page = req.Page
|
|
if req.PageSize == -1 {
|
|
resp.PageSize = int64(len(datas))
|
|
} else {
|
|
resp.PageSize = req.PageSize
|
|
}
|
|
return
|
|
}
|
|
func HasBeenLocked(artistUid string) bool {
|
|
//检查是否已经被锁定
|
|
var hasLocked int64
|
|
db.DB.Model(model.ArtworkLockRecord{}).Where("artist_uid = ? AND status = 2", artistUid).Count(&hasLocked)
|
|
if hasLocked > 0 {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// UpdateAuditStatus 更新审批状态
|
|
// flowIndex 2=基本信息审批 3=补充信息审批
|
|
func UpdateAuditStatus(artworkUid string, auditStatus int64, remark1 string, remark2 string, flowIndex int64) error {
|
|
var thisData model.ArtworkLockRecord
|
|
err := db.DB.Model(model.ArtworkLockRecord{}).Where("artwork_uid = ?", artworkUid).First(&thisData).Error
|
|
if err != nil {
|
|
if err != gorm.ErrRecordNotFound {
|
|
return errors.New("画作数据未找到")
|
|
} else {
|
|
return err
|
|
}
|
|
}
|
|
switch flowIndex {
|
|
case 2:
|
|
thisData.BaseAuditStatus = model.AuditStatus(auditStatus)
|
|
thisData.BaseAuditMark = remark1
|
|
thisData.BaseAuditMark2 = remark2
|
|
case 3:
|
|
thisData.SupplementAuditStatus = model.AuditStatus(auditStatus)
|
|
thisData.SupplementAuditMark = remark1
|
|
thisData.SupplementAuditMark2 = remark2
|
|
}
|
|
return db.DB.Save(&thisData).Error
|
|
}
|
|
|
|
func BatchUpdateAuditStatus(artworkUids []string, auditStatus int64, remark1 string, remark2 string, flowIndex int64) error {
|
|
for _, uid := range artworkUids {
|
|
if err := UpdateAuditStatus(uid, auditStatus, remark1, remark2, flowIndex); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GenerateArtworkSupplementInfo(artworkUids []string) error {
|
|
var datas = []model.ArtworkLockRecord{}
|
|
db.DB.Where("artwork_uid in ?", artworkUids).Find(&datas)
|
|
for _, v := range datas {
|
|
if v.BaseAuditStatus != 4 {
|
|
return errors.New("存在基本信息未审批通过的画作,操作取消!")
|
|
}
|
|
}
|
|
var updateData = map[string]any{
|
|
"audit_flow_index": 3,
|
|
"supplement_audit_status": 5,
|
|
}
|
|
return db.DB.Model(model.ArtworkLockRecord{}).Where("artwork_uid in ?", artworkUids).Updates(&updateData).Error
|
|
}
|
|
|
|
func PassedArtworkStatic(request *artistInfoArtwork.ArtistArtworkStaticRequest, uids []string) (res []model.ViewPassedArtworkStatic, err error) {
|
|
res = []model.ViewPassedArtworkStatic{}
|
|
var tx = db.DB.Model(&model.ViewPassedArtworkStatic{})
|
|
err = tx.Where("artist_uid in ?", uids).Scopes(db.Pagination(request.Page, request.PageSize)).Find(&res).Error
|
|
return
|
|
}
|
|
|
|
// CountArtworkTotalWhichAuditPassed 单个统计画家已通过的画作数量和已通过的平尺数
|
|
func CountArtworkTotalWhichAuditPassed(artistUid string) (rulerPassedTotal int64, artworkPassedCount int64) {
|
|
artworkList, err := GetArtworkLockRecords(&artistInfoArtwork.GetArtworkLockRecordsRequest{
|
|
ArtistUid: artistUid,
|
|
QueryType: artistInfoArtwork.ArtworkQueryMode_AllAuditPassArtwork,
|
|
})
|
|
if err != nil {
|
|
fmt.Println("service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords Error:", err.Error())
|
|
return 0, 0
|
|
}
|
|
if len(artworkList.Data) == 0 {
|
|
fmt.Println("service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords :画作数量为0")
|
|
return 0, 0
|
|
}
|
|
var artworkUids = []string{}
|
|
for _, v := range artworkList.Data {
|
|
artworkUids = append(artworkUids, v.ArtworkUid)
|
|
}
|
|
//搜索画作信息
|
|
var (
|
|
defultPageSize int32 = 500
|
|
nowPageIndex int32
|
|
artworkNumber int32
|
|
artworkRulerTotal int32
|
|
artworkTotal int32
|
|
)
|
|
for {
|
|
nowPageIndex++
|
|
res, err := service.ArtworkQueryImpl.ArtworkPreviewList(context.Background(), &artwork_query.ArtworkPreviewListRequest{
|
|
Page: nowPageIndex,
|
|
PageSize: defultPageSize,
|
|
ArtistUid: artistUid,
|
|
ArtworkUids: artworkUids,
|
|
})
|
|
if err != nil {
|
|
fmt.Println(err.Error())
|
|
return 0, 0
|
|
}
|
|
if artworkNumber == 0 {
|
|
artworkNumber = res.Page.Total
|
|
artworkTotal += res.Page.Total
|
|
}
|
|
artworkNumber -= defultPageSize
|
|
for _, v := range res.Data {
|
|
artworkRulerTotal += v.Ruler
|
|
}
|
|
if artworkNumber <= 0 {
|
|
break
|
|
}
|
|
}
|
|
return int64(artworkRulerTotal), int64(artworkTotal)
|
|
}
|
|
|
|
// CountAllArtworkTotal 单个统计画家所有的画作数量和平尺数
|
|
func CountAllArtworkTotal(artistUid string) (artworkTotal int64, artworkRulerTotal int64) {
|
|
//查询画家宝中的画作总数
|
|
var artworkUids []string
|
|
db.DB.Model(model.ArtworkLockRecord{}).Where("artist_uid = ?", artistUid).Pluck("artwork_uid", &artworkUids)
|
|
artworkTotal = int64(len(artworkUids))
|
|
//查询此画家的所有画作
|
|
artworkList, err := service.ArtworkQueryImpl.ArtworkPreviewList(context.Background(), &artwork_query.ArtworkPreviewListRequest{
|
|
Page: 1,
|
|
PageSize: -1,
|
|
ArtistUid: artistUid,
|
|
ArtworkUids: artworkUids,
|
|
})
|
|
if err != nil {
|
|
fmt.Println("画作列表查询失败", err.Error())
|
|
return 0, 0
|
|
}
|
|
for _, v := range artworkList.Data {
|
|
artworkRulerTotal += int64(v.Ruler)
|
|
}
|
|
return artworkTotal, artworkRulerTotal
|
|
}
|
|
|
|
func UpdateArtworkExtData(request *artistInfoArtwork.ArtworkExtData) (err error) {
|
|
if request.ArtworkUid == "" {
|
|
return errors.New("画作uid不能为空")
|
|
}
|
|
err = db.DB.Model(model.ArtworkLockRecord{}).Where("artwork_uid = ?", request.ArtworkUid).Update("national_exhibition", request.NationalExhibition).Error
|
|
return
|
|
}
|
|
func GetArtworkExtDatas(request *artistInfoArtwork.GetArtworkExtDataRequest) (data *artistInfoArtwork.GetArtworkExtDataResponse, err error) {
|
|
data = &artistInfoArtwork.GetArtworkExtDataResponse{
|
|
Data: []*artistInfoArtwork.ArtworkExtData{},
|
|
}
|
|
if request.ArtworkUid != "" {
|
|
request.ArtworkUids = append(request.ArtworkUids, request.ArtworkUid)
|
|
}
|
|
for _, v := range request.ArtworkUids {
|
|
var artworkData = artistInfoArtwork.ArtworkExtData{ArtworkUid: v}
|
|
var findData model.ArtworkLockRecord
|
|
if err = db.DB.Where("artwork_uid = ?", v).Find(&findData).Error; err != nil {
|
|
return
|
|
}
|
|
artworkData.NationalExhibition = int64(findData.NationalExhibition)
|
|
data.Data = append(data.Data, &artworkData)
|
|
}
|
|
return
|
|
}
|