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.
332 lines
12 KiB
332 lines
12 KiB
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 |
|
}
|
|
|