221 lines
6.7 KiB
Go
221 lines
6.7 KiB
Go
package dao
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"go-common/app/job/main/growup/model"
|
|
|
|
"go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
xtime "go-common/library/time"
|
|
"go-common/library/xstr"
|
|
)
|
|
|
|
const (
|
|
_upStateByMID = "SELECT account_state FROM up_info_video WHERE mid = ? LIMIT 1"
|
|
_upInfoVideoSQL = "SELECT id,mid,nickname,signed_at,fans,total_play_count,account_type,account_state,credit_score,is_deleted FROM up_info_video WHERE id > ? ORDER BY id LIMIT ?"
|
|
|
|
_upsState = "SELECT mid,expired_in FROM %s WHERE account_state = ?"
|
|
_upsStateType = "SELECT mid,expired_in FROM %s WHERE account_type = ? AND account_state = ?"
|
|
_updateAccountState = "UPDATE %s SET account_state = ? WHERE mid IN (%s)"
|
|
|
|
// select count(*)
|
|
_signedDayUpsSQL = "SELECT COUNT(*) FROM up_info_video WHERE account_state = 3 AND is_deleted = 0 AND signed_at < ? AND signed_at >= ?"
|
|
_signedAllUpsSQL = "SELECT COUNT(*) FROM up_info_video WHERE account_state = 3 AND signed_at < ? AND is_deleted = 0"
|
|
|
|
_videoApplyCountSQL = "SELECT COUNT(*) FROM up_info_video WHERE apply_at >= ? AND apply_at < ?"
|
|
|
|
_upBaseInfoSQL = "SELECT mid,fans,play,avs_origin,avs FROM up_base_statistics WHERE mid IN (%s)"
|
|
_insertUpInfoSQL = "INSERT INTO up_info_video(mid,fans,total_play_count,original_archive_count,avs) VALUES %s ON DUPLICATE KEY UPDATE fans=VALUES(fans),total_play_count=VALUES(total_play_count),original_archive_count=VALUES(original_archive_count),avs=VALUES(avs)"
|
|
_uidSQL = "SELECT id,mid FROM up_info_video WHERE id > ? ORDER BY id LIMIT ?"
|
|
_creditScoreByMIDSQL = "SELECT mid, score FROM credit_score WHERE mid IN (%s)"
|
|
)
|
|
|
|
// GetUpStateByMID get up account_state
|
|
func (d *Dao) GetUpStateByMID(c context.Context, mid int64) (state int, err error) {
|
|
err = d.db.QueryRow(c, _upStateByMID, mid).Scan(&state)
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
state = 0
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetUpCreditScore get up credit score
|
|
func (d *Dao) GetUpCreditScore(c context.Context, mids []int64) (scores map[int64]int64, err error) {
|
|
scores = make(map[int64]int64)
|
|
if len(mids) == 0 {
|
|
return
|
|
}
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_creditScoreByMIDSQL, xstr.JoinInts(mids)))
|
|
if err != nil {
|
|
log.Error("db Query GetUpCreditScore error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var mid, score int64
|
|
err = rows.Scan(&mid, &score)
|
|
if err != nil {
|
|
log.Error("rows scan error(%v)", err)
|
|
return
|
|
}
|
|
scores[mid] = score
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpInfoVideo get up_info_video
|
|
func (d *Dao) UpInfoVideo(c context.Context, offset int64, limit int64) (last int64, ups map[int64]*model.UpInfoVideo, err error) {
|
|
ups = make(map[int64]*model.UpInfoVideo)
|
|
rows, err := d.db.Query(c, _upInfoVideoSQL, offset, limit)
|
|
if err != nil {
|
|
log.Error("db Query UpInfoVideo error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
up := &model.UpInfoVideo{}
|
|
err = rows.Scan(&last, &up.MID, &up.Nickname, &up.SignedAt, &up.Fans, &up.TotalPlayCount, &up.AccountType, &up.AccountState, &up.CreditScore, &up.IsDeleted)
|
|
if err != nil {
|
|
log.Error("rows scan error(%v)", err)
|
|
return
|
|
}
|
|
ups[up.MID] = up
|
|
}
|
|
return
|
|
}
|
|
|
|
// MIDsByState get mids and expired
|
|
func (d *Dao) MIDsByState(c context.Context, state int, table string) (result map[int64]xtime.Time, err error) {
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_upsState, table), state)
|
|
if err != nil {
|
|
log.Error("d.MIDsByState Query error(%v)", err)
|
|
return
|
|
}
|
|
|
|
result = make(map[int64]xtime.Time)
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var mid int64
|
|
var exp xtime.Time
|
|
err = rows.Scan(&mid, &exp)
|
|
if err != nil {
|
|
log.Error("rows scan error (%v)", err)
|
|
return
|
|
}
|
|
result[mid] = exp
|
|
}
|
|
return
|
|
}
|
|
|
|
// MIDsByStateType get mids and expired by account_type and account_state
|
|
func (d *Dao) MIDsByStateType(c context.Context, typ int, state int, table string) (result map[int64]xtime.Time, err error) {
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_upsStateType, table), typ, state)
|
|
if err != nil {
|
|
log.Error("d.MIDsByStateType Query error(%v)", err)
|
|
return
|
|
}
|
|
|
|
result = make(map[int64]xtime.Time)
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var mid int64
|
|
var exp xtime.Time
|
|
err = rows.Scan(&mid, &exp)
|
|
if err != nil {
|
|
log.Error("rows scan error (%v)", err)
|
|
return
|
|
}
|
|
result[mid] = exp
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpdateAccountState update account state
|
|
func (d *Dao) UpdateAccountState(c context.Context, state int, mids []int64, table string) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_updateAccountState, table, xstr.JoinInts(mids)), state)
|
|
if err != nil {
|
|
log.Error("d.UpdateAccountState Exec error (%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// GetDateSignedUps get date signed ups
|
|
func (d *Dao) GetDateSignedUps(c context.Context, startAt time.Time, endAt time.Time) (count int, err error) {
|
|
row := d.db.QueryRow(c, _signedDayUpsSQL, endAt, startAt)
|
|
if err = row.Scan(&count); err != nil {
|
|
log.Error("dao.GetDateSignedUps error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetAllSignedUps get all signed ups.
|
|
func (d *Dao) GetAllSignedUps(c context.Context, data time.Time) (count int, err error) {
|
|
row := d.db.QueryRow(c, _signedAllUpsSQL, data.Add(24*time.Hour))
|
|
if err = row.Scan(&count); err != nil {
|
|
log.Error("dao.GetAllSignedUps error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetVideoApplyUpCount get up_info_video count
|
|
func (d *Dao) GetVideoApplyUpCount(c context.Context, startAt, endAt time.Time) (count int, err error) {
|
|
row := d.db.QueryRow(c, _videoApplyCountSQL, startAt, endAt)
|
|
err = row.Scan(&count)
|
|
return
|
|
}
|
|
|
|
// GetUpBaseInfo get up_base_info
|
|
func (d *Dao) GetUpBaseInfo(c context.Context, mid []int64) (bs []*model.UpBaseInfo, err error) {
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_upBaseInfoSQL, xstr.JoinInts(mid)))
|
|
if err != nil {
|
|
log.Error("dao.GetUpBaseInfo error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
b := &model.UpBaseInfo{}
|
|
err = rows.Scan(&b.MID, &b.Fans, &b.TotalPlayCount, &b.OriginalArchiveCount, &b.Avs)
|
|
if err != nil {
|
|
log.Error("rows scan error(%v)", err)
|
|
return
|
|
}
|
|
bs = append(bs, b)
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpdateUpInfo update up_info_video
|
|
func (d *Dao) UpdateUpInfo(c context.Context, values string) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_insertUpInfoSQL, values))
|
|
if err != nil {
|
|
log.Error("dao.UpdateUpInfo error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// MIDs get mids from up_info_viode
|
|
func (d *Dao) MIDs(c context.Context, offset, limit int64) (last int64, mids []int64, err error) {
|
|
rows, err := d.db.Query(c, _uidSQL, offset, limit)
|
|
if err != nil {
|
|
log.Error("dao.GetUpBaseInfo error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var mid int64
|
|
err = rows.Scan(&last, &mid)
|
|
if err != nil {
|
|
log.Error("rows scan error(%v)", err)
|
|
return
|
|
}
|
|
mids = append(mids, mid)
|
|
}
|
|
return
|
|
}
|