463 lines
15 KiB
Go
463 lines
15 KiB
Go
package archive
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"go-common/app/service/main/videoup/model/archive"
|
|
xsql "go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
"go-common/library/xstr"
|
|
)
|
|
|
|
const (
|
|
// insert
|
|
_inArcSQL = "INSERT INTO archive (mid,typeid,title,author,cover,content,tag,attribute,copyright,state,round,pubtime,ctime,mtime,reject_reason) VALUES (?,?,?,?,?,?,?,?,?,-30,0,?,?,?,'')"
|
|
_inAddSQL = "INSERT INTO archive_addit (aid,mission_id,up_from,ipv6,source,order_id,flow_id,advertiser,flow_remark,description,desc_format_id,dynamic) VALUES (?,?,?,?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE mission_id=?,source=?,order_id=?,flow_id=?,advertiser=?,flow_remark=?,description=?,desc_format_id=?,dynamic=?"
|
|
_inAddRdrSQL = "INSERT INTO archive_addit (aid,redirect_url) VALUES (?,?) ON DUPLICATE KEY UPDATE redirect_url=?"
|
|
_inAddReaSQL = "INSERT INTO archive_addit (aid,recheck_reason) VALUES (?,?) ON DUPLICATE KEY UPDATE recheck_reason=?"
|
|
_inAddMissionSQL = "INSERT INTO archive_addit (aid,mission_id) VALUES (?,?) ON DUPLICATE KEY UPDATE mission_id=?"
|
|
// update
|
|
_upArcSQL = "UPDATE archive SET typeid=?,title=?,cover=?,content=?,tag=?,copyright=? WHERE id=?"
|
|
_upArcMidSQL = "UPDATE archive SET mid=?,state=? WHERE id=?"
|
|
_upArcStateSQL = "UPDATE archive SET state=? WHERE id=?"
|
|
_upArcAttrSQL = "UPDATE archive SET attribute=attribute&(~(1<<?))|(?<<?) WHERE id=?"
|
|
_upTagSQL = "UPDATE archive SET tag=? WHERE id=?"
|
|
// select
|
|
_arcSQL = "SELECT id,mid,typeid,copyright,author,title,cover,reject_reason,content,tag,duration,round,attribute,access,state,pubtime,ctime,mtime FROM archive WHERE id=?"
|
|
_arcAddSQL = "SELECT aid,mission_id,from_ip,ipv6,up_from,recheck_reason,redirect_url,source,order_id,flow_id,advertiser,flow_remark,description,desc_format_id,dynamic FROM archive_addit WHERE aid=?"
|
|
_arcMidsSQL = "SELECT id,mid FROM archive WHERE id IN (%s)"
|
|
_arcUpAllSQL = `SELECT id FROM archive WHERE mid = ? AND state != -100 ORDER BY id DESC LIMIT ?,?`
|
|
_arcUpOpenSQL = `SELECT id FROM archive WHERE mid = ? AND (state >= 0 OR state = -6) ORDER BY id DESC LIMIT ?,?`
|
|
_arcUpUnOpenSQL = `SELECT id FROM archive WHERE mid = ? AND state < 0 AND state != -100 AND state != -6 ORDER BY id DESC LIMIT ?,?`
|
|
_arcUpAllCountSQL = "SELECT count(*) FROM archive WHERE mid = ? AND state != -100"
|
|
_arcUpOpenCountSQL = "SELECT count(*) FROM archive WHERE mid = ? AND (state >= 0 OR state = -6)"
|
|
_arcUpUnOpenCountSQL = "SELECT count(*) FROM archive WHERE mid = ? AND state < 0 AND state != -100 AND state != -6"
|
|
_simpleArcSQL = "SELECT id,title,mid FROM archive WHERE id = ?"
|
|
_getRecoSQL = "SELECT reco_aid FROM archive_recommend WHERE state= 0 and aid=? ORDER BY ctime asc"
|
|
_rejectArcsSQL = "SELECT id,mid,title,reject_reason,mtime FROM archive WHERE mid = ? AND state = ? AND mtime > ? ORDER BY mtime DESC LIMIT ?,?"
|
|
_rejectArcsCountSQL = "SELECT count(*) FROM archive WHERE mid = ? AND state = ? AND mtime > ?"
|
|
_delRecoSQL = "UPDATE archive_recommend SET state=1 WHERE aid=?"
|
|
_batchAddRecoSQL = "INSERT IGNORE INTO archive_recommend (aid,reco_aid) VALUES %s on duplicate key update state=0"
|
|
//POI 元数据
|
|
_arcPOISQL = "SELECT data from archive_biz WHERE aid=? AND type= ?"
|
|
_arcVoteSQL = "SELECT data from archive_biz WHERE aid=? AND type= 2"
|
|
_inADDBizSQL = "INSERT INTO archive_biz (aid,type,data) VALUES (?,?,?) ON DUPLICATE KEY UPDATE data=?"
|
|
)
|
|
|
|
// TxAddArchive insert archive.
|
|
func (d *Dao) TxAddArchive(tx *xsql.Tx, a *archive.Archive) (aid int64, err error) {
|
|
var now = time.Now()
|
|
res, err := tx.Exec(_inArcSQL, a.Mid, a.TypeID, a.Title, a.Author, a.Cover, a.Desc, a.Tag, a.Attribute, a.Copyright, now, now, now)
|
|
if err != nil {
|
|
log.Error("d.inArc.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
if aid, err = res.LastInsertId(); err != nil {
|
|
log.Error("res.LastInsertId() error(%v)", err)
|
|
return
|
|
}
|
|
if strings.Contains(xstr.JoinInts(d.c.KeepArc.Aids)+",", strconv.FormatInt(aid, 10)+",") {
|
|
keepAid := aid
|
|
aid, err = d.TxAddArchive(tx, a)
|
|
a.State = archive.StateForbidUpDelete
|
|
a.Mid = d.c.KeepArc.Mid // 内部归属mid
|
|
a.Aid = keepAid // 内部保留aid
|
|
d.TxUpArchiveMid(tx, a)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// TxUpArchive update archive.
|
|
func (d *Dao) TxUpArchive(tx *xsql.Tx, a *archive.Archive) (rows int64, err error) {
|
|
res, err := tx.Exec(_upArcSQL, a.TypeID, a.Title, a.Cover, a.Desc, a.Tag, a.Copyright, a.Aid)
|
|
if err != nil {
|
|
log.Error("d.upArc.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpArchiveMid update archive mid.
|
|
func (d *Dao) TxUpArchiveMid(tx *xsql.Tx, a *archive.Archive) (rows int64, err error) {
|
|
res, err := tx.Exec(_upArcMidSQL, a.Mid, a.State, a.Aid)
|
|
if err != nil {
|
|
log.Error("d.upArcMid.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpArchiveState update Archive state.
|
|
func (d *Dao) TxUpArchiveState(tx *xsql.Tx, aid int64, state int8) (rows int64, err error) {
|
|
res, err := tx.Exec(_upArcStateSQL, state, aid)
|
|
if err != nil {
|
|
log.Error("d.upVideoState.Exec error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpAddit update archive addit.
|
|
func (d *Dao) TxUpAddit(tx *xsql.Tx, aid, missionID, orderID, flowID, descFormatID int64, ipv6 []byte, source, advertiser, flowRemark, desc, dynamic string, upFrom int8) (rows int64, err error) {
|
|
if ipv6 == nil {
|
|
ipv6 = []byte{}
|
|
}
|
|
res, err := tx.Exec(_inAddSQL, aid, missionID, upFrom, ipv6, source, orderID, flowID, advertiser, flowRemark, desc, descFormatID, dynamic, missionID, source, orderID, flowID, advertiser, flowRemark, desc, descFormatID, dynamic)
|
|
if err != nil {
|
|
log.Error("d.inArcAddit.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpArchiveBiz update archive biz.
|
|
func (d *Dao) TxUpArchiveBiz(tx *xsql.Tx, aid, bizType int64, data string) (rows int64, err error) {
|
|
res, err := tx.Exec(_inADDBizSQL, aid, bizType, data, data)
|
|
if err != nil {
|
|
log.Error("d.TxUpArchiveBiz.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpAdditReason update archive recheck_reason
|
|
func (d *Dao) TxUpAdditReason(tx *xsql.Tx, aid int64, reason string) (rows int64, err error) {
|
|
res, err := tx.Exec(_inAddReaSQL, aid, reason, reason)
|
|
if err != nil {
|
|
log.Error("d.inAdditReason.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpAdditRedirect update archive redirect url.
|
|
func (d *Dao) TxUpAdditRedirect(tx *xsql.Tx, aid int64, redirectURL string) (rows int64, err error) {
|
|
res, err := tx.Exec(_inAddRdrSQL, aid, redirectURL, redirectURL)
|
|
if err != nil {
|
|
log.Error("d._inAdditRedirect.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpArcAttr update attribute by aid.
|
|
func (d *Dao) TxUpArcAttr(tx *xsql.Tx, aid int64, bit uint, val int32) (rows int64, err error) {
|
|
res, err := tx.Exec(_upArcAttrSQL, bit, val, bit, aid)
|
|
attSql := fmt.Sprintf("UPDATE archive SET attribute=attribute&(~(1<<%d))|(%d<<%d) WHERE id=%d", bit, val, bit, aid)
|
|
log.Info("aid(%d) attribute update log sql (%s)", aid, attSql)
|
|
if err != nil {
|
|
log.Error("d.upArcAttr.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// TxUpTag update tag by aid.
|
|
func (d *Dao) TxUpTag(tx *xsql.Tx, aid int64, tag string) (rows int64, err error) {
|
|
res, err := tx.Exec(_upTagSQL, tag, aid)
|
|
if err != nil {
|
|
log.Error("d.upTag.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
rows, err = res.RowsAffected()
|
|
return
|
|
}
|
|
|
|
// Archive get a archive by avid.
|
|
func (d *Dao) Archive(c context.Context, aid int64) (a *archive.Archive, err error) {
|
|
var (
|
|
row = d.rddb.QueryRow(c, _arcSQL, aid)
|
|
reason, tag sql.NullString
|
|
)
|
|
a = &archive.Archive{}
|
|
if err = row.Scan(&a.Aid, &a.Mid, &a.TypeID, &a.Copyright, &a.Author, &a.Title, &a.Cover, &reason, &a.Desc, &tag, &a.Duration,
|
|
&a.Round, &a.Attribute, &a.Access, &a.State, &a.PTime, &a.CTime, &a.MTime); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
a = nil
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
a.RejectReason = reason.String
|
|
a.Tag = tag.String
|
|
return
|
|
}
|
|
|
|
// POI get a archive POI by avid.
|
|
func (d *Dao) POI(c context.Context, aid int64) (data []byte, err error) {
|
|
var (
|
|
row = d.rddb.QueryRow(c, _arcPOISQL, aid, archive.BIZPOI)
|
|
)
|
|
if err = row.Scan(&data); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// Vote get a archive Vote by avid.
|
|
func (d *Dao) Vote(c context.Context, aid int64) (data []byte, err error) {
|
|
var (
|
|
row = d.rddb.QueryRow(c, _arcVoteSQL, aid)
|
|
)
|
|
if err = row.Scan(&data); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// Addit get a archive addit by avid.
|
|
func (d *Dao) Addit(c context.Context, aid int64) (ad *archive.Addit, err error) {
|
|
row := d.rddb.QueryRow(c, _arcAddSQL, aid)
|
|
ad = &archive.Addit{}
|
|
if err = row.Scan(&ad.Aid, &ad.MissionID, &ad.FromIP, &ad.IPv6, &ad.UpFrom, &ad.RecheckReason, &ad.RedirectURL, &ad.Source, &ad.OrderID, &ad.FlowID, &ad.Advertiser, &ad.FlowRemark, &ad.Desc, &ad.DescFormatID, &ad.Dynamic); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
ad = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Mids multi get archive mid by aids.
|
|
func (d *Dao) Mids(c context.Context, aids []int64) (mm map[int64]int64, err error) {
|
|
rows, err := d.rddb.Query(c, fmt.Sprintf(_arcMidsSQL, xstr.JoinInts(aids)))
|
|
if err != nil {
|
|
log.Error("db.Query() error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
mm = make(map[int64]int64, len(aids))
|
|
for rows.Next() {
|
|
var aid, mid int64
|
|
if err = rows.Scan(&aid, &mid); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
mm[aid] = mid
|
|
}
|
|
return
|
|
}
|
|
|
|
// ArchivesUpAll get archive all aids by mid.
|
|
func (d *Dao) ArchivesUpAll(c context.Context, mid int64, offset int, ps int) (aids []int64, err error) {
|
|
rows, err := d.rddb.Query(c, _arcUpAllSQL, mid, offset, ps)
|
|
if err != nil {
|
|
log.Error("db.Query() error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var aid int64
|
|
if err = rows.Scan(&aid); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
aids = append(aids, aid)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ArchivesUpOpen get archive open aids by mid.
|
|
func (d *Dao) ArchivesUpOpen(c context.Context, mid int64, offset int, ps int) (aids []int64, err error) {
|
|
rows, err := d.rddb.Query(c, _arcUpOpenSQL, mid, offset, ps)
|
|
if err != nil {
|
|
log.Error("db.Query() error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var aid int64
|
|
if err = rows.Scan(&aid); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
aids = append(aids, aid)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ArchivesUpUnOpen get archive unopen aids by mid.
|
|
func (d *Dao) ArchivesUpUnOpen(c context.Context, mid int64, offset int, ps int) (aids []int64, err error) {
|
|
rows, err := d.rddb.Query(c, _arcUpUnOpenSQL, mid, offset, ps)
|
|
if err != nil {
|
|
log.Error("db.Query() error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var aid int64
|
|
if err = rows.Scan(&aid); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
aids = append(aids, aid)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ArchiveAllUpCount get all archive count by mid.
|
|
func (d *Dao) ArchiveAllUpCount(c context.Context, mid int64) (count int64, err error) {
|
|
row := d.rddb.QueryRow(c, _arcUpAllCountSQL, mid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ArchiveOpenUpCount get open archive count by mid.
|
|
func (d *Dao) ArchiveOpenUpCount(c context.Context, mid int64) (count int64, err error) {
|
|
row := d.rddb.QueryRow(c, _arcUpOpenCountSQL, mid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ArchiveUnOpenUpCount get un open archive count by mid.
|
|
func (d *Dao) ArchiveUnOpenUpCount(c context.Context, mid int64) (count int64, err error) {
|
|
row := d.rddb.QueryRow(c, _arcUpUnOpenCountSQL, mid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// SimpleArchive get a archive by avid.
|
|
func (d *Dao) SimpleArchive(c context.Context, aid int64) (a *archive.SimpleArchive, err error) {
|
|
row := d.rddb.QueryRow(c, _simpleArcSQL, aid)
|
|
a = &archive.SimpleArchive{}
|
|
if err = row.Scan(&a.Aid, &a.Title, &a.Mid); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
a = nil
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Recos fn
|
|
func (d *Dao) Recos(c context.Context, aid int64) (aids []int64, err error) {
|
|
rows, err := d.db.Query(c, _getRecoSQL, aid)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%d) error(%v)", aid, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var aid int64
|
|
if err = rows.Scan(&aid); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
aids = append(aids, aid)
|
|
}
|
|
return
|
|
}
|
|
|
|
// RecoUpdate fn
|
|
func (d *Dao) RecoUpdate(c context.Context, aid int64, recoIDs []int64) (effCnt int64, err error) {
|
|
if len(recoIDs) == 0 {
|
|
_, err = d.db.Query(c, _delRecoSQL, aid)
|
|
if err != nil {
|
|
log.Error("d.db.Query error(%v)| aid (%d)", err, aid)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
_, err = d.db.Query(c, _delRecoSQL, aid)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%d) error(%v)", aid, err)
|
|
return
|
|
}
|
|
var (
|
|
batchVals = make([]string, 0, len(recoIDs))
|
|
)
|
|
for _, recoID := range recoIDs {
|
|
batchVals = append(batchVals, fmt.Sprintf("(%d,%d)", aid, recoID))
|
|
}
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_batchAddRecoSQL, strings.Join(batchVals, ",")))
|
|
if err != nil {
|
|
log.Error("d.db.Exe _batchAddRecoSQL batchVals(%+v) error(%+v)", batchVals, err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UpMissionID update mission_id for archive.
|
|
func (d *Dao) UpMissionID(c context.Context, aa *archive.ArcMissionParam) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, _inAddMissionSQL, aa.AID, aa.MissionID, aa.MissionID)
|
|
if err != nil {
|
|
log.Error("UpMissionID.Exec error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// RejectedArchives list rejected archives
|
|
func (d *Dao) RejectedArchives(c context.Context, mid int64, state, offset, limit int32, start *time.Time) (arcs []*archive.Archive, count int32, err error) {
|
|
row := d.slaveDB.QueryRow(c, _rejectArcsCountSQL, mid, state, start)
|
|
if err = row.Scan(&count); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
if count == 0 {
|
|
return
|
|
}
|
|
rows, err := d.slaveDB.Query(c, _rejectArcsSQL, mid, state, start, offset, limit)
|
|
if err != nil {
|
|
log.Error("db.Query error(%v)", err)
|
|
return
|
|
}
|
|
for rows.Next() {
|
|
a := archive.Archive{}
|
|
if err = rows.Scan(&a.Aid, &a.Mid, &a.Title, &a.RejectReason, &a.MTime); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
arcs = append(arcs, &a)
|
|
}
|
|
return
|
|
}
|