886 lines
21 KiB
Go
886 lines
21 KiB
Go
package service
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"fmt"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"go-common/app/admin/main/growup/model"
|
||
"go-common/library/database/sql"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
xtime "go-common/library/time"
|
||
"go-common/library/xstr"
|
||
)
|
||
|
||
const (
|
||
_video = 0
|
||
_column = 2
|
||
_bgm = 3
|
||
_passTitle = "创作激励计划(%s)申请成功"
|
||
_rejectTitle = "创作激励计划(%s)申请未通过"
|
||
_passContent = "恭喜，您的创作激励计划(%s)申请已通过！"
|
||
_rejectContent = "您的创作激励计划(%s)申请被驳回，驳回原因：%s。如有任何疑问，请参看帮助中心说明。"
|
||
)
|
||
|
||
func getUpTable(typ int) (table string, err error) {
|
||
switch typ {
|
||
case _video:
|
||
table = "up_info_video"
|
||
case _column:
|
||
table = "up_info_column"
|
||
case _bgm:
|
||
table = "up_info_bgm"
|
||
default:
|
||
err = fmt.Errorf("up type error")
|
||
}
|
||
return
|
||
}
|
||
|
||
func text(typ int, base string) (text string, err error) {
|
||
switch typ {
|
||
case _video:
|
||
text = fmt.Sprintf(base, "视频")
|
||
case _column:
|
||
text = fmt.Sprintf(base, "专栏")
|
||
case _bgm:
|
||
text = fmt.Sprintf(base, "素材")
|
||
default:
|
||
err = fmt.Errorf("up type error")
|
||
}
|
||
return
|
||
}
|
||
|
||
// AddUp add user to creative pgc不区分业务，所有的都加入pgc
|
||
func (s *Service) AddUp(c context.Context, mid int64, accType int) (err error) {
|
||
id, err := s.dao.Blocked(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if id != 0 { // blocked == true
|
||
return ecode.GrowupDisabled
|
||
}
|
||
|
||
nickname, category, err := s.dao.CategoryInfo(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
fans, oac, err := s.dao.Stat(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
err = s.addUpVideo(c, mid, nickname, accType, category, fans, oac)
|
||
if err != nil {
|
||
log.Error("s.addUpVideo mid(%d), error(%v)", mid, err)
|
||
return
|
||
}
|
||
|
||
err = s.addUpColumn(c, mid, nickname, accType, category, fans)
|
||
if err != nil {
|
||
log.Error("s.addUpColumn mid(%d), error(%v)", mid, err)
|
||
}
|
||
|
||
err = s.addUpBgm(c, mid, nickname, accType, category, fans)
|
||
if err != nil {
|
||
log.Error("s.addUpBgm mid(%d), error(%v)", mid, err)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) addUpVideo(c context.Context, mid int64, nickname string, accType, category, fans, oac int) (err error) {
|
||
ups, err := s.dao.UpsVideoInfo(c, fmt.Sprintf("mid = %d and is_deleted = 0", mid))
|
||
if err != nil {
|
||
log.Error("s.dao.UpsInfo mid(%d), error(%v)", mid, err)
|
||
return
|
||
}
|
||
if len(ups) == 1 {
|
||
if ups[0].AccountType == accType {
|
||
return
|
||
}
|
||
}
|
||
up := &model.UpInfo{
|
||
MID: mid,
|
||
Nickname: nickname,
|
||
MainCategory: category,
|
||
Fans: fans,
|
||
AccountType: accType,
|
||
OriginalArchiveCount: oac,
|
||
}
|
||
if accType == 2 { // if account_type is pgc, sign_type update to first publish
|
||
up.SignType = 2
|
||
up.AccountState = 1
|
||
}
|
||
_, err = s.dao.InsertUpVideo(c, up)
|
||
return
|
||
}
|
||
|
||
func (s *Service) addUpColumn(c context.Context, mid int64, nickname string, accType, category, fans int) (err error) {
|
||
ups, err := s.dao.UpsColumnInfo(c, fmt.Sprintf("mid = %d and is_deleted = 0", mid))
|
||
if err != nil {
|
||
log.Error("s.dao.UpsColumnInfo mids(%d), error(%v)", mid, err)
|
||
return
|
||
}
|
||
if len(ups) == 1 {
|
||
if ups[0].AccountType == accType {
|
||
return
|
||
}
|
||
}
|
||
|
||
up := &model.UpInfo{
|
||
MID: mid,
|
||
Nickname: nickname,
|
||
MainCategory: category,
|
||
Fans: fans,
|
||
AccountType: accType,
|
||
}
|
||
|
||
if accType == 2 { // if account_type is pgc, sign_type update to first publish
|
||
up.SignType = 2
|
||
up.AccountState = 1
|
||
}
|
||
_, err = s.dao.InsertUpColumn(c, up)
|
||
return
|
||
}
|
||
|
||
func (s *Service) addUpBgm(c context.Context, mid int64, nickname string, accType, category, fans int) (err error) {
|
||
ups, err := s.dao.UpsBgmInfo(c, fmt.Sprintf("mid=%d AND is_deleted=0", mid))
|
||
if err != nil {
|
||
return
|
||
}
|
||
if len(ups) == 1 {
|
||
if ups[0].AccountType == accType {
|
||
return
|
||
}
|
||
}
|
||
count, err := s.dao.BGMCount(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
up := &model.UpInfo{
|
||
MID: mid,
|
||
Nickname: nickname,
|
||
Fans: fans,
|
||
AccountType: accType,
|
||
BGMs: count,
|
||
}
|
||
if accType == 2 {
|
||
up.SignType = 2
|
||
up.AccountState = 1
|
||
}
|
||
_, err = s.dao.InsertBgmUpInfo(c, up)
|
||
return
|
||
}
|
||
|
||
func (s *Service) getBusinessType(c context.Context, mids []int64, state int) (business map[int64][]int, err error) {
|
||
business = make(map[int64][]int)
|
||
// video
|
||
video, err := s.dao.GetUpInfoByState(c, "up_info_video", mids, state)
|
||
if err != nil {
|
||
log.Error("s.dao.GetUpInfoSigned error(%v)", err)
|
||
return
|
||
}
|
||
// column
|
||
column, err := s.dao.GetUpInfoByState(c, "up_info_column", mids, state)
|
||
if err != nil {
|
||
log.Error("s.dao.GetUpInfoSigned error(%v)", err)
|
||
return
|
||
}
|
||
// bgm
|
||
bgm, err := s.dao.GetUpInfoByState(c, "up_info_bgm", mids, state)
|
||
if err != nil {
|
||
log.Error("s.dao.GetUpInfoSigned error(%v)", err)
|
||
return
|
||
}
|
||
for _, mid := range mids {
|
||
business[mid] = make([]int, 0)
|
||
if _, ok := video[mid]; ok {
|
||
business[mid] = append(business[mid], 0)
|
||
}
|
||
if _, ok := column[mid]; ok {
|
||
business[mid] = append(business[mid], 2)
|
||
}
|
||
if _, ok := bgm[mid]; ok {
|
||
business[mid] = append(business[mid], 3)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// QueryFromUpInfo query up-info in growup plan
|
||
func (s *Service) QueryFromUpInfo(c context.Context, busType int, accType int, states []int64, mid int64, category int, signType int, nickname string, lower int, upper int, from int, limit int, sort string) (ups []*model.UpInfo, total int, err error) {
|
||
table, err := getUpTable(busType)
|
||
if err != nil {
|
||
return
|
||
}
|
||
query := upsInfoStmt(accType, states, mid, category, signType, nickname, lower, upper)
|
||
total, err = s.dao.UpsCount(c, table, query)
|
||
if err != nil {
|
||
return
|
||
}
|
||
sb := sortBy(sort)
|
||
if len(sb) != 0 {
|
||
query += " " + sb
|
||
}
|
||
query += fmt.Sprintf(" LIMIT %d, %d", from, limit)
|
||
switch busType {
|
||
case _video:
|
||
ups, err = s.dao.UpsVideoInfo(c, query)
|
||
if err != nil {
|
||
log.Error("s.dao.UpsInfo mids(%+d), state(%d) error(%v)", mid, states, err)
|
||
return
|
||
}
|
||
case _column:
|
||
ups, err = s.dao.UpsColumnInfo(c, query)
|
||
if err != nil {
|
||
log.Error("s.dao.UpsColumnInfo mids(%+d), state(%d) error(%v)", mid, states, err)
|
||
return
|
||
}
|
||
case _bgm:
|
||
ups, err = s.dao.UpsBgmInfo(c, query)
|
||
if err != nil {
|
||
log.Error("s.dao.UpsBgmInfo mids(%+d), state(%d) error(%v)", mid, states, err)
|
||
return
|
||
}
|
||
}
|
||
|
||
if ups == nil {
|
||
ups = make([]*model.UpInfo, 0)
|
||
}
|
||
|
||
if len(ups) == 0 {
|
||
return
|
||
}
|
||
|
||
mids := make([]int64, 0)
|
||
for _, up := range ups {
|
||
mids = append(mids, up.MID)
|
||
}
|
||
|
||
signedType, err := s.getBusinessType(c, mids, 3)
|
||
if err != nil {
|
||
log.Error("s.getBusinessType error(%v)", err)
|
||
return
|
||
}
|
||
|
||
// credit scores
|
||
scores, err := s.dao.CreditScores(c, mids)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
for _, up := range ups {
|
||
up.SignedType = signedType[up.MID]
|
||
up.CreditScore = scores[up.MID]
|
||
}
|
||
|
||
if len(states) == 1 {
|
||
var other map[int64][]int
|
||
other, err = s.getBusinessType(c, mids, int(states[0]))
|
||
if err != nil {
|
||
log.Error("s.getBusinessType error(%v)", err)
|
||
return
|
||
}
|
||
for _, up := range ups {
|
||
up.OtherType = other[up.MID]
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func sortBy(name string) (sort string) {
|
||
if len(name) == 0 {
|
||
return
|
||
}
|
||
if strings.HasPrefix(name, "-") {
|
||
name = strings.TrimPrefix(name, "-")
|
||
name += " DESC"
|
||
}
|
||
sort = " ORDER BY " + name
|
||
return
|
||
}
|
||
|
||
func upsInfoStmt(accountType int, states []int64, mid int64, category int, signType int, nickname string, lower, upper int) (query string) {
|
||
if accountType > 0 {
|
||
query += "account_type = " + strconv.Itoa(accountType)
|
||
query += " AND "
|
||
}
|
||
if len(states) > 0 {
|
||
query += fmt.Sprintf("account_state IN (%s)", xstr.JoinInts(states))
|
||
query += " AND "
|
||
}
|
||
if mid > 0 {
|
||
query += "mid = " + strconv.FormatInt(mid, 10)
|
||
query += " AND "
|
||
}
|
||
if category != 0 {
|
||
query += "category_id = " + strconv.Itoa(category)
|
||
query += " AND "
|
||
}
|
||
if signType > 0 {
|
||
query += "sign_type = " + strconv.Itoa(signType)
|
||
query += " AND "
|
||
}
|
||
if nickname != "" {
|
||
query += "nickname = " + "\"" + nickname + "\""
|
||
query += " AND "
|
||
}
|
||
query += "fans >= " + strconv.Itoa(lower)
|
||
query += " AND "
|
||
if upper > 0 {
|
||
query += "fans <=" + strconv.Itoa(upper)
|
||
query += " AND "
|
||
}
|
||
query += "is_deleted = 0"
|
||
return
|
||
}
|
||
|
||
// Reject update account state to 4(reject)
|
||
func (s *Service) Reject(c context.Context, typ int, mids []int64, reason string, days int) (err error) {
|
||
table, err := getUpTable(typ)
|
||
if err != nil {
|
||
return
|
||
}
|
||
now := time.Now().Unix()
|
||
_, err = s.dao.Reject(c, table, 4, reason, xtime.Time(now), xtime.Time(now+int64(86400*days)), mids)
|
||
if err != nil {
|
||
return
|
||
}
|
||
title, err := text(typ, _rejectTitle)
|
||
if err != nil {
|
||
return
|
||
}
|
||
var content string
|
||
switch typ {
|
||
case _video:
|
||
content = fmt.Sprintf(_rejectContent, "视频", reason)
|
||
case _column:
|
||
content = fmt.Sprintf(_rejectContent, "专栏", reason)
|
||
case _bgm:
|
||
content = fmt.Sprintf(_rejectContent, "素材", reason)
|
||
}
|
||
pushErr := s.msg.Send(c, "1_14_2", title, content, mids, now)
|
||
if pushErr != nil {
|
||
log.Error("reject push error(%v)", pushErr)
|
||
}
|
||
return
|
||
}
|
||
|
||
// Pass update account state to 3(signed) type 0.video 1.audio 2.column 3.bgm,
|
||
func (s *Service) Pass(c context.Context, mids []int64, typ int) (err error) {
|
||
if len(mids) == 0 {
|
||
return
|
||
}
|
||
table, err := getUpTable(typ)
|
||
if err != nil {
|
||
return
|
||
}
|
||
ms, err := s.dao.Pendings(c, mids, table)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if len(ms) == 0 {
|
||
return
|
||
}
|
||
upM := make(map[int64]struct{})
|
||
for _, m := range ms {
|
||
upM[m] = struct{}{}
|
||
}
|
||
// check other two business
|
||
if typ != _video {
|
||
err = s.removeUnusualUps(c, "up_info_video", upM, ms)
|
||
if err != nil {
|
||
log.Error("s.removeUnusualUps error(%v)", err)
|
||
return
|
||
}
|
||
}
|
||
if typ != _column {
|
||
err = s.removeUnusualUps(c, "up_info_column", upM, ms)
|
||
if err != nil {
|
||
log.Error("s.removeUnusualUps error(%v)", err)
|
||
return
|
||
}
|
||
}
|
||
if typ != _bgm {
|
||
err = s.removeUnusualUps(c, "up_info_bgm", upM, ms)
|
||
if err != nil {
|
||
log.Error("s.removeUnusualUps error(%v)", err)
|
||
return
|
||
}
|
||
}
|
||
if len(upM) == 0 {
|
||
return
|
||
}
|
||
ms = make([]int64, 0)
|
||
for mid := range upM {
|
||
ms = append(ms, mid)
|
||
}
|
||
_, err = s.dao.Pass(c, table, 3, xtime.Time(time.Now().Unix()), ms)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = s.dao.InsertCreditScore(c, midValues(mids))
|
||
if err != nil {
|
||
return
|
||
}
|
||
title, err := text(typ, _passTitle)
|
||
if err != nil {
|
||
return
|
||
}
|
||
msg, err := text(typ, _passContent)
|
||
if err != nil {
|
||
return
|
||
}
|
||
pushErr := s.msg.Send(c, "1_14_1", title, msg, ms, time.Now().Unix())
|
||
if pushErr != nil {
|
||
log.Error("pass push error(%v)", pushErr)
|
||
}
|
||
// add creative task notify
|
||
s.msg.NotifyTask(c, mids)
|
||
return
|
||
}
|
||
|
||
func (s *Service) removeUnusualUps(c context.Context, table string, upM map[int64]struct{}, ms []int64) (err error) {
|
||
mids, err := s.dao.UnusualUps(c, ms, table)
|
||
if err != nil {
|
||
return
|
||
}
|
||
for _, mid := range mids {
|
||
if _, ok := upM[mid]; ok {
|
||
delete(upM, mid)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func midValues(mids []int64) (values string) {
|
||
var buf bytes.Buffer
|
||
for _, mid := range mids {
|
||
buf.WriteString("(")
|
||
buf.WriteString(strconv.FormatInt(mid, 10))
|
||
buf.WriteString(")")
|
||
buf.WriteByte(',')
|
||
}
|
||
if buf.Len() > 0 {
|
||
buf.Truncate(buf.Len() - 1)
|
||
}
|
||
values = buf.String()
|
||
buf.Reset()
|
||
return
|
||
}
|
||
|
||
// Dismiss update account state to 6
|
||
func (s *Service) Dismiss(c context.Context, operator string, typ, oldState int, mid int64, reason string) (err error) {
|
||
var (
|
||
tx *sql.Tx
|
||
now = xtime.Time(time.Now().Unix())
|
||
current int
|
||
drows int64
|
||
crows int64
|
||
)
|
||
|
||
if tx, err = s.dao.BeginTran(c); err != nil {
|
||
return
|
||
}
|
||
|
||
if current, err = s.dao.CreditScore(c, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
// deduct credit score 10
|
||
var drows1, drows2, drows3 int64
|
||
if drows1, err = s.dao.TxDismiss(tx, "up_info_video", 6, oldState, reason, now, now, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if drows2, err = s.dao.TxDismiss(tx, "up_info_column", 6, oldState, reason, now, now, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if drows3, err = s.dao.TxDismiss(tx, "up_info_bgm", 6, oldState, reason, now, now, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
switch typ {
|
||
case _video:
|
||
drows = drows1
|
||
case _column:
|
||
drows = drows2
|
||
case _bgm:
|
||
drows = drows3
|
||
}
|
||
if crows, err = s.txInsertCreditRecord(tx, mid, operator, 6, 10, current-10); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
if drows != crows {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if typ == _video {
|
||
if _, err = s.dao.TxUpdateUpSpyState(tx, 6, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if _, err = s.dao.DelCheatUp(c, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
}
|
||
|
||
_, err = s.dao.TxUpdateCreditScore(tx, mid, current-10)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
if err = tx.Commit(); err != nil {
|
||
log.Error("tx.Commit error(%v)", err)
|
||
return
|
||
}
|
||
pushErr := s.msg.Send(c, "1_14_4", "您的创作激励计划参与资格已被取消", fmt.Sprintf(`您好，根据创作激励计划规则，您因%s，已被永久取消参与创作激励计划的资格。如有任何疑问，请联系客服。`, reason), []int64{mid}, time.Now().Unix())
|
||
if pushErr != nil {
|
||
log.Error("dismiss push error(%v)", pushErr)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) txInsertCreditRecord(tx *sql.Tx, mid int64, operator string, state, deducted, remaining int) (rows int64, err error) {
|
||
// insert to credit record
|
||
cr := &model.CreditRecord{
|
||
MID: mid,
|
||
OperateAt: xtime.Time(time.Now().Unix()),
|
||
Operator: operator,
|
||
Reason: state,
|
||
Deducted: deducted,
|
||
Remaining: remaining,
|
||
}
|
||
return s.dao.TxInsertCreditRecord(tx, cr)
|
||
}
|
||
|
||
// Forbid update account state to 7 and add a n days CD
|
||
func (s *Service) Forbid(c context.Context, operator string, typ, oldState int, mid int64, reason string, days, second int) (err error) {
|
||
var (
|
||
tx *sql.Tx
|
||
now = time.Now().Unix()
|
||
expiredIn = xtime.Time(now + int64(second))
|
||
current int
|
||
frows int64
|
||
crows int64
|
||
)
|
||
|
||
if tx, err = s.dao.BeginTran(c); err != nil {
|
||
return
|
||
}
|
||
|
||
if current, err = s.dao.CreditScore(c, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
var frows1, frows2, frows3 int64
|
||
// deduct credit score 5
|
||
if frows1, err = s.dao.TxForbid(tx, "up_info_video", 7, oldState, reason, xtime.Time(now), expiredIn, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
if frows2, err = s.dao.TxForbid(tx, "up_info_column", 7, oldState, reason, xtime.Time(now), expiredIn, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
if frows3, err = s.dao.TxForbid(tx, "up_info_bgm", 7, oldState, reason, xtime.Time(now), expiredIn, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
switch typ {
|
||
case _video:
|
||
frows = frows1
|
||
case _column:
|
||
frows = frows2
|
||
case _bgm:
|
||
frows = frows3
|
||
}
|
||
// insert credit record
|
||
if crows, err = s.txInsertCreditRecord(tx, mid, operator, 7, 5, current-5); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
if frows != crows {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if typ == _video {
|
||
// update up spy state
|
||
if _, err = s.dao.TxUpdateUpSpyState(tx, 7, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
// del up from cheat fans list
|
||
if _, err = s.dao.DelCheatUp(c, mid); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
}
|
||
|
||
_, err = s.dao.TxUpdateCreditScore(tx, mid, current-5)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
if err = tx.Commit(); err != nil {
|
||
log.Error("tx.Commit error(%v)", err)
|
||
return
|
||
}
|
||
|
||
pushErr := s.msg.Send(c, "1_14_3", "您已被暂停参加创作激励计划", fmt.Sprintf(`根据创作激励计划规则，您因为%s原因被停止参与计划%d天，%d年%d月%d日恢复，如有疑问，请联系客服。`, reason, days, expiredIn.Time().Year(), expiredIn.Time().Month(), expiredIn.Time().Day()), []int64{mid}, time.Now().Unix())
|
||
if pushErr != nil {
|
||
log.Error("forbid push error(%v)", pushErr)
|
||
}
|
||
return
|
||
}
|
||
|
||
// Recovery update (video/column) account state to 3(signed)
|
||
func (s *Service) Recovery(c context.Context, mid int64) (err error) {
|
||
err = s.UpdateUpAccountState(c, "up_info_video", mid, 3)
|
||
if err != nil {
|
||
log.Error("s.UpdateUpAccountState(video) error(%v)", err)
|
||
return
|
||
}
|
||
err = s.UpdateUpAccountState(c, "up_info_column", mid, 3)
|
||
if err != nil {
|
||
log.Error("s.UpdateUpAccountState(column) error(%v)", err)
|
||
return
|
||
}
|
||
err = s.UpdateUpAccountState(c, "up_info_bgm", mid, 3)
|
||
if err != nil {
|
||
log.Error("s.UpdateUpAccountState(bgm) error(%v)", err)
|
||
}
|
||
return
|
||
}
|
||
|
||
// UpdateUpAccountState update video up account state
|
||
func (s *Service) UpdateUpAccountState(c context.Context, table string, mid int64, state int) (err error) {
|
||
_, err = s.dao.UpdateAccountState(c, table, state, mid)
|
||
return
|
||
}
|
||
|
||
// DeleteUp delete up from up_info (update is_deleted = 1)
|
||
func (s *Service) DeleteUp(c context.Context, mid int64) (err error) {
|
||
_, err = s.dao.DelUpInfo(c, "up_info_video", mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = s.dao.DelUpInfo(c, "up_info_column", mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = s.dao.DelUpInfo(c, "up_info_bgm", mid)
|
||
return
|
||
}
|
||
|
||
// Block add to blacklist
|
||
func (s *Service) Block(c context.Context, mid int64) (err error) {
|
||
nickname, categoryID, err := s.dao.CategoryInfo(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
fans, oac, err := s.dao.Stat(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
applyAt, err := s.dao.ApplyAt(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
b := &model.Blocked{
|
||
MID: mid,
|
||
Nickname: nickname,
|
||
OriginalArchiveCount: oac,
|
||
MainCategory: categoryID,
|
||
Fans: fans,
|
||
ApplyAt: applyAt,
|
||
}
|
||
|
||
_, err = s.dao.InsertBlocked(c, b)
|
||
if err != nil {
|
||
return
|
||
}
|
||
// if up in table up_info_video, delete
|
||
_, err = s.dao.DelUpInfo(c, "up_info_video", mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = s.dao.DelUpInfo(c, "up_info_column", mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = s.dao.DelUpInfo(c, "up_info_bgm", mid)
|
||
return
|
||
}
|
||
|
||
// QueryFromBlocked query up-info in black list of growup plan
|
||
func (s *Service) QueryFromBlocked(c context.Context, mid int64, category int, nickname string, lower, upper, from, limit int, sort string) (ups []*model.Blocked, total int, err error) {
|
||
query := queryBlockStmt(mid, category, nickname, lower, upper)
|
||
total, err = s.dao.BlockCount(c, query)
|
||
if err != nil {
|
||
return
|
||
}
|
||
sb := sortBy(sort)
|
||
if len(sb) != 0 {
|
||
query += " " + sb
|
||
}
|
||
query += fmt.Sprintf(" LIMIT %d, %d", from, limit)
|
||
ups, err = s.dao.QueryFromBlocked(c, query)
|
||
if err != nil {
|
||
log.Error("s.dao.QueryFromBlocked error(%v)", err)
|
||
return
|
||
}
|
||
if ups == nil {
|
||
ups = make([]*model.Blocked, 0)
|
||
}
|
||
return
|
||
}
|
||
|
||
func queryBlockStmt(mid int64, categoryID int, nickname string, lower int, upper int) (query string) {
|
||
if mid > 0 {
|
||
query += "mid = " + strconv.FormatInt(mid, 10)
|
||
query += " AND "
|
||
}
|
||
if categoryID != 0 {
|
||
query += "category_id = " + strconv.Itoa(categoryID)
|
||
query += " AND "
|
||
}
|
||
if nickname != "" {
|
||
query += "nickname = " + "\"" + nickname + "\""
|
||
query += " AND "
|
||
}
|
||
query += "fans >= " + strconv.Itoa(lower)
|
||
query += " AND "
|
||
query += "is_deleted = 0"
|
||
if upper > 0 {
|
||
query += " AND "
|
||
query += "fans <=" + strconv.Itoa(upper)
|
||
}
|
||
return
|
||
}
|
||
|
||
// DeleteFromBlocked del blocked and recover up info of video
|
||
func (s *Service) DeleteFromBlocked(c context.Context, mid int64) (err error) {
|
||
_, err = s.dao.DelFromBlocked(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = s.dao.RecUpInfo(c, "up_info_video", mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = s.dao.RecUpInfo(c, "up_info_column", mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = s.dao.RecUpInfo(c, "up_info_bgm", mid)
|
||
return
|
||
}
|
||
|
||
// DelUpAccount del mid from up_account
|
||
func (s *Service) DelUpAccount(c context.Context, mid int64) (err error) {
|
||
_, err = s.dao.DelUpAccount(c, mid)
|
||
return
|
||
}
|
||
|
||
// UpdateUpAccount update up_account
|
||
func (s *Service) UpdateUpAccount(c context.Context, mid int64, isDeleted int, withdrawDate string) (err error) {
|
||
_, err = s.dao.UpdateUpAccount(c, mid, isDeleted, withdrawDate)
|
||
return
|
||
}
|
||
|
||
// CreditRecords get credit records by mid
|
||
func (s *Service) CreditRecords(c context.Context, mid int64) (crs []*model.CreditRecord, err error) {
|
||
return s.dao.CreditRecords(c, mid)
|
||
}
|
||
|
||
// RecoverCreditScore recover credit score
|
||
func (s *Service) RecoverCreditScore(c context.Context, typ int, id, mid int64) (err error) {
|
||
var (
|
||
tx *sql.Tx
|
||
deducted int
|
||
drows int64
|
||
urows int64
|
||
)
|
||
|
||
if tx, err = s.dao.BeginTran(c); err != nil {
|
||
return
|
||
}
|
||
|
||
if deducted, err = s.dao.DeductedScore(c, id); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
// del detucted record by id
|
||
if drows, err = s.dao.TxDelCreditRecord(tx, id); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
// recover credit score
|
||
if urows, err = s.dao.TxRecoverCreditScore(tx, deducted, mid); err != nil {
|
||
return
|
||
}
|
||
|
||
if drows != urows {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if err = tx.Commit(); err != nil {
|
||
log.Error("tx.Commit error(%v)", err)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// ExportUps export ups by query
|
||
func (s *Service) ExportUps(c context.Context, busType, accType int, states []int64, mid int64, category int, signType int, nickname string, lower int, upper int, from int, limit int, sort string) (res []byte, err error) {
|
||
ups, _, err := s.QueryFromUpInfo(c, busType, accType, states, mid, category, signType, nickname, lower, upper, from, limit, sort)
|
||
if err != nil {
|
||
log.Error("s.QueryFromUpInfo error(%v)", err)
|
||
return
|
||
}
|
||
|
||
records := formatUpInfo(ups, states, busType)
|
||
res, err = FormatCSV(records)
|
||
if err != nil {
|
||
log.Error("FormatCSV error(%v)", err)
|
||
}
|
||
return
|
||
}
|
||
|
||
// UpState get up state
|
||
func (s *Service) UpState(c context.Context, mid int64, typ int) (data interface{}, err error) {
|
||
table, err := getUpTable(typ)
|
||
if err != nil {
|
||
return
|
||
}
|
||
state, err := s.dao.GetUpState(c, table, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
data = map[string]interface{}{
|
||
"mid": mid,
|
||
"state": state,
|
||
}
|
||
return
|
||
}
|