312 lines
11 KiB
Go
312 lines
11 KiB
Go
package archive
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"go-common/app/admin/main/videoup/model/archive"
|
|
"go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
"go-common/library/xstr"
|
|
)
|
|
|
|
const (
|
|
_videoByCid = "SELECT vr.id,vr.aid,vr.title AS eptitle,vr.description,v.filename,v.src_type,vr.cid,v.duration,v.filesize,v.resolutions,vr.index_order,vr.ctime,vr.mtime,v.status,v.playurl,v.attribute,v.failcode AS failinfo,v.xcode_state,v.weblink FROM archive_video_relation AS vr LEFT JOIN video AS v ON vr.cid = v.id WHERE vr.cid = ?"
|
|
_inRelationSQL = "INSERT IGNORE INTO archive_video_relation (id,aid,cid,title,description,index_order,ctime,mtime) VALUES (?,?,?,?,?,?,?,?)"
|
|
_upRelationSQL = "UPDATE archive_video_relation SET title=?,description=? WHERE id=?"
|
|
_upRelationOrderSQL = "UPDATE archive_video_relation SET index_order=? WHERE id=?"
|
|
_upRelationStateSQL = "UPDATE archive_video_relation SET state=? WHERE id=?"
|
|
_upVideoLinkSQL = "UPDATE video SET weblink=? WHERE id=?"
|
|
_upVideoStatusSQL = "UPDATE video SET status=? WHERE id=?"
|
|
_upVideoAttrSQL = "UPDATE video SET attribute=attribute&(~(1<<?))|(?<<?) WHERE id=?"
|
|
_slPlayurl = "SELECT playurl FROM video WHERE id=? LIMIT 1"
|
|
_newVideoIDSQL = `SELECT avr.id,v.filename,avr.cid,avr.aid,avr.title,avr.description,v.src_type,v.duration,v.filesize,v.resolutions,v.playurl,v.failcode,
|
|
avr.index_order,v.attribute,v.xcode_state,avr.state,avr.ctime,avr.mtime FROM archive_video_relation avr JOIN video v on avr.cid = v.id
|
|
WHERE avr.id=? LIMIT 1`
|
|
_newVideoIDsSQL = `SELECT avr.id,v.filename,avr.cid,avr.aid,avr.title,avr.description,v.src_type,v.duration,v.filesize,v.resolutions,v.playurl,v.failcode,
|
|
avr.index_order,v.attribute,v.xcode_state,avr.state,avr.ctime,avr.mtime FROM archive_video_relation avr JOIN video v on avr.cid = v.id
|
|
WHERE avr.id in (%s)`
|
|
_newVideosAIDSQL = `SELECT avr.id,v.filename,avr.cid,avr.aid,avr.title,avr.description,v.src_type,v.duration,v.filesize,v.resolutions,v.playurl,v.failcode,
|
|
avr.index_order,v.attribute,v.xcode_state,avr.state,v.status,avr.ctime,avr.mtime FROM archive_video_relation avr JOIN video v on avr.cid = v.id
|
|
WHERE aid=? and state != -100 ORDER BY index_order ASC`
|
|
_newVideoCntSQL = `SELECT COUNT(*) FROM archive_video_relation WHERE aid=? AND state!=-100`
|
|
_slSrcTypeSQL = "SELECT `id`, `src_type` FROM `video` WHERE `id` IN (%s)"
|
|
_slVIDSQL = "SELECT ar.id FROM archive_video_relation AS ar, video AS v WHERE ar.cid = v.id AND ar.aid=? AND v.filename=?;"
|
|
_videoInfo = `SELECT vr.id, vr.aid, vr.title AS eptitle, vr.description, vr.cid, vr.ctime AS epctime, v.filename, v.xcode_state, v.playurl,
|
|
a.ctime, a.author, a.title, a.tag, a.content, a.cover, a.typeid, a.mid, a.copyright,
|
|
coalesce(addit.source, '') source, coalesce(addit.dynamic, '') dynamic, coalesce(addit.desc_format_id, 0) desc_format_id, coalesce(addit.description, '') description
|
|
FROM archive_video_relation AS vr JOIN archive AS a ON vr.aid = a.id
|
|
LEFT OUTER JOIN video AS v ON vr.cid = v.id
|
|
LEFT OUTER JOIN archive_addit AS addit ON vr.aid = addit.aid
|
|
WHERE vr.aid = ? AND vr.cid=? LIMIT 1`
|
|
_videoRelated = `SELECT v.filename,v.status,vr.aid,vr.index_order,a.title,a.ctime FROM archive_video_relation AS vr LEFT JOIN video AS v ON vr.cid = v.id JOIN archive AS a ON vr.aid = a.id WHERE vr.aid = ?`
|
|
)
|
|
|
|
// VideoByCID get video by cid
|
|
func (d *Dao) VideoByCID(c context.Context, cid int64) (v *archive.Video, err error) {
|
|
row := d.rddb.QueryRow(c, _videoByCid, cid)
|
|
v = &archive.Video{}
|
|
if err = row.Scan(&v.ID, &v.Aid, &v.Title, &v.Desc, &v.Filename, &v.SrcType, &v.Cid, &v.Duration, &v.Filesize, &v.Resolutions, &v.Index, &v.CTime, &v.MTime, &v.Status, &v.Playurl, &v.Attribute, &v.FailCode, &v.XcodeState, &v.WebLink); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
v = nil
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// TxAddRelation insert archive_video_relation.
|
|
func (d *Dao) TxAddRelation(tx *sql.Tx, v *archive.Video) (rows int64, err error) {
|
|
res, err := tx.Exec(_inRelationSQL, v.ID, v.Aid, v.Cid, v.Title, v.Desc, v.Index, v.CTime, v.MTime)
|
|
if err != nil {
|
|
log.Error("d.inRelation.Exec error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpRelation update title and desc on archive_video_relation by vid.
|
|
func (d *Dao) TxUpRelation(tx *sql.Tx, vid int64, title, desc string) (rows int64, err error) {
|
|
res, err := tx.Exec(_upRelationSQL, title, desc, vid)
|
|
if err != nil {
|
|
log.Error("d.upRelation.Exec error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpRelationOrder update index_order on archive_video_relation by vid.
|
|
func (d *Dao) TxUpRelationOrder(tx *sql.Tx, vid int64, index int) (rows int64, err error) {
|
|
res, err := tx.Exec(_upRelationOrderSQL, index, vid)
|
|
if err != nil {
|
|
log.Error("d.upRelationOrder.Exec error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpRelationState update state on archive_video_relation by vid.
|
|
func (d *Dao) TxUpRelationState(tx *sql.Tx, vid int64, state int16) (rows int64, err error) {
|
|
res, err := tx.Exec(_upRelationStateSQL, state, vid)
|
|
if err != nil {
|
|
log.Error("d.upRelationState.Exec error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpWebLink update weblink on video by cid.
|
|
func (d *Dao) TxUpWebLink(tx *sql.Tx, cid int64, weblink string) (rows int64, err error) {
|
|
res, err := tx.Exec(_upVideoLinkSQL, weblink, cid)
|
|
if err != nil {
|
|
log.Error("d.upVideoLink.Exec error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpStatus update status on video by cid.
|
|
func (d *Dao) TxUpStatus(tx *sql.Tx, cid int64, status int16) (rows int64, err error) {
|
|
res, err := tx.Exec(_upVideoStatusSQL, status, cid)
|
|
if err != nil {
|
|
log.Error("d.upVideoStatus.Exec error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpAttr update attribute on video by cid.
|
|
func (d *Dao) TxUpAttr(tx *sql.Tx, cid int64, bit uint, val int32) (rows int64, err error) {
|
|
res, err := tx.Exec(_upVideoAttrSQL, bit, val, bit, cid)
|
|
if err != nil {
|
|
log.Error("d.upVideoAttr.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// VideoPlayurl get video play url
|
|
func (d *Dao) VideoPlayurl(c context.Context, cid int64) (playurl string, err error) {
|
|
row := d.rddb.QueryRow(c, _slPlayurl, cid)
|
|
if err = row.Scan(&playurl); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// NewVideoByID Video get video info by id.
|
|
func (d *Dao) NewVideoByID(c context.Context, id int64) (v *archive.Video, err error) {
|
|
row := d.rddb.QueryRow(c, _newVideoIDSQL, id)
|
|
v = &archive.Video{}
|
|
if err = row.Scan(&v.ID, &v.Filename, &v.Cid, &v.Aid, &v.Title, &v.Desc, &v.SrcType, &v.Duration, &v.Filesize, &v.Resolutions,
|
|
&v.Playurl, &v.FailCode, &v.Index, &v.Attribute, &v.XcodeState, &v.Status, &v.CTime, &v.MTime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
v = nil
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// NewVideoByIDs Video get video info by ids. NOTE: NOT USED
|
|
func (d *Dao) NewVideoByIDs(c context.Context, id []int64) (vs []*archive.Video, err error) {
|
|
rows, err := d.rddb.Query(c, fmt.Sprintf(_newVideoIDsSQL, xstr.JoinInts(id)))
|
|
if err != nil {
|
|
log.Error("db.Query() error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
v := &archive.Video{}
|
|
if err = rows.Scan(&v.ID, &v.Filename, &v.Cid, &v.Aid, &v.Title, &v.Desc, &v.SrcType, &v.Duration, &v.Filesize, &v.Resolutions,
|
|
&v.Playurl, &v.FailCode, &v.Index, &v.Attribute, &v.XcodeState, &v.Status, &v.CTime, &v.MTime); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
vs = append(vs, v)
|
|
}
|
|
return
|
|
}
|
|
|
|
// NewVideosByAid Video get video info by aid.
|
|
func (d *Dao) NewVideosByAid(c context.Context, aid int64) (vs []*archive.Video, err error) {
|
|
rows, err := d.rddb.Query(c, _newVideosAIDSQL, aid)
|
|
if err != nil {
|
|
log.Error("db.Query() error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var avrState, vState int16
|
|
v := &archive.Video{}
|
|
if err = rows.Scan(&v.ID, &v.Filename, &v.Cid, &v.Aid, &v.Title, &v.Desc, &v.SrcType, &v.Duration, &v.Filesize, &v.Resolutions,
|
|
&v.Playurl, &v.FailCode, &v.Index, &v.Attribute, &v.XcodeState, &avrState, &vState, &v.CTime, &v.MTime); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
// 2 state map to 1
|
|
if avrState == archive.VideoStatusDelete {
|
|
v.Status = archive.VideoStatusDelete
|
|
} else {
|
|
v.Status = vState
|
|
}
|
|
vs = append(vs, v)
|
|
}
|
|
return
|
|
}
|
|
|
|
// NewVideoCount get all video duration by aid. NOTE: NOT USED
|
|
func (d *Dao) NewVideoCount(c context.Context, aid int64) (count int, err error) {
|
|
row := d.rddb.QueryRow(c, _newVideoCntSQL, aid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//VideoSrcTypeByIDs video src_type and id map
|
|
func (d *Dao) VideoSrcTypeByIDs(c context.Context, ids []int64) (st map[int64]string, err error) {
|
|
st = map[int64]string{}
|
|
idStr := xstr.JoinInts(ids)
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_slSrcTypeSQL, idStr))
|
|
if err != nil {
|
|
log.Error("VideoSrcTypeByIDs d.db.Query (ids(%v)) error(%v)", idStr, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var (
|
|
id int64
|
|
srcType string
|
|
)
|
|
if err = rows.Scan(&id, &srcType); err != nil {
|
|
log.Error("VideoSrcTypeByIDs rows.Scan (ids(%v)) error(%v)", idStr, err)
|
|
return
|
|
}
|
|
st[id] = srcType
|
|
}
|
|
return
|
|
}
|
|
|
|
//VIDByAIDFilename 根据filename查询视频的vid
|
|
func (d *Dao) VIDByAIDFilename(c context.Context, aid int64, filename string) (vid int64, err error) {
|
|
row := d.db.QueryRow(c, _slVIDSQL, aid, filename)
|
|
if err = row.Scan(&vid); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("VideoRelationIDByFilename row.Scan err(%v) aid(%d) filename(%s)", err, aid, filename)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
//VideoInfo video info
|
|
func (d *Dao) VideoInfo(c context.Context, aid int64, cid int64) (v *archive.VideoInfo, err error) {
|
|
var (
|
|
descFormatID int64
|
|
formatDesc string
|
|
)
|
|
v = &archive.VideoInfo{}
|
|
row := d.rddb.QueryRow(c, _videoInfo, aid, cid)
|
|
if err = row.Scan(&v.ID, &v.AID, &v.Eptitle, &v.Description, &v.CID, &v.Epctime, &v.Filename, &v.XcodeState, &v.Playurl,
|
|
&v.Ctime, &v.Author, &v.Title, &v.Tag, &v.Content, &v.Cover, &v.Typeid, &v.MID, &v.Copyright,
|
|
&v.Source, &v.Dynamic, &descFormatID, &formatDesc); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
v = nil
|
|
} else {
|
|
log.Error("VideoInfo row.Scan error(%v) aid(%d) cid(%d)", err, aid, cid)
|
|
}
|
|
return
|
|
}
|
|
|
|
if descFormatID > 0 {
|
|
v.Content = formatDesc
|
|
}
|
|
return
|
|
}
|
|
|
|
//VideoRelated related videos
|
|
func (d *Dao) VideoRelated(c context.Context, aid int64) (vs []*archive.RelationVideo, err error) {
|
|
var rows *sql.Rows
|
|
vs = []*archive.RelationVideo{}
|
|
if rows, err = d.rddb.Query(c, _videoRelated, aid); err != nil {
|
|
log.Error("VideoRelated d.rddb.Query error(%v) aid(%d)", err, aid)
|
|
return
|
|
}
|
|
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
v := &archive.RelationVideo{}
|
|
if err = rows.Scan(&v.Filename, &v.Status, &v.AID, &v.IndexOrder, &v.Title, &v.Ctime); err != nil {
|
|
log.Error("VideoRelated rows.Scan error(%v) aid(%d)", err, aid)
|
|
return
|
|
}
|
|
|
|
vs = append(vs, v)
|
|
}
|
|
return
|
|
}
|