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.
462 lines
15 KiB
462 lines
15 KiB
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 |
|
}
|
|
|