333 lines
12 KiB
Go
333 lines
12 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
|
||
"go-common/app/admin/main/videoup/model/archive"
|
||
"go-common/library/database/sql"
|
||
"go-common/library/log"
|
||
xtime "go-common/library/time"
|
||
)
|
||
|
||
// txUpArcAttrs update archive attrs
|
||
func (s *Service) txUpArcAttrs(tx *sql.Tx, a *archive.Archive, attrs map[uint]int32, redirectURL string) (cont []string, err error) {
|
||
const template = "[%s]从[%s]设为[%s]"
|
||
var yesOrNo = map[int32]string{archive.AttrYes: "是", archive.AttrNo: "否"}
|
||
for bit, attr := range attrs {
|
||
if bit == archive.AttrBitJumpURL && (attr == archive.AttrNo || redirectURL == "") {
|
||
redirectURL = ""
|
||
attr = archive.AttrNo
|
||
}
|
||
var arcRows int64
|
||
if arcRows, err = s.arc.TxUpArcAttr(tx, a.Aid, bit, attr); err != nil {
|
||
log.Error("s.arc.TxUpArcAttr(%d,%d,%d) error(%v)", a.Aid, bit, attr, err)
|
||
return
|
||
}
|
||
if bit == archive.AttrBitJumpURL {
|
||
var additRows int64
|
||
if additRows, err = s.arc.TxUpAdditRedirect(tx, a.Aid, redirectURL); err != nil {
|
||
log.Error("s.arc.TxUpAddit(%d,%s) error(%v)", a.Aid, redirectURL, err)
|
||
return
|
||
}
|
||
if arcRows != 0 || additRows != 0 {
|
||
log.Info("aid(%d) update addit redirectURL(%s)", a.Aid, redirectURL)
|
||
var desc = redirectURL
|
||
if desc == "" {
|
||
desc = "空"
|
||
}
|
||
cont = append(cont, fmt.Sprintf("[%s]设为[%s]", "跳转地址", desc))
|
||
}
|
||
}
|
||
a.AttrSet(attr, bit)
|
||
if arcRows <= 0 {
|
||
continue
|
||
}
|
||
cont = append(cont, fmt.Sprintf(template, archive.BitDesc(bit), yesOrNo[^attr&1], yesOrNo[attr]))
|
||
log.Info("aid(%d) update archive bit(%d) bitdesc(%s) attrs(%d)", a.Aid, bit, archive.BitDesc(bit), attr)
|
||
}
|
||
return
|
||
}
|
||
|
||
// txUpArcForbidAttrs update archive forbid attrs
|
||
func (s *Service) txUpArcForbidAttrs(c context.Context, tx *sql.Tx, a *archive.Archive, forbidAttrs map[string]map[uint]int32) (conts []string, err error) {
|
||
const template = "[%s]从[%s]设为[%s]"
|
||
var (
|
||
yesOrNo = map[int32]string{archive.AttrYes: "是", archive.AttrNo: "否"}
|
||
forbid *archive.ForbidAttr
|
||
change bool
|
||
)
|
||
// forbid
|
||
if forbid, err = s.arc.Forbid(c, a.Aid); err != nil {
|
||
log.Error("s.arc.Forbid(%d) error(%v)", a.Aid, err)
|
||
return
|
||
}
|
||
for name, attrs := range forbidAttrs {
|
||
for bit, attr := range attrs {
|
||
if change = forbid.SetAttr(name, attr, bit); change {
|
||
conts = append(conts, fmt.Sprintf(template, archive.ForbidBitDesc(name, bit), yesOrNo[^attr&1], yesOrNo[attr]))
|
||
log.Info("aid(%d) update archive forbid name(%s) bit(%d) bitdesc(%s) attrs(%d)", a.Aid, name, bit, archive.ForbidBitDesc(name, bit), attr)
|
||
}
|
||
}
|
||
}
|
||
forbid.Convert()
|
||
if _, err = s.arc.TxUpForbid(tx, forbid); err != nil {
|
||
log.Error("s.arc.TxUpForbid(%+v) error(%v)", forbid, err)
|
||
}
|
||
return
|
||
}
|
||
|
||
//txAddFirstPass 添加稿件第一次过审的记录
|
||
func (s *Service) txAddFirstPass(c context.Context, tx *sql.Tx, aid int64, state int8) (firstPass bool, err error) {
|
||
if !archive.NormalState(state) || s.hadPassed(c, aid) {
|
||
return
|
||
}
|
||
|
||
if err = s.arc.AddFirstPass(tx, aid); err != nil {
|
||
log.Error("txUpArcState s.arc.AddFirstPass error(%v) aid(%d)", err, aid)
|
||
return
|
||
}
|
||
|
||
firstPass = true
|
||
return
|
||
}
|
||
|
||
//txUpArcState 更新稿件属性时，联动添加第一次过审记录
|
||
func (s *Service) txUpArcState(c context.Context, tx *sql.Tx, aid int64, state int8) (firstPass bool, err error) {
|
||
if _, err = s.arc.TxUpArcState(tx, aid, state); err != nil {
|
||
log.Error("txUpArcState s.arc.TxUpArcState error(%v) aid(%d) state(%d)", err, aid, state)
|
||
return
|
||
}
|
||
|
||
if firstPass, err = s.txAddFirstPass(c, tx, aid, state); err != nil {
|
||
log.Error("txUpArcState s.txAddFirstPass error(%v) aid(%d) state(%d)", err, aid, state)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// txUpArcMainState update archive states
|
||
func (s *Service) txUpArcMainState(c context.Context, tx *sql.Tx, aid, forward int64, typeID, access int16, state, round int8, reason string) (racs int16, err error) {
|
||
log.Info("aid(%d) get archive state(%d)", aid, state)
|
||
if ok := s.isAccess(c, aid); ok && access == archive.AccessDefault {
|
||
access = archive.AccessMember
|
||
}
|
||
if _, err = s.txUpArcState(c, tx, aid, state); err != nil {
|
||
log.Error("txUpArcMainState s.txUpArcState error(%v) aid(%d) state(%d)", err, aid, state)
|
||
return
|
||
}
|
||
log.Info("aid(%d) update archive state(%d)", aid, state)
|
||
if _, err = s.arc.TxUpArcAccess(tx, aid, access); err != nil {
|
||
log.Error("s.arc.TxUpArcAccess(%d,%d) error(%v)", aid, access, err)
|
||
return
|
||
}
|
||
racs = access
|
||
log.Info("aid(%d) update archive access(%d)", aid, access)
|
||
if typeID != 0 {
|
||
if _, err = s.arc.TxUpArcTypeID(tx, aid, typeID); err != nil {
|
||
log.Error("s.arc.TxUpArcTypeID(%d,%d) error(%v)", aid, typeID, err)
|
||
return
|
||
}
|
||
log.Info("aid(%d) update archive type_id(%d)", aid, typeID)
|
||
}
|
||
if _, err = s.arc.TxUpArcRound(tx, aid, round); err != nil {
|
||
log.Error("s.arc.TxUpArcRound(%d,%d) error(%v)", aid, round, err)
|
||
return
|
||
}
|
||
log.Info("aid(%d) update archive round(%d)", aid, round)
|
||
if _, err = s.arc.TxUpArcReason(tx, aid, forward, reason); err != nil {
|
||
log.Error("s.arc.TxUpArcReason(%d,%d,%s) error(%v)", aid, forward, reason, err)
|
||
return
|
||
}
|
||
log.Info("aid(%d) update archive reason(%s) forward_id(%d)", aid, reason, forward)
|
||
return
|
||
}
|
||
|
||
// txUpArcDelay update archive delay
|
||
func (s *Service) txUpArcDelay(c context.Context, tx *sql.Tx, aid, mid int64, state int8, isDelay bool, dTime xtime.Time) (rs int8, cont string, err error) {
|
||
rs = state
|
||
var delay *archive.Delay
|
||
if delay, _ = s.arc.Delay(c, aid, archive.DelayTypeForUser); delay == nil && dTime <= 0 {
|
||
return
|
||
}
|
||
if !isDelay || archive.NotAllowDelay(state) {
|
||
if _, err = s.arc.TxDelDelay(tx, aid, archive.DelayTypeForUser); err != nil {
|
||
log.Error("s.arc.TxDelDelay(%d) error(%v)", aid, err)
|
||
return
|
||
}
|
||
cont = archive.Operformat(archive.OperTypeDelay, dTime.Time().Format("2006-01-02 15:04:05"), "无", archive.OperStyleOne)
|
||
log.Info("aid(%d) err delay time delete archive_delay", aid)
|
||
return
|
||
}
|
||
if dTime <= 0 && delay != nil {
|
||
dTime = delay.DTime
|
||
}
|
||
if _, err = s.arc.TxUpDelay(tx, mid, aid, state, archive.DelayTypeForUser, dTime); err != nil {
|
||
log.Error("s.arc.TxUpDelay(%d，%d,%d,%d,%d) error(%v)", aid, mid, state, archive.DelayTypeForUser, dTime, err)
|
||
return
|
||
}
|
||
if archive.NormalState(state) {
|
||
rs = archive.StateForbidUserDelay
|
||
}
|
||
if delay != nil && dTime != delay.DTime {
|
||
cont = archive.Operformat(archive.OperTypeDelay, delay.DTime.Time().Format("2006-01-02 15:04:05"), dTime.Time().Format("2006-01-02 15:04:05"), archive.OperStyleOne)
|
||
} else if delay == nil {
|
||
cont = archive.Operformat(archive.OperTypeDelay, "无", dTime.Time().Format("2006-01-02 15:04:05"), archive.OperStyleOne)
|
||
}
|
||
log.Info("aid(%d) second_round submit update archive_delay mid(%d) state(%d) type(%d) dtime(%v)", aid, mid, state, archive.DelayTypeForUser, dTime)
|
||
return
|
||
}
|
||
|
||
// TxUpArchiveAttr update archive attr by aid.
|
||
func (s *Service) TxUpArchiveAttr(c context.Context, tx *sql.Tx, a *archive.Archive, aid, uid int64, attrs map[uint]int32, forbidAttrs map[string]map[uint]int32, redirectURL string) (conts []string, err error) {
|
||
var cont []string
|
||
log.Info("aid(%d) begin tran change attribute", aid)
|
||
if cont, err = s.txUpArcAttrs(tx, a, attrs, redirectURL); err != nil {
|
||
log.Error("s.txUpArcAttrs(%d) error(%v)", aid, err)
|
||
return
|
||
}
|
||
conts = append(conts, cont...)
|
||
if _, err = s.txUpArcForbidAttrs(c, tx, a, forbidAttrs); err != nil {
|
||
log.Error("s.txUpArcForbidAttrs(%d) error(%v)", aid, err)
|
||
return
|
||
}
|
||
log.Info("aid(%d) end tran change attribute", aid)
|
||
return
|
||
}
|
||
|
||
// txUpVideoStatus update video status by vid and cid.
|
||
func (s *Service) txUpVideoStatus(tx *sql.Tx, vid, cid int64, status int16) (err error) {
|
||
//update archive_video
|
||
if _, err = s.arc.TxUpVideoStatus(tx, vid, status); err != nil {
|
||
log.Error("s.arc.TxUpVideoStatus vid(%d) status(%d) error(%v)", vid, status, err)
|
||
return
|
||
}
|
||
//update video
|
||
if _, err = s.arc.TxUpStatus(tx, cid, status); err != nil {
|
||
log.Error("s.arc.TxUpStatus cid(%d) status(%d) error(%v)", cid, status, err)
|
||
return
|
||
}
|
||
//update archive_video_relation to 0
|
||
if _, err = s.arc.TxUpRelationState(tx, vid, archive.VideoStatusOpen); err != nil {
|
||
log.Error("s.arc.TxUpRelationState cid(%d) status(%d) error(%v)", cid, archive.VideoStatusOpen, err)
|
||
return
|
||
}
|
||
log.Info("vid(%d) cid(%d) update video status(%d)", vid, cid, status)
|
||
return
|
||
}
|
||
|
||
// txAddVideo insert video get vid.
|
||
func (s *Service) txAddVideo(tx *sql.Tx, v *archive.Video) (vid int64, err error) {
|
||
if vid, err = s.arc.TxAddVideo(tx, v); err != nil {
|
||
log.Error("s.arc.TxAddVideo video(%+v) error(%v)", v, err)
|
||
return
|
||
}
|
||
v.ID = vid
|
||
if _, err = s.arc.TxAddRelation(tx, v); err != nil {
|
||
log.Error("s.arc.TxAddRelation video(%+v) error(%v)", v, err)
|
||
return
|
||
}
|
||
log.Info("aid(%d) update video vid(%d) cid(%d) index(%d) title(%s) desc(%s) filename(%s) srctype(%s)", v.Aid, vid, v.Cid, v.Index, v.Title, v.Desc, v.Filename, v.SrcType)
|
||
return
|
||
}
|
||
|
||
// txUpVideo update video title and desc by vid.
|
||
func (s *Service) txUpVideo(tx *sql.Tx, vid int64, title, desc string) (err error) {
|
||
if _, err = s.arc.TxUpVideo(tx, vid, title, desc); err != nil {
|
||
log.Error("s.arc.TxUpVideo vid(%d) title(%s) desc(%s) error(%v)", vid, title, desc, err)
|
||
return
|
||
}
|
||
if _, err = s.arc.TxUpRelation(tx, vid, title, desc); err != nil {
|
||
log.Error("s.arc.TxUpRelation vid(%d) title(%s) desc(%s) error(%v)", vid, title, desc, err)
|
||
return
|
||
}
|
||
log.Info("vid(%d) update video title(%s) desc(%s)", vid, title, desc)
|
||
return
|
||
}
|
||
|
||
// txUpVideoLink update video weblink by vid and cid.
|
||
func (s *Service) txUpVideoLink(tx *sql.Tx, vid, cid int64, webLink string) (err error) {
|
||
if _, err = s.arc.TxUpVideoLink(tx, vid, webLink); err != nil {
|
||
log.Error("s.arc.TxUpVideoLink(%d,%s)", vid, webLink)
|
||
return
|
||
}
|
||
if _, err = s.arc.TxUpWebLink(tx, cid, webLink); err != nil {
|
||
log.Error("s.arc.TxUpWebLink(%d,%s)", cid, webLink)
|
||
return
|
||
}
|
||
log.Info("vid(%d) cid(%d) update webLink(%s)", vid, cid, webLink)
|
||
return
|
||
}
|
||
|
||
// txDelVideo delete video by vid.
|
||
func (s *Service) txDelVideo(tx *sql.Tx, vp *archive.VideoParam) (err error) {
|
||
if _, err = s.arc.TxUpVideoStatus(tx, vp.ID, archive.VideoStatusDelete); err != nil {
|
||
log.Error("s.arc.TxUpVideoStatus(%d,%d)", vp.ID, archive.VideoStatusDelete)
|
||
return
|
||
}
|
||
if _, err = s.arc.TxUpRelationState(tx, vp.ID, archive.VideoStatusDelete); err != nil {
|
||
log.Error("s.arc.TxUpRelationState(%d,%d)", vp.ID, archive.VideoStatusDelete)
|
||
return
|
||
}
|
||
log.Info("del video cid(%d) vid(%d)", vp.Cid, vp.ID)
|
||
return
|
||
}
|
||
|
||
// txUpVideoIndex update video index by vid.
|
||
func (s *Service) txUpVideoIndex(tx *sql.Tx, vid int64, index int) (err error) {
|
||
if _, err = s.arc.TxUpVideoIndex(tx, vid, index); err != nil {
|
||
log.Error("s.arc.TxUpVideoIndex(%d,%d)", vid, index)
|
||
return
|
||
}
|
||
if _, err = s.arc.TxUpRelationOrder(tx, vid, index); err != nil {
|
||
log.Error("s.arc.TxUpRelationOrder(%d,%d)", vid, index)
|
||
return
|
||
}
|
||
log.Info("vid(%d) update index(%d)", vid, index)
|
||
return
|
||
}
|
||
|
||
func (s *Service) txUpVideoAttr(c context.Context, tx *sql.Tx, vid, cid int64, attrs map[uint]int32) (conts []string, attribute int32, err error) {
|
||
var v *archive.Video
|
||
if v, err = s.arc.NewVideoByID(c, vid); err != nil || v == nil {
|
||
log.Error("s.arc.VideoByID(%d) error(%v)", vid, err)
|
||
return
|
||
}
|
||
const template = "[%s]从[%s]设为[%s]"
|
||
var yesOrNo = map[int32]string{archive.AttrYes: "是", archive.AttrNo: "否"}
|
||
for bit, attr := range attrs {
|
||
var rows int64
|
||
if rows, err = s.arc.TxUpVideoAttr(tx, vid, bit, attr); err != nil {
|
||
log.Error("s.arc.TxUpVideoAttr id(%d) bit(%d) attr(%d) error(%v)", vid, bit, attr, err)
|
||
return
|
||
}
|
||
if _, err = s.arc.TxUpAttr(tx, cid, bit, attr); err != nil {
|
||
log.Error("s.arc.TxUpAttr cid(%d) bit(%d) attr(%d) error(%v)", cid, bit, attr, err)
|
||
return
|
||
}
|
||
v.AttrSet(attr, bit)
|
||
if rows <= 0 {
|
||
continue
|
||
}
|
||
conts = append(conts, fmt.Sprintf(template, archive.BitDesc(bit), yesOrNo[^attr&1], yesOrNo[attr]))
|
||
log.Info("vid(%d) update video bit(%d) bitdesc(%s) attrs(%d)", vid, bit, archive.BitDesc(bit), attr)
|
||
}
|
||
attribute = v.Attribute
|
||
return
|
||
}
|
||
|
||
// txUpVideoAudit update video audit by videoParam.
|
||
func (s *Service) txUpVideoAudit(tx *sql.Tx, vp *archive.VideoParam) (err error) {
|
||
if err = s.txUpVideoStatus(tx, vp.ID, vp.Cid, vp.Status); err != nil {
|
||
log.Error("s.arc.TxUpVideoStatus id(%d) cid(%d) status(%d) error(%v)", vp.ID, vp.Cid, vp.Status, err)
|
||
return
|
||
}
|
||
log.Info("aid(%d) vid(%d) update video status(%d)", vp.Aid, vp.ID, vp.Status)
|
||
if _, err = s.arc.TxAddAudit(tx, vp.Aid, vp.ID, vp.TagID, vp.Oname, vp.Note, vp.Reason); err != nil {
|
||
log.Error("s.arc.TxAddAudit(%d,%d,%d,%s,%s,%s)", vp.Aid, vp.ID, vp.TagID, vp.Oname, vp.Note, vp.Reason)
|
||
return
|
||
}
|
||
log.Info("aid(%d) vid(%d) audit log tag(%d) oname(%s) note(%s) reason(%s)", vp.Aid, vp.ID, vp.TagID, vp.Oname, vp.Note, vp.Reason)
|
||
return
|
||
}
|