321 lines
8.3 KiB
Go
321 lines
8.3 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"go-common/app/admin/main/videoup-task/dao"
|
|
"go-common/app/admin/main/videoup-task/model"
|
|
accmdl "go-common/app/service/main/account/model"
|
|
"go-common/library/database/sql"
|
|
"go-common/library/ecode"
|
|
"go-common/library/log"
|
|
"go-common/library/queue/databus/report"
|
|
)
|
|
|
|
//GetVideoList list qa video tasks
|
|
func (s *Service) GetVideoList(ctx context.Context, pm *model.ListParams) (list *model.QAVideoList, err error) {
|
|
var (
|
|
listLen int
|
|
detailMap map[int64]map[string]int64
|
|
midList []int64
|
|
users map[int64]*model.UserRole
|
|
infos map[int64]*accmdl.Info
|
|
upGroupList map[int64][]*model.UPGroup
|
|
)
|
|
|
|
if list, err = s.searchQAVideo(ctx, pm); err != nil || list == nil || len(list.Result) <= 0 {
|
|
return
|
|
}
|
|
|
|
ids := make([]int64, listLen)
|
|
uids := make([]int64, listLen)
|
|
for _, item := range list.Result {
|
|
ids = append(ids, item.ID)
|
|
uids = append(uids, item.UID)
|
|
}
|
|
if detailMap, midList, err = s.dao.QAVideoDetail(ctx, ids); err != nil {
|
|
return
|
|
}
|
|
if users, err = s.dao.GetUsernameAndRole(ctx, uids); err != nil {
|
|
return
|
|
}
|
|
if infos, err = s.dao.AccountInfos(ctx, midList); err != nil {
|
|
return
|
|
}
|
|
//获取列表页获取
|
|
if upGroupList, err = s.dao.UPGroups(ctx, midList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, item := range list.Result {
|
|
item.User = users[item.UID]
|
|
item.StateName = model.QAStates[item.State]
|
|
item.UPName = ""
|
|
dt, exist := detailMap[item.ID]
|
|
if exist {
|
|
item.DetailID = dt["detail_id"]
|
|
item.TaskUTime = dt["task_utime"]
|
|
item.MID = dt["mid"]
|
|
item.UPGroupList = upGroupList[item.MID]
|
|
if infos[item.MID] != nil {
|
|
item.UPName = infos[item.MID].Name
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
//AddQATaskVideo add a qa video task
|
|
func (s *Service) AddQATaskVideo(ctx context.Context, detail *model.AddVideoParams) (taskID int64, err error) {
|
|
var vid int64
|
|
if vid, err = s.dao.GetVID(ctx, detail.AID, detail.CID); err != nil {
|
|
log.Error("AddQATaskVideo s.dao.GetVID(aid(%d), cid(%d)) error(%v)", detail.AID, detail.CID, err)
|
|
return
|
|
}
|
|
if vid <= 0 {
|
|
log.Error("AddQATaskVideo non-deleted video(aid(%d), cid(%d)) not exist", detail.AID, detail.CID)
|
|
return
|
|
}
|
|
|
|
taskID, err = s.insertVideoTask(ctx, detail)
|
|
return
|
|
}
|
|
|
|
func (s *Service) insertVideoTask(ctx context.Context, detail *model.AddVideoParams) (taskID int64, err error) {
|
|
var (
|
|
tx *sql.Tx
|
|
detailID int64
|
|
)
|
|
defer func() {
|
|
if msg := recover(); msg != nil {
|
|
if tx != nil {
|
|
tx.Rollback()
|
|
}
|
|
log.Error("insertVideoTask panic recover, msg(%s)", msg)
|
|
}
|
|
}()
|
|
|
|
if tx, err = s.dao.BeginTran(ctx); err != nil {
|
|
return
|
|
}
|
|
|
|
if detailID, err = s.dao.InsertQAVideo(tx, &detail.VideoDetail); err != nil {
|
|
tx.Rollback()
|
|
return
|
|
}
|
|
|
|
if taskID, err = s.dao.InTaskQA(tx, detail.OUID, detailID, model.QATypeVideo); err != nil {
|
|
tx.Rollback()
|
|
return
|
|
}
|
|
|
|
if err = tx.Commit(); err != nil {
|
|
dao.PromeErr("arcdb: commit", "insertVideoTask commit error(%v) aid(%d) cid(%d)", err, detail.AID, detail.CID)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) getQATaskVideo(ctx context.Context, id int64, simple bool) (task *model.QATaskVideo, err error) {
|
|
if simple {
|
|
task, err = s.dao.QATaskVideoSimpleByID(ctx, id)
|
|
} else {
|
|
task, err = s.dao.QATaskVideoByID(ctx, id)
|
|
}
|
|
|
|
if err != nil {
|
|
return
|
|
}
|
|
if task == nil {
|
|
err = ecode.NothingFound
|
|
return
|
|
}
|
|
|
|
task.GetAttributeList()
|
|
return
|
|
}
|
|
|
|
//GetDetail get qa video task detail
|
|
func (s *Service) GetDetail(ctx context.Context, id int64) (dt *model.TaskVideoDetail, err error) {
|
|
var (
|
|
taskVideo *model.QATaskVideo
|
|
video *model.Video
|
|
history []*model.VideoOperInfo
|
|
)
|
|
if taskVideo, err = s.getQATaskVideo(ctx, id, false); err != nil {
|
|
return
|
|
}
|
|
info := &model.VideoTaskInfo{
|
|
QATaskVideo: *taskVideo,
|
|
}
|
|
groups, _ := s.dao.UPGroups(ctx, []int64{taskVideo.MID})
|
|
info.UPGroupList = groups[taskVideo.MID]
|
|
info.GetWarnings()
|
|
|
|
if video, err = s.getVideo(ctx, taskVideo.AID, taskVideo.CID); err != nil {
|
|
return
|
|
}
|
|
if history, err = s.getVideoOperInfo(ctx, video.ID); err != nil {
|
|
return
|
|
}
|
|
|
|
dt = &model.TaskVideoDetail{
|
|
Task: info,
|
|
Video: video,
|
|
VideoHistory: history,
|
|
}
|
|
return
|
|
}
|
|
|
|
//QAVideoSubmit submit qa video task
|
|
func (s *Service) QAVideoSubmit(ctx context.Context, username string, uid int64, vp *model.QASubmitParams) (err error) {
|
|
var (
|
|
task *model.QATaskVideo
|
|
video *model.Video
|
|
)
|
|
if task, err = s.getQATaskVideo(ctx, vp.ID, true); err != nil {
|
|
log.Error("QAVideoSubmit s.arc.QATaskVideoByID error(%v), id(%d) task(%+v)", err, vp.ID, task)
|
|
return
|
|
}
|
|
if video, err = s.getVideo(ctx, task.AID, task.CID); err != nil {
|
|
log.Error("sendLog s.getVideo error(%v) qa.id(%d) aid(%d) cid(%d)", err, vp.ID, task.AID, task.CID)
|
|
return
|
|
}
|
|
//不重复质检
|
|
if task.State == model.QAStateFinish {
|
|
return
|
|
}
|
|
|
|
//更新task
|
|
task.State = model.QAStateFinish
|
|
task.FTime = time.Now()
|
|
if _, err = s.dao.UpTask(ctx, vp.ID, task.State, task.FTime); err != nil {
|
|
return
|
|
}
|
|
|
|
s.dao.AddVideoOper(ctx, task.AID, uid, video.ID, video.Attribute, video.Status, 0, fmt.Sprintf("一审任务质检TAG: [%s]", vp.QATag), vp.QaNote)
|
|
s.sendLog(ctx, username, uid, video, task, vp)
|
|
return
|
|
}
|
|
|
|
func (s *Service) sendLog(ctx context.Context, username string, uid int64, video *model.Video, task *model.QATaskVideo, vp *model.QASubmitParams) (err error) {
|
|
var (
|
|
note string
|
|
taskUIDName string
|
|
)
|
|
|
|
if task == nil || len(task.AttributeList) == 0 {
|
|
log.Error("sendLog task/task.attributelist not exist, task(%+v) params(%+v)", task, vp)
|
|
return
|
|
}
|
|
if note, err = task.GetNote(); err != nil {
|
|
log.Error("sendLog task.GetNote() error(%v), params(%+v)", err, vp)
|
|
return
|
|
}
|
|
if vp.Norank == 1 {
|
|
video.AttributeList["norank"] = 1
|
|
}
|
|
if vp.Nodynamic == 1 {
|
|
video.AttributeList["nodynamic"] = 1
|
|
}
|
|
if vp.Norecommend == 1 {
|
|
video.AttributeList["norecommend"] = 1
|
|
}
|
|
if vp.Nosearch == 1 {
|
|
video.AttributeList["nosearch"] = 1
|
|
}
|
|
if vp.PushBlog == 1 {
|
|
video.AttributeList["push_blog"] = 1
|
|
}
|
|
if vp.OverseaBlock == 1 {
|
|
video.AttributeList["oversea_block"] = 1
|
|
}
|
|
video.TagID = vp.TagID
|
|
video.Status = vp.AuditStatus
|
|
video.Note = vp.Note
|
|
video.Reason = vp.Reason
|
|
video.Encoding = vp.Encoding
|
|
if taskUIDNames, err := s.dao.GetUsername(ctx, []int64{task.UID}); err != nil {
|
|
taskUIDName = ""
|
|
err = nil
|
|
} else {
|
|
taskUIDName = taskUIDNames[task.UID]
|
|
}
|
|
|
|
content := map[string]interface{}{
|
|
"audit_status": task.AuditStatus,
|
|
"audit_attr": task.AttributeList,
|
|
"audit_tag_id": task.TagID,
|
|
"audit_note": note,
|
|
"qa_status": video.Status,
|
|
"qa_attr": video.AttributeList,
|
|
"qa_tag_id": video.TagID,
|
|
"qa_note": video.Note,
|
|
}
|
|
|
|
data := &report.ManagerInfo{
|
|
Uname: username,
|
|
UID: uid,
|
|
Business: model.LogQATask,
|
|
Type: model.LogQATaskVideo,
|
|
Oid: vp.ID,
|
|
Action: strconv.Itoa(int(video.Status)),
|
|
Ctime: task.FTime,
|
|
Index: []interface{}{task.TaskID, task.MID, task.CTime.Unix(), strconv.FormatInt(vp.QaTagID, 10), strconv.FormatInt(task.UID, 10), taskUIDName},
|
|
Content: content,
|
|
}
|
|
report.Manager(data)
|
|
log.Info(" sendLog data(%+v)", data)
|
|
return
|
|
}
|
|
|
|
//UpVideoUTime update qa video task utime
|
|
func (s *Service) UpVideoUTime(ctx context.Context, aid, cid, taskID, utime int64) (err error) {
|
|
var id int64
|
|
if id, err = s.dao.GetQAVideoID(ctx, aid, cid, taskID); err != nil {
|
|
log.Error("UpVideoUTime s.dao.GetQAVideoID error(%v) aid(%d) cid(%d) taskid(%d) utime(%d)", err, aid, cid, taskID, utime)
|
|
return
|
|
}
|
|
if id <= 0 {
|
|
log.Error("UpVideoUTime s.dao.GetQAVideoID not found aid(%d) cid(%d) taskid(%d) utime(%d)", aid, cid, taskID, utime)
|
|
err = ecode.RequestErr
|
|
return
|
|
}
|
|
|
|
return s.dao.UpdateQAVideoUTime(ctx, aid, cid, taskID, utime)
|
|
}
|
|
|
|
func (s *Service) delProc() {
|
|
var (
|
|
err error
|
|
qaVideoRows, qaTaskRows int64 = 1, 1
|
|
limit = 1000
|
|
)
|
|
|
|
for {
|
|
deadLine := time.Now().AddDate(0, -1, 0)
|
|
for {
|
|
if qaVideoRows > 0 {
|
|
if qaVideoRows, err = s.dao.DelQAVideo(context.TODO(), deadLine, limit); err != nil {
|
|
log.Error("delProc s.dao.DelQAVideo(%v,%d) error(%v)", deadLine, limit, err)
|
|
}
|
|
}
|
|
if qaTaskRows > 0 {
|
|
if qaTaskRows, err = s.dao.DelQATask(context.TODO(), deadLine, limit); err != nil {
|
|
log.Error("delProc s.dao.DelQATask(%v,%d) error(%v)", deadLine, limit, err)
|
|
}
|
|
}
|
|
|
|
if qaVideoRows+qaTaskRows == 0 {
|
|
break
|
|
}
|
|
time.Sleep(time.Minute)
|
|
}
|
|
|
|
time.Sleep(time.Hour * 24)
|
|
}
|
|
}
|