358 lines
10 KiB
Go
358 lines
10 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
|
|
"go-common/app/admin/main/dm/model"
|
|
accountApi "go-common/app/service/main/account/api"
|
|
"go-common/app/service/main/archive/api"
|
|
archiveMdl "go-common/app/service/main/archive/model/archive"
|
|
"go-common/library/ecode"
|
|
"go-common/library/log"
|
|
"go-common/library/sync/errgroup"
|
|
)
|
|
|
|
const (
|
|
_workFlowSubtitleBid = 14
|
|
)
|
|
|
|
// SubtitleLanList .
|
|
func (s *Service) SubtitleLanList(c context.Context) (res map[int64]string, err error) {
|
|
var (
|
|
sLans []*model.SubtitleLan
|
|
)
|
|
if sLans, err = s.dao.SubtitleLans(c); err != nil {
|
|
return
|
|
}
|
|
res = make(map[int64]string)
|
|
for _, sLan := range sLans {
|
|
res[sLan.Code] = sLan.DocZh
|
|
}
|
|
return
|
|
}
|
|
|
|
// WorkFlowEditSubtitle .
|
|
func (s *Service) WorkFlowEditSubtitle(c context.Context, arg *model.WorkFlowSubtitleArg) (err error) {
|
|
var (
|
|
argEdit *model.EditSubtitleArg
|
|
status model.SubtitleStatus
|
|
)
|
|
if arg == nil || arg.Object == nil || len(arg.Object.Ids) == 0 || len(arg.Targets) == 0 {
|
|
err = ecode.RequestErr
|
|
return
|
|
}
|
|
switch arg.Object.DisposeMode {
|
|
case model.WorkFlowSubtitleDisposeManagerBack:
|
|
status = model.SubtitleStatusManagerBack
|
|
case model.WorkFlowSubtitleDisposeManagerDelete:
|
|
status = model.SubtitleStatusManagerRemove
|
|
default:
|
|
return
|
|
}
|
|
for _, target := range arg.Targets {
|
|
if target == nil {
|
|
continue
|
|
}
|
|
argEdit = &model.EditSubtitleArg{
|
|
Oid: target.Oid,
|
|
SubtileID: target.Eid,
|
|
Status: uint8(status),
|
|
}
|
|
// 容错
|
|
if argEdit.Oid == 0 {
|
|
continue
|
|
}
|
|
if err = s.editSubtitle(c, argEdit, false); err != nil {
|
|
log.Error("s.EditSubtitle(arg:%+v),error(%v)", argEdit, err)
|
|
err = nil // ignore error
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// EditSubtitle .
|
|
func (s *Service) EditSubtitle(c context.Context, arg *model.EditSubtitleArg) (err error) {
|
|
return s.editSubtitle(c, arg, true)
|
|
}
|
|
|
|
func (s *Service) editSubtitle(c context.Context, arg *model.EditSubtitleArg, removeWorkFlow bool) (err error) {
|
|
// 更新表
|
|
var (
|
|
subtitle *model.Subtitle
|
|
argStatus = model.SubtitleStatus(arg.Status)
|
|
subtitleLans model.SubtitleLans
|
|
sLans []*model.SubtitleLan
|
|
err1 error
|
|
lanDoc string
|
|
archiveInfo *api.Arc
|
|
archiveName string
|
|
)
|
|
if subtitle, err = s.dao.GetSubtitle(c, arg.Oid, arg.SubtileID); err != nil {
|
|
log.Error("params(oid:%v,subtitleID:%v),error(%v)", arg.Oid, arg.SubtileID, err)
|
|
return
|
|
}
|
|
if subtitle == nil {
|
|
err = ecode.NothingFound
|
|
return
|
|
}
|
|
if argStatus == subtitle.Status {
|
|
err = ecode.SubtitleStatusUnValid
|
|
return
|
|
}
|
|
if subtitle.Status != model.SubtitleStatusPublish && argStatus != model.SubtitleStatusPublish {
|
|
arg.NotifyUpper = false
|
|
}
|
|
switch argStatus {
|
|
case model.SubtitleStatusDraft, model.SubtitleStatusToAudit,
|
|
model.SubtitleStatusAuditBack, model.SubtitleStatusRemove,
|
|
model.SubtitleStatusPublish, model.SubtitleStatusManagerBack,
|
|
model.SubtitleStatusManagerRemove:
|
|
default:
|
|
err = ecode.SubtitleStatusUnValid
|
|
return
|
|
}
|
|
if err = s.changeSubtitleStatus(c, subtitle, argStatus); err != nil {
|
|
log.Error("params(subtitle:%+v,status:%v),error(%v)", subtitle, arg.Status, err)
|
|
return
|
|
}
|
|
if arg.NotifyAuthor || arg.NotifyUpper {
|
|
if sLans, err1 = s.dao.SubtitleLans(c); err1 == nil {
|
|
subtitleLans = model.SubtitleLans(sLans)
|
|
}
|
|
_, lanDoc = subtitleLans.GetByID(int64(subtitle.Lan))
|
|
if archiveInfo, err1 = s.arcRPC.Archive3(c, &archiveMdl.ArgAid2{
|
|
Aid: subtitle.Aid,
|
|
}); err1 != nil {
|
|
log.Error("s.arcRPC.Archive3(aid:%v),error(%v)", subtitle.Aid, err1)
|
|
err1 = nil
|
|
} else {
|
|
archiveName = archiveInfo.Title
|
|
}
|
|
}
|
|
if arg.NotifyAuthor {
|
|
argUser := &model.NotifySubtitleUser{
|
|
Mid: subtitle.Mid,
|
|
Aid: subtitle.Aid,
|
|
Oid: subtitle.Oid,
|
|
SubtitleID: subtitle.ID,
|
|
ArchiveName: archiveName,
|
|
LanDoc: lanDoc,
|
|
Status: model.StatusContent[uint8(subtitle.Status)],
|
|
}
|
|
if err1 = s.dao.SendMsgToSubtitleUser(c, argUser); err1 != nil {
|
|
log.Error("SendMsgToSubtitleUser(argUser:%+v),error(%v)", argUser, err1)
|
|
err1 = nil
|
|
}
|
|
}
|
|
if arg.NotifyUpper {
|
|
var (
|
|
accountInfo *accountApi.InfoReply
|
|
authorName string
|
|
)
|
|
if accountInfo, err1 = s.accountRPC.Info3(c, &accountApi.MidReq{
|
|
Mid: subtitle.Mid,
|
|
}); err1 != nil {
|
|
log.Error("s.accRPC.Info3(mid:%v),error(%v)", subtitle.Mid, err1)
|
|
err1 = nil
|
|
} else {
|
|
authorName = accountInfo.GetInfo().GetName()
|
|
}
|
|
argUp := &model.NotifySubtitleUp{
|
|
Mid: subtitle.UpMid,
|
|
AuthorID: subtitle.Mid,
|
|
AuthorName: authorName,
|
|
Aid: subtitle.Aid,
|
|
Oid: subtitle.Oid,
|
|
SubtitleID: subtitle.ID,
|
|
ArchiveName: archiveName,
|
|
LanDoc: lanDoc,
|
|
Status: model.StatusContent[uint8(subtitle.Status)],
|
|
}
|
|
if err1 = s.dao.SendMsgToSubtitleUp(c, argUp); err1 != nil {
|
|
log.Error("SendMsgToSubtitleUp(argUp:%+v),error(%v)", argUp, err1)
|
|
err1 = nil
|
|
}
|
|
}
|
|
if removeWorkFlow && (argStatus == model.SubtitleStatusRemove || argStatus == model.SubtitleStatusManagerRemove) {
|
|
if err1 := s.dao.WorkFlowAppealDelete(c, _workFlowSubtitleBid, subtitle.Oid, subtitle.ID); err1 != nil {
|
|
log.Error("s.dao.WorkFlowAppealDelete(oid:%v,subtitleID:%v),error(%v)", subtitle.Oid, subtitle.ID, err1)
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// TODO 确认状态扭转
|
|
func (s *Service) changeSubtitleStatus(c context.Context, subtitle *model.Subtitle, status model.SubtitleStatus) (err error) {
|
|
var (
|
|
sc *model.SubtitleContext
|
|
hasDraft bool
|
|
)
|
|
sc = &model.SubtitleContext{}
|
|
sc.Build(subtitle.Status, status)
|
|
subtitle.PubTime = time.Now().Unix()
|
|
if sc.CheckHasDraft {
|
|
if hasDraft, err = s.CheckHasDraft(c, subtitle); err != nil {
|
|
log.Error("params(subtitle:%+v),error(%v)", subtitle, err)
|
|
return
|
|
}
|
|
if hasDraft {
|
|
err = ecode.SubtitleAlreadyHasDraft
|
|
return
|
|
}
|
|
subtitle.PubTime = 0
|
|
}
|
|
subtitle.Status = status
|
|
if sc.RebuildPub {
|
|
if err = s.RebuildSubtitle(c, subtitle); err != nil {
|
|
log.Error("RebuildSubtitle.params(subtitle:%+v),error(%v)", subtitle, err)
|
|
return
|
|
}
|
|
} else {
|
|
if err = s.dao.UpdateSubtitle(c, subtitle); err != nil {
|
|
log.Error("UpdateSubtitle.params(subtitle:%+v),error(%v)", subtitle, err)
|
|
return
|
|
}
|
|
}
|
|
if sc.DraftCache {
|
|
s.dao.DelSubtitleDraftCache(c, subtitle.Oid, subtitle.Type, subtitle.Mid, subtitle.Lan)
|
|
}
|
|
if sc.SubtitleCache {
|
|
s.dao.DelSubtitleCache(c, subtitle.Oid, subtitle.ID)
|
|
}
|
|
if sc.RebuildPub {
|
|
s.dao.DelVideoSubtitleCache(c, subtitle.Oid, subtitle.Type)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SubtitleList .
|
|
func (s *Service) SubtitleList(c context.Context, arg *model.SubtitleArg) (res *model.SubtitleList, err error) {
|
|
var (
|
|
searchResult *model.SearchSubtitleResult
|
|
oidSubtitleIds map[int64][]int64
|
|
eg errgroup.Group
|
|
lock sync.Mutex
|
|
subtitleMap map[string]*model.Subtitle
|
|
searchSubtitles []*model.SearchSubtitle
|
|
searchSubtitle *model.SearchSubtitle
|
|
subtitle *model.Subtitle
|
|
ok bool
|
|
aids []int64
|
|
aidMap map[int64]struct{}
|
|
archives map[int64]*api.Arc
|
|
archive *api.Arc
|
|
archiveVideo *api.Page
|
|
subtitleLans model.SubtitleLans
|
|
searchArg *model.SubtitleSearchArg
|
|
)
|
|
if arg.Ps > 100 {
|
|
err = ecode.RequestErr
|
|
return
|
|
}
|
|
key := func(oid, subtitleID int64) string {
|
|
return fmt.Sprintf("%d_%d", oid, subtitleID)
|
|
}
|
|
if sLans, err1 := s.dao.SubtitleLans(c); err1 == nil {
|
|
subtitleLans = model.SubtitleLans(sLans)
|
|
}
|
|
lanCode := subtitleLans.GetByLan(arg.Lan)
|
|
searchArg = &model.SubtitleSearchArg{
|
|
Aid: arg.Aid,
|
|
Oid: arg.Oid,
|
|
Mid: arg.Mid,
|
|
UpperMid: arg.UpperMid,
|
|
Status: arg.Status,
|
|
Lan: uint8(lanCode),
|
|
Ps: arg.Ps,
|
|
Pn: arg.Pn,
|
|
}
|
|
if searchResult, err = s.dao.SearchSubtitle(c, searchArg); err != nil {
|
|
log.Error("params(arg:%+v).error(%v)", arg, err)
|
|
return
|
|
}
|
|
if searchResult == nil || len(searchResult.Result) == 0 {
|
|
err = ecode.NothingFound
|
|
return
|
|
}
|
|
oidSubtitleIds = make(map[int64][]int64)
|
|
subtitleMap = make(map[string]*model.Subtitle)
|
|
aidMap = make(map[int64]struct{})
|
|
for _, r := range searchResult.Result {
|
|
oidSubtitleIds[r.Oid] = append(oidSubtitleIds[r.Oid], r.ID)
|
|
}
|
|
for oid, subtitleIds := range oidSubtitleIds {
|
|
tempOid := oid
|
|
tempSubtitleIds := subtitleIds
|
|
eg.Go(func() (err error) {
|
|
var subtitles []*model.Subtitle
|
|
if subtitles, err = s.dao.GetSubtitles(context.Background(), tempOid, tempSubtitleIds); err != nil {
|
|
log.Error("params(oid:%v,subtitleIds:%+v).error(%v)", tempOid, tempSubtitleIds, err)
|
|
return
|
|
}
|
|
for _, subtitle := range subtitles {
|
|
lock.Lock()
|
|
aidMap[subtitle.Aid] = struct{}{}
|
|
subtitleMap[key(subtitle.Oid, subtitle.ID)] = subtitle
|
|
lock.Unlock()
|
|
}
|
|
return
|
|
})
|
|
}
|
|
if err = eg.Wait(); err != nil {
|
|
return
|
|
}
|
|
for aid := range aidMap {
|
|
aids = append(aids, aid)
|
|
}
|
|
if archives, err = s.arcRPC.Archives3(c, &archiveMdl.ArgAids2{
|
|
Aids: aids,
|
|
}); err != nil {
|
|
log.Error("prams(aid:%v),error(%v)", aids, err)
|
|
archives = make(map[int64]*api.Arc)
|
|
err = nil
|
|
}
|
|
searchSubtitles = make([]*model.SearchSubtitle, 0, len(searchResult.Result))
|
|
for _, r := range searchResult.Result {
|
|
if subtitle, ok = subtitleMap[key(r.Oid, r.ID)]; !ok {
|
|
continue
|
|
}
|
|
lan, lanDoc := subtitleLans.GetByID(int64(subtitle.Lan))
|
|
searchSubtitle = &model.SearchSubtitle{
|
|
ID: subtitle.ID,
|
|
Oid: subtitle.Oid,
|
|
Aid: subtitle.Aid,
|
|
AuthorID: subtitle.Mid,
|
|
Status: uint8(subtitle.Status),
|
|
Lan: lan,
|
|
LanDoc: lanDoc,
|
|
IsSign: subtitle.IsSign,
|
|
IsLock: subtitle.IsLock,
|
|
Mtime: subtitle.Mtime,
|
|
SubtitleURL: subtitle.SubtitleURL,
|
|
}
|
|
if archive, ok = archives[subtitle.Aid]; ok {
|
|
searchSubtitle.ArchiveName = archive.Title
|
|
}
|
|
if archiveVideo, err = s.arcRPC.Video3(c, &archiveMdl.ArgVideo2{
|
|
Aid: subtitle.Aid,
|
|
Cid: subtitle.Oid,
|
|
}); err != nil {
|
|
log.Error("params(aid:%v,oid:%v) error(%v)", subtitle.Aid, subtitle.Oid, err)
|
|
err = nil
|
|
} else {
|
|
searchSubtitle.VideoName = archiveVideo.Part
|
|
}
|
|
searchSubtitles = append(searchSubtitles, searchSubtitle)
|
|
}
|
|
res = &model.SubtitleList{
|
|
Page: searchResult.Page,
|
|
}
|
|
res.Subtitles = searchSubtitles
|
|
return
|
|
}
|