go-common/app/admin/main/videoup-task/service/review.go

265 lines
6.6 KiB
Go
Raw Normal View History

2019-04-22 10:49:16 +00:00
package service
import (
"context"
"fmt"
"strings"
"time"
"go-common/app/admin/main/videoup-task/model"
"go-common/library/database/sql"
"go-common/library/log"
"go-common/library/xstr"
)
// ErrTaskMISS .
var ErrTaskMISS = fmt.Errorf("任务缓存查找失败")
// ReviewForm 复审表单
func (s *Service) ReviewForm(c context.Context, tid int64) (form *model.SubmitForm, err error) {
return s.dao.ReviewForm(c, tid)
}
// CheckReview 检查任务复审
func (s *Service) CheckReview(c context.Context, form *model.SubmitForm) (isReview bool, err error) {
var (
v *model.Video
attr int32
tx *sql.Tx
rows int64
tp *model.TaskPriority
)
attr, err = s.dao.VideoAttribute(c, form.CID)
if err != nil {
log.Error("CheckReview VideoAttribute(aid%d,cid%d) miss(%v)", form.AID, form.CID, err)
return false, ErrTaskMISS
}
v = &model.Video{Attribute: attr}
tp, err = s.getReviewParams(c, form)
if err != nil || tp == nil {
log.Info("CheckReview(%d) 不需要复审(%+v)", form.TaskID, tp)
return false, err
}
s.SyncRC(c)
ck := s.reviewCache.Check(c, tp, form.UID)
if !ck {
log.Info("CheckReview(%d) 不需要复审(%+v)", form.TaskID, tp)
return false, nil
}
if _, err = s.dao.InReviewForm(c, form, form.UID, form.Uname); err != nil {
return false, err
}
if tx, err = s.dao.BeginTran(c); err != nil {
return false, err
}
if rows, err = s.dao.TxUpTaskByID(tx, form.TaskID, map[string]interface{}{"state": model.TypeReview}); err != nil {
tx.Rollback()
return false, err
}
if rows > 0 {
if _, err = s.dao.TxAddTaskHis(tx, 0, model.ActionSubmit, form.TaskID, form.CID, form.UID, 0, form.Status, "TaskReview"); err != nil {
tx.Rollback()
return false, err
}
}
if err = tx.Commit(); err != nil {
log.Error("tx.Commit error(%v)", err)
return false, err
}
// log
attrs := map[uint]int32{
model.AttrBitNoRank: form.Norank,
model.AttrBitNoDynamic: form.Noindex,
model.AttrBitNoRecommend: form.NoRecommend,
model.AttrBitNoSearch: form.Nosearch,
model.AttrBitOverseaLock: form.OverseaBlock,
model.AttrBitPushBlog: form.PushBlog,
}
var conts []string
const template = "[%s]从[%s]设为[%s]"
var yesOrNo = map[int32]string{model.AttrYes: "是", model.AttrNo: "否"}
for bit, attr := range attrs {
v.AttrSet(attr, bit)
if attr == 1 {
conts = append(conts, fmt.Sprintf(template, model.BitDesc(bit), yesOrNo[^attr&1], yesOrNo[attr]))
log.Info("vid(%d) update video bit(%d) bitdesc(%s) attrs(%d)", form.ID, bit, model.BitDesc(bit), attr)
}
}
vp := &model.VideoParam{
ID: form.ID,
Aid: form.AID,
Mid: form.MID,
RegionID: tp.TypeID,
Status: form.Status,
Cid: form.CID,
Title: form.Eptitle,
Desc: form.Description,
UID: form.UID,
TaskID: form.TaskID,
Oname: form.Uname,
TagID: form.TID,
Reason: form.Reason,
ReasonID: form.ReasonID,
Note: form.Note,
Attribute: v.Attribute,
}
oper := &model.VideoOper{Aid: form.AID, UID: form.UID, Vid: form.ID, Attribute: vp.Attribute, Status: form.Status, Remark: form.Note}
operConts := append([]string{fmt.Sprintf("初审提交")}, conts...)
operConts = append(operConts, s.diffVideoOper(vp)...)
oper.Content = strings.Join(operConts, "")
s.addVideoOper(c, oper)
s.sendVideoLog(c, vp, oper.Content)
return true, nil
}
// ListReviewConfs 配置列表
func (s *Service) ListReviewConfs(c context.Context, unames, bt, et, sort string, pn, ps int64) (rcs []*model.ReviewConf, count int64, err error) {
var uids []int64
if len(unames) > 0 {
res, _ := s.dao.Uids(c, strings.Split(unames, ","))
for _, uid := range res {
uids = append(uids, uid)
}
}
rcs, count, err = s.dao.ListConfs(c, uids, bt, et, sort, pn, ps)
for _, v := range rcs {
if v.Bt.TimeValue().IsZero() {
v.Bt = ""
}
if v.Et.TimeValue().IsZero() {
v.Et = ""
}
if len(v.Uids) > 0 {
if unames, _ := s.dao.Unames(c, v.Uids); len(unames) > 0 {
for _, uname := range unames {
v.Unames = append(v.Unames, uname)
}
}
}
}
return
}
// AddReviewConf 添加配置
func (s *Service) AddReviewConf(c context.Context, rc *model.ReviewConf) (err error) {
if len(rc.Types) > 0 {
stypes, _ := xstr.SplitInts(s.tarnsType(c, xstr.JoinInts(rc.Types)))
rc.Types = stypes
}
if _, err = s.dao.InReviewConf(c, rc); err != nil {
log.Error("s.AddReviewConf(%+v) error(%v)", rc, err)
return err
}
s.SyncRC(c)
return
}
// EditReviewConf 修改配置
func (s *Service) EditReviewConf(c context.Context, rc *model.ReviewConf) (err error) {
if len(rc.Types) > 0 {
stypes, _ := xstr.SplitInts(s.tarnsType(c, xstr.JoinInts(rc.Types)))
rc.Types = stypes
}
if _, err = s.dao.UpReviewConf(c, rc); err != nil {
log.Error("s.EditReviewConf(%+v) error(%v)", rc, err)
return err
}
s.SyncRC(c)
return
}
// DelReviewConf 删除配置
func (s *Service) DelReviewConf(c context.Context, id int) (err error) {
if _, err = s.dao.DelReviewConf(c, id); err != nil {
log.Error("s.DelReviewConf(%d) error(%v)", id, err)
return err
}
s.SyncRC(c)
return
}
// SyncRC sync from db
func (s *Service) SyncRC(c context.Context) {
rcs, err := s.dao.ReviewConfs(context.TODO())
if err != nil {
log.Error("loadRC error(%v)", err)
return
}
if len(rcs) > 0 {
s.reviewCache.Mux.Lock()
defer s.reviewCache.Mux.Unlock()
s.reviewCache.MRC = make(map[int64]*model.ReviewConf)
for _, item := range rcs {
s.reviewCache.MRC[item.ID] = item
}
}
}
func (s *Service) loadRC() {
s.SyncRC(context.TODO())
}
func (s *Service) loadRCproc() {
for {
time.Sleep(3 * time.Minute)
s.SyncRC(context.TODO())
}
}
func (s *Service) getReviewParams(c context.Context, form *model.SubmitForm) (tp *model.TaskPriority, err error) {
t, err := s.dao.TaskByID(c, form.TaskID)
if err != nil || t == nil {
return nil, ErrTaskMISS
}
if t.State != model.TypeDispatched {
log.Info("CheckReview(%d) 不需要复审 state(%d)", form.TaskID, t.State)
return nil, nil
}
mp, err := s.dao.GetWeightRedis(c, []int64{form.TaskID})
if err != nil || len(mp) == 0 {
if mp, err = s.dao.GetWeightDB(c, []int64{form.TaskID}); err != nil || len(mp) == 0 {
log.Error("GetWeightDB(%d) miss", form.TaskID)
return nil, ErrTaskMISS
}
}
if _, ok := mp[form.TaskID]; !ok {
log.Error("mp(%d) miss", form.TaskID)
return nil, ErrTaskMISS
}
tp = mp[form.TaskID]
// 补充复审判断的参数
if tp.TypeID == 0 {
s.setReviewParams(c, form.MID, form.AID, tp)
}
return
}
func (s *Service) setReviewParams(c context.Context, mid, aid int64, tp *model.TaskPriority) {
typeid, upfrom, err := s.dao.ArchiveParam(c, aid)
if err == nil {
tp.TypeID = typeid
tp.UpFrom = upfrom
}
tp.UpGroups = s.getSpecial(mid)
}