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.
885 lines
21 KiB
885 lines
21 KiB
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 |
|
}
|
|
|