You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
264 lines
6.6 KiB
264 lines
6.6 KiB
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) |
|
}
|
|
|