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.
746 lines
21 KiB
746 lines
21 KiB
package service |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"fmt" |
|
"strconv" |
|
"time" |
|
|
|
"go-common/app/interface/main/answer/conf" |
|
"go-common/app/interface/main/answer/model" |
|
accoutCli "go-common/app/service/main/account/api" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
"go-common/library/log/infoc" |
|
"go-common/library/net/metadata" |
|
"go-common/library/text/translate/chinese" |
|
) |
|
|
|
var ( |
|
// concat type type_id : _pendantIDNameMap id |
|
_rankIDPendantMap = map[int]int{ |
|
// 11: 6, |
|
// 12: 7, |
|
// 14: 8, |
|
// 15: 9, |
|
// 17: 11, |
|
// 27: 10, |
|
// 28: 12, |
|
// 41: 13, |
|
// 9: 14, |
|
27: 124, |
|
28: 127, |
|
31: 126, |
|
29: 123, |
|
18: 121, |
|
8: 125, |
|
19: 129, |
|
15: 130, |
|
7: 128, |
|
} |
|
|
|
// concat pendant |
|
_pendantIDNameMap = map[int]string{ |
|
5: "哔哩王", |
|
6: "声控", |
|
7: "追番党", |
|
8: "调教师", |
|
9: "动感DJ", |
|
10: "局座", |
|
11: "攻略组", |
|
12: "学霸", |
|
13: "迷影者", |
|
14: "全明星", |
|
122: "哔哩王", |
|
124: "声控", |
|
127: "追番党", |
|
126: "调教师", |
|
123: "动感DJ", |
|
121: "局座", |
|
125: "攻略组", |
|
129: "学霸", |
|
130: "迷影者", |
|
128: "全明星", |
|
} |
|
|
|
// 老挂件id对应新挂件id |
|
_oldPIDToNewMap = map[int]int{ |
|
5: 122, |
|
6: 124, |
|
7: 127, |
|
8: 126, |
|
9: 123, |
|
10: 121, |
|
11: 125, |
|
12: 129, |
|
13: 130, |
|
14: 128, |
|
122: 122, |
|
124: 124, |
|
127: 127, |
|
126: 126, |
|
123: 123, |
|
121: 121, |
|
125: 125, |
|
129: 129, |
|
130: 130, |
|
128: 128, |
|
} |
|
|
|
_pendantIDImgMap = map[int]string{ |
|
122: "/bfs/face/67ed957ae789852bcc59b1c1e3097ea23179f793.png", |
|
124: "/bfs/face/ff61b405cdcf8f7860c67293218340aeaed6e233.png", |
|
127: "/bfs/face/369098093a07af821b767eac44b51f97ee8501c5.png", |
|
126: "/bfs/face/9e775c3ebe224a774d4b2f99fd5be342eb6f51ec.png", |
|
123: "/bfs/face/939fa982d8b1c1fd653de5c7890db03d62e87226.png", |
|
121: "/bfs/face/7f6b5cb11ea7abd2e05b04f65f190dfb10456554.png", |
|
125: "/bfs/face/90cc47168e40326dc934fad7b9abb82aa748d6ac.png", |
|
129: "/bfs/face/42869dad53926c75e3010150c15b16a8925fb268.png", |
|
130: "/bfs/face/3d5ee491c125bf452b2dbec082dbb8209b645316.png", |
|
128: "/bfs/face/b53937110e8009a720e2426ea69c449483718b3c.png", |
|
} |
|
|
|
// 125: "攻略组",--> 题库(8,9,12,13,14) |
|
// 130: "迷影者",--> 题库(15,16,17) |
|
// 121: "局座",--> 题库(18) |
|
// 129: "学霸",--> 题库(19,20,21,22,23,24,25,26) |
|
// 124: "声控",--> 题库(27) |
|
// 127: "追番党",--> 题库(28) |
|
// 126: "调教师",--> 题库(31) |
|
// 123: "动感DJ",--> 题库(30,29) |
|
// 128: "全明星",--> 题库(35,34,33,32) |
|
// 122: "哔哩王", |
|
|
|
// 分区合并归类 |
|
_typeIDMap = map[int][]int{ |
|
// 11: {12, 13}, // 动漫作品+动漫内容 |
|
// 15: {15, 16}, // ACG+三次元音乐 |
|
// 17: {17, 18, 19, 20, 21, 22, 23, 24, 25}, // 各类游戏 |
|
// 28: {28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 7, 8}, // 科学技术+音频+视频技术 |
|
// 41: {41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52}, // 各类影视剧 |
|
8: {8, 9, 12, 13, 14}, // 游戏 |
|
19: {19, 20, 21, 22, 23, 24, 25, 26}, // 科技 |
|
15: {15, 16, 17}, // 影视 |
|
29: {29, 30}, // 音乐 |
|
7: {7, 35, 34, 33, 32}, // 鬼畜+流行前线 |
|
} |
|
|
|
// 兼容账号rank错误 |
|
_rank0 = int32(0) |
|
) |
|
|
|
const ( |
|
_unBindTel = 0 |
|
) |
|
|
|
// ProCheck check second step questions |
|
func (s *Service) ProCheck(c context.Context, mid int64, ids []int64, ansHash map[int64]string, lang string) (hid int64, err error) { |
|
var now = time.Now() |
|
if len(ids) != s.c.Answer.ProNum { |
|
err = ecode.AnswerQsNumErr |
|
return |
|
} |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
ah, err := s.history(c, mid) |
|
if err != nil || ah == nil || ah.StartTime.Add(s.answerDuration()).Before(now) || ah.Score != 0 { |
|
err = ecode.AnswerBaseNotPassed |
|
return |
|
} |
|
if (now.Unix() - ah.StepTwoStartTime.Unix()) < s.c.Answer.BlockedTimestamp { |
|
s.answerDao.SetBlockCache(c, mid) |
|
log.Error("member user answer block, time space(%v)", now.Unix()-ah.StepTwoStartTime.Unix()) |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
qsidsMc, err := s.answerDao.IdsCache(c, mid, model.Q) |
|
if err != nil { |
|
err = ecode.AnswerMidCacheQidsErr |
|
log.Error("s.answerDao.IdsCache(%d) err(%v) ", mid, err) |
|
return |
|
} |
|
ok, err := s.checkQsIDs(c, ids, mid, qsidsMc, s.c.Answer.ProNum) |
|
if !ok { |
|
return |
|
} |
|
errIds, rc, err := s.checkAns(c, mid, ids, ansHash, lang, s.c.Answer.ProNum) |
|
if err != nil { |
|
return |
|
} |
|
rcJSON, err := json.Marshal(rc) |
|
if err != nil { |
|
log.Error("json.Marshal(%v) error(%v)", rc, err) |
|
return |
|
} |
|
total := s.c.Answer.BaseNum + s.c.Answer.ProNum + int(ah.StepExtraScore) |
|
score := total - len(errIds) |
|
ahDB := &model.AnswerHistory{ |
|
ID: ah.ID, |
|
Hid: ah.Hid, |
|
CompleteResult: string(rcJSON), |
|
CompleteTime: now, |
|
Score: int8(score), |
|
IsFirstPass: 0, |
|
} |
|
log.Info("user: %d, score:%d, his: %v", mid, score, ahDB) |
|
member, err := s.accInfo(c, mid) |
|
if err == nil && member != nil && score >= model.Score60 && member.Rank == model.UserInfoRank { |
|
ahDB.IsFirstPass = 1 |
|
} |
|
ahDB.RankID = s.pendant(c, ahDB, mid, metadata.String(c, metadata.RemoteIP), rc) |
|
r, err := s.answerDao.SetHistory(c, mid, ahDB) |
|
if err != nil || r != 1 { |
|
return |
|
} |
|
ah.CompleteResult = ahDB.CompleteResult |
|
ah.CompleteTime = ahDB.CompleteTime |
|
ah.Score = ahDB.Score |
|
ah.IsFirstPass = ahDB.IsFirstPass |
|
ah.RankID = ahDB.RankID |
|
ah.Mtime = now |
|
s.userActionLog(mid, model.ProCheck, ah) |
|
if ahDB.Score >= model.Score60 && ahDB.RankID > 0 { |
|
if hid, _, err = s.answerDao.PendantHistory(c, mid); err != nil { |
|
return |
|
} |
|
if hid <= 0 { |
|
s.answerDao.AddPendantHistory(c, mid, ah.Hid) |
|
} |
|
} |
|
hid = ah.Hid |
|
s.missch.Do(c, func(ctx context.Context) { |
|
s.answerDao.DelHistoryCache(ctx, mid) |
|
s.answerDao.DelIdsCache(ctx, mid, model.Q) |
|
}) |
|
return |
|
} |
|
|
|
// CheckBase check base question all |
|
func (s *Service) CheckBase(c context.Context, mid int64, ids []int64, ansHas map[int64]string, lang string) (res *model.AnsCheck, err error) { |
|
var ( |
|
now = time.Now() |
|
errIds []int64 |
|
profileReply *accoutCli.ProfileReply |
|
) |
|
// 检查手机绑定 |
|
if profileReply, err = s.accountSvc.Profile3(c, &accoutCli.MidReq{Mid: mid}); err != nil || profileReply == nil || profileReply.Profile == nil { |
|
log.Error("s.accRPC.Profile3(%d) err(%+v)", mid, err) |
|
err = ecode.AnswerAccCallErr |
|
return |
|
} |
|
if profileReply.Profile.TelStatus == _unBindTel { |
|
err = ecode.AnswerNeedBindTel |
|
return |
|
} |
|
if len(ids) < s.c.Answer.BaseNum { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
res = &model.AnsCheck{} |
|
at, ok := s.checkTime(c, mid, now) |
|
if !ok { |
|
err = ecode.AnswerTimeExpire |
|
return |
|
} |
|
if len(ids) != s.c.Answer.BaseNum { |
|
err = ecode.AnswerQsNumErr |
|
return |
|
} |
|
qsIdsMc, err := s.answerDao.IdsCache(c, mid, model.Q) |
|
if err != nil { |
|
log.Error("s.answerDao.IdsCache(%d) err(%v) ", mid, err) |
|
err = ecode.AnswerMidCacheQidsErr |
|
return |
|
} |
|
ok, err = s.checkQsIDs(c, ids, mid, qsIdsMc, s.c.Answer.BaseNum) |
|
if err != nil || !ok { |
|
return |
|
} |
|
errIds, _, err = s.checkAns(c, mid, ids, ansHas, lang, s.c.Answer.BaseNum) |
|
res.QidList = errIds |
|
if err != nil { |
|
return |
|
} |
|
if len(errIds) > 0 { |
|
return |
|
} |
|
s.basePass(c, mid, at, now) |
|
res.Pass = true |
|
return |
|
} |
|
|
|
// Captcha get question captcha |
|
func (s *Service) Captcha(c context.Context, mid int64, clientType string, newCaptcha int) (res *model.ProcessRes, err error) { |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
ah, err := s.history(c, mid) |
|
if err != nil || ah == nil || ah.Score == model.Score0 { |
|
log.Info("answer Captcha(%d) answer history is null or score is zero err(%v) ", mid, err) |
|
if ah != nil { |
|
if ah.StepOneCompleteTime == 0 { |
|
err = ecode.AnswerBaseNotPassed |
|
return |
|
} |
|
if ah.StepExtraCompleteTime == 0 { |
|
err = ecode.AnswerExtraNoPass |
|
return |
|
} |
|
} |
|
err = ecode.AnswerProNoPass |
|
return |
|
} |
|
if ah.IsPassCaptcha == model.CaptchaPass { |
|
err = ecode.AnswerCaptchaPassed |
|
return |
|
} |
|
if !conf.Conf.Answer.Captcha { |
|
if res, err = s.preProcess(c, mid, metadata.String(c, metadata.RemoteIP), clientType, newCaptcha); err == nil { |
|
return |
|
} |
|
log.Error("s.preProcess(%d,%s,%d) err:%+v", mid, clientType, newCaptcha, err) |
|
} |
|
var token, url string |
|
if token, url, err = s.answerDao.Captcha(c); err != nil { |
|
return |
|
} |
|
res = &model.ProcessRes{ |
|
Token: token, |
|
URL: url, |
|
CaptchaType: model.BiliCaptcha, |
|
} |
|
return |
|
} |
|
|
|
// Validate check question captcha |
|
func (s *Service) Validate(c context.Context, challenge, validate, seccode, clientType string, success int, mid int64, |
|
cookie, captchaType string, comargs map[string]string) (res *model.AnsCheck, err error) { |
|
var now = time.Now() |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
res = &model.AnsCheck{} |
|
ah, err := s.history(c, mid) |
|
log.Info(" Validate ah (%d) res(%v) ", mid, ah) |
|
if err != nil || ah == nil || ah.Score == model.Score0 { |
|
log.Info("answer Validate(%d) answer history is null or score is zero err(%v) ", mid, err) |
|
if ah != nil { |
|
if ah.StepOneCompleteTime == 0 { |
|
err = ecode.AnswerBaseNotPassed |
|
return |
|
} |
|
if ah.StepExtraCompleteTime == 0 { |
|
err = ecode.AnswerExtraNoPass |
|
return |
|
} |
|
} |
|
err = ecode.AnswerProNoPass |
|
return |
|
} |
|
// passed go to next page |
|
if ah.IsPassCaptcha == model.CaptchaPass { |
|
res.Pass = true |
|
res.HistoryID = ah.Hid |
|
return |
|
} |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
switch captchaType { |
|
case model.BiliCaptcha: |
|
if err = s.answerDao.Verify(c, validate, seccode, ip); err != nil { |
|
log.Error("answerDao.Verify(%s,%s,%s) error:%+v", validate, seccode, ip, err) |
|
return |
|
} |
|
res.Pass = true |
|
default: |
|
if ok := s.validate(c, challenge, validate, seccode, clientType, ip, success, mid); !ok { |
|
log.Error("Validate validate(%v,%v,%v,%v,%v,%d) error(%v)", challenge, validate, seccode, clientType, success, mid, err) |
|
err = ecode.AnswerGeetestVaErr |
|
return |
|
} |
|
res.Pass = true |
|
} |
|
member, err := s.accInfo(c, mid) |
|
if err != nil || member == nil { |
|
log.Error("Validate accInfo(%d) info is null error(%v)", mid, err) |
|
return |
|
} |
|
if _, err = s.answerDao.UpdateCaptcha(c, ah.ID, ah.Mid, model.CaptchaPass); err != nil { |
|
log.Error("s.answerDao.UpdateCaptcha error (%v) ", err) |
|
err = ecode.ServerErr |
|
return |
|
} |
|
ah.IsPassCaptcha = model.CaptchaPass |
|
ah.Mtime = now |
|
s.userActionLog(mid, model.Captcha, ah) |
|
s.answerDao.DelHistoryCache(c, mid) |
|
log.Info(" Validate member (%v) rank(%d) ", ah, member.Rank) |
|
if ah.Score >= model.Score60 && (member.Rank == model.UserInfoRank || member.Rank == _rank0) { |
|
log.Info(" beFormal in (%d) ", mid) |
|
s.sendData(c, comargs, ah, ip) |
|
if err = s.accountDao.BeFormal(c, mid, ip); err != nil { |
|
log.Error(" beFormal fail(%d) err(%v)", mid, err) |
|
s.addRetryBeFormal(&model.Formal{Mid: mid, IP: ip}) |
|
err = ecode.AnswerFormalFailed |
|
return |
|
} |
|
s.answerDao.UpdateLevel(c, ah.ID, ah.Mid, 1, 1) |
|
ah.IsFirstPass = 1 |
|
ah.PassedLevel = 1 |
|
ah.Mtime = now |
|
s.userActionLog(mid, model.Level, ah) |
|
s.answerDao.DelHistoryCache(c, mid) |
|
s.PendantRec(c, &model.ReqPendant{HID: ah.Hid, MID: mid}) |
|
} |
|
res.HistoryID = ah.Hid |
|
return |
|
} |
|
|
|
// checkQsIDs check question id param. |
|
func (s *Service) checkQsIDs(c context.Context, ids []int64, mid int64, qsIdsMc []int64, qs int) (ok bool, err error) { |
|
if qsIdsMc == nil { |
|
log.Error("CheckBase.qsIdsMc is nil (%d,%v) )", mid, qsIdsMc) |
|
err = ecode.AnswerMidCacheQidsErr |
|
return |
|
} |
|
if len(ids) != qs { |
|
err = ecode.AnswerQsNumErr |
|
return |
|
} |
|
qidMap := map[int64]bool{} |
|
for _, v := range qsIdsMc { |
|
qidMap[v] = true |
|
} |
|
i := 0 |
|
for _, v := range ids { |
|
if qidMap[v] { |
|
i++ |
|
} |
|
} |
|
if i == qs { |
|
ok = true |
|
} else { |
|
err = ecode.AnswerQidDiffRequestErr |
|
} |
|
return |
|
} |
|
|
|
// checkAns check question ans. |
|
func (s *Service) checkAns(c context.Context, mid int64, ids []int64, ansHash map[int64]string, lang string, count int) (errIds []int64, rc map[int8]int, err error) { |
|
qs, err := s.answerDao.ByIds(c, ids) |
|
if err != nil || qs == nil || len(qs) != count { |
|
log.Error("checkAns.qs is nil (%v,%v) error(%v)", ids, qs, err) |
|
err = ecode.AnswerMidDBQueErr |
|
return |
|
} |
|
errIds = []int64{} |
|
rc = make(map[int8]int) |
|
for _, q := range qs { |
|
if lang == model.LangZhTW { |
|
q.Ans[0] = chinese.Convert(c, q.Ans[0]) |
|
} |
|
if h := s.ansHash(mid, q.Ans[0]); h != ansHash[q.ID] { |
|
errIds = append(errIds, q.ID) |
|
} else { |
|
rc[q.TypeID]++ |
|
} |
|
} |
|
return |
|
} |
|
|
|
// basePass base question pass. |
|
func (s *Service) basePass(c context.Context, mid int64, at *model.AnswerTime, now time.Time) { |
|
h := &model.AnswerHistory{ |
|
Mid: mid, |
|
StartTime: at.Stime, |
|
StepOneErrTimes: at.Etimes, |
|
StepOneCompleteTime: now.Unix() - at.Stime.Unix(), |
|
Ctime: now, |
|
Mtime: now, |
|
} |
|
r, hid, err := s.answerDao.AddHistory(c, mid, h) |
|
if err != nil || r != 1 { |
|
log.Error("answerDao.AddHistory r !=1 (%d,%v) error(%v)", mid, h, err) |
|
return |
|
} |
|
h.Hid, _ = strconv.ParseInt(hid, 10, 64) |
|
s.userActionLog(mid, model.BasePass, h) |
|
s.answerDao.DelHistoryCache(c, mid) |
|
s.answerDao.DelExpireCache(c, mid) |
|
s.answerDao.DelIdsCache(c, mid, model.Q) |
|
} |
|
|
|
// setPendant set pendant. |
|
func (s *Service) pendant(c context.Context, ah *model.AnswerHistory, mid int64, ip string, rc map[int8]int) (rankID int) { |
|
var ( |
|
ok bool |
|
ht int |
|
typeIDScore = map[int8]int{ // key:_typeIDMap`key,value:Score |
|
8: 0, |
|
19: 0, |
|
15: 0, |
|
29: 0, |
|
7: 0, |
|
} |
|
) |
|
if ah.Score == model.FullScore { |
|
return model.RankTop // 122: "哔哩王", |
|
} |
|
for k, v := range rc { |
|
switch k { |
|
case 8, 9, 12, 13, 14: // 游戏 125: "攻略组",--> 题库(8,9,12,13,14) |
|
typeIDScore[8] += v |
|
case 15, 16, 17: // 影视 130: "迷影者",--> 题库(15,16,17) |
|
typeIDScore[15] += v |
|
case 19, 20, 21, 22, 23, 24, 25, 26: // 科技 129: "学霸",--> 题库(19,20,21,22,23,24,25,26) |
|
typeIDScore[19] += v |
|
case 29, 30: // 音乐 123: "动感DJ",--> 题库(30,29) |
|
typeIDScore[29] += v |
|
case 7, 35, 34, 33, 32: // 鬼畜+流行前线 128: "全明星",--> 题库(35,34,33,32) |
|
typeIDScore[7] += v |
|
default: |
|
// 121: "局座",--> 题库(18) |
|
// 124: "声控",--> 题库(27) |
|
// 127: "追番党",--> 题库(28) |
|
// 126: "调教师",--> 题库(31) |
|
typeIDScore[k] += v |
|
} |
|
} |
|
score := 0 |
|
for k, v := range typeIDScore { |
|
if score < v { |
|
score = v |
|
ht = int(k) |
|
} |
|
} |
|
rankID, ok = _rankIDPendantMap[ht] |
|
if !ok { |
|
log.Warn("user(%d),pendant() rankId(%d) result:%+v ", mid, _rankIDPendantMap[ht], rc) |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) checkAnswerBlock(c context.Context, mid int64) (block bool) { |
|
block, _ = s.answerDao.CheckBlockCache(c, mid) |
|
return |
|
} |
|
|
|
func (s *Service) sendData(c context.Context, comargs map[string]string, ah *model.AnswerHistory, ip string) { |
|
s.promBeFormal.Incr("count") |
|
// add report bigdata log |
|
ans := []interface{}{ |
|
strconv.FormatInt(ah.StepOneCompleteTime, 10), |
|
ah.CompleteResult, |
|
strconv.FormatInt(ah.CompleteTime.Unix()-ah.StepTwoStartTime.Unix(), 10), |
|
fmt.Sprintf("%d", ah.Score), |
|
strconv.FormatInt(time.Now().Unix(), 10), |
|
} |
|
s.missch.Do(c, func(ctx context.Context) { |
|
ac := map[string]string{ |
|
"itemType": infoc.ItemTypeLV, |
|
"action": infoc.ActionAnswer, |
|
"ip": ip, |
|
"mid": strconv.FormatInt(ah.Mid, 10), |
|
"sid": comargs["sid"], |
|
"ua": comargs["ua"], |
|
"buvid": comargs["buvid"], |
|
"refer": comargs["refer"], |
|
"url": comargs["url"], |
|
} |
|
log.Info("s.infoc2.ServiceAntiCheatBus(%v,%v)", ac, ans) |
|
s.infoc2.ServiceAntiCheatBus(ac, ans) |
|
}) |
|
} |
|
|
|
// ExtraCheck extra check. |
|
func (s *Service) ExtraCheck(c context.Context, mid int64, ids []int64, ansHash map[int64]string, ua string, lang string, refer string, buvid string) (err error) { |
|
var now = time.Now() |
|
if len(ids) < s.c.Answer.ExtraNum { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
ah, err := s.history(c, mid) |
|
if err != nil || ah == nil || ah.StartTime.Add(s.answerDuration()).Before(now) || ah.Score != 0 { |
|
err = ecode.AnswerBaseNotPassed |
|
return |
|
} |
|
if len(ids) != (s.c.Answer.BaseExtraPassNum + s.c.Answer.BaseExtraNoPassNum) { |
|
return ecode.AnswerQsNumErr |
|
} |
|
passids, err := s.answerDao.IdsCache(c, mid, model.BaseExtraPassQ) |
|
if err != nil { |
|
log.Error("s.answerDao.IdsCache(%d) extra pass err(%v) ", mid, err) |
|
return ecode.AnswerMidCacheQidsErr |
|
} |
|
nopassids, err := s.answerDao.IdsCache(c, mid, model.BaseExtraNoPassQ) |
|
if err != nil { |
|
log.Error("s.answerDao.IdsCache(%d) extra nopass err(%v) ", mid, err) |
|
return ecode.AnswerMidCacheQidsErr |
|
} |
|
idsmc := append(passids, nopassids...) |
|
ok, err := s.checkQsIDs(c, ids, mid, idsmc, s.c.Answer.BaseExtraPassNum+s.c.Answer.BaseExtraNoPassNum) |
|
if err != nil || !ok { |
|
return |
|
} |
|
ret, qs, _ := s.checkExtraPassAns(c, mid, passids, ansHash, lang, s.c.Answer.BaseExtraPassNum) |
|
ah.StepExtraScore = int64(ret * s.c.Answer.BaseExtraScore) |
|
ah.StepExtraCompleteTime = now.Unix() - ah.StartTime.Unix() |
|
if _, err = s.answerDao.UpdateExtraRet(c, ah.ID, mid, ah.StepExtraCompleteTime, ah.StepExtraScore); err != nil { |
|
log.Error("s.answerDao.UpdateExtraRet(%d) err(%v) ", mid, err) |
|
return |
|
} |
|
ah.Mtime = now |
|
s.userActionLog(mid, model.ExtraCheck, ah) |
|
s.answerDao.DelHistoryCache(c, mid) |
|
s.answerDao.DelIdsCache(c, mid, model.BaseExtraPassQ) |
|
s.answerDao.DelIdsCache(c, mid, model.BaseExtraNoPassQ) |
|
// send answer ret to bigdata |
|
rs, err := s.sendExtraRetMsg(c, mid, qs, nopassids, ansHash, s.c.Answer.BaseExtraNoPassNum) |
|
if err != nil { |
|
log.Error("s.sendExtraRetMsg(%d,%v,%v,%v) err(%v) ", mid, qs, nopassids, ansHash, err) |
|
return |
|
} |
|
s.answerDao.PubExtraRet(c, mid, &model.DataBusResult{ |
|
Mid: mid, |
|
Buvid: buvid, |
|
IP: metadata.String(c, metadata.RemoteIP), |
|
Ua: ua, |
|
Refer: refer, |
|
Score: int8(ah.StepExtraScore), |
|
Rs: rs, |
|
Hid: ah.Hid, |
|
}) |
|
return |
|
} |
|
|
|
// checkExtraPassAns check extra question ans. |
|
func (s *Service) checkExtraPassAns(c context.Context, mid int64, ids []int64, ansHash map[int64]string, lang string, count int) (ret int, qs map[int64]*model.ExtraQst, err error) { |
|
qs, err = s.answerDao.ExtraByIds(c, ids) |
|
if err != nil || qs == nil || len(qs) != count { |
|
log.Error("checkAns extra qs is nil (%v,%v) error(%v)", ids, qs, err) |
|
err = ecode.AnswerMidDBQueErr |
|
return |
|
} |
|
for _, q := range qs { |
|
var ans string |
|
switch q.Ans { |
|
case model.NormalQ: |
|
if lang == model.LangZhTW { |
|
ans = s.ansHash(mid, chinese.Convert(c, model.ExtraAnsA)) |
|
} else { |
|
ans = s.ansHash(mid, model.ExtraAnsA) |
|
} |
|
case model.ViolationQ: |
|
if lang == model.LangZhTW { |
|
ans = s.ansHash(mid, chinese.Convert(c, model.ExtraAnsB)) |
|
} else { |
|
ans = s.ansHash(mid, model.ExtraAnsB) |
|
} |
|
} |
|
if ansHash[q.ID] == ans { |
|
ret++ |
|
} |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) sendExtraRetMsg(c context.Context, mid int64, passqs map[int64]*model.ExtraQst, nopassids []int64, |
|
ansHash map[int64]string, count int) (rs []*model.Rs, err error) { |
|
var ( |
|
qs map[int64]*model.ExtraQst |
|
) |
|
qs, err = s.answerDao.ExtraByIds(c, nopassids) |
|
if err != nil || qs == nil || len(qs) != count { |
|
log.Error("checkAns extra nopassqs is nil (%v) error(%v)", qs, err) |
|
err = ecode.AnswerMidDBQueErr |
|
return |
|
} |
|
for k, v := range passqs { |
|
qs[k] = v |
|
} |
|
for _, q := range qs { |
|
var ( |
|
userAns int8 |
|
) |
|
ansA := s.ansHash(mid, model.ExtraAnsA) |
|
ansB := s.ansHash(mid, model.ExtraAnsB) |
|
switch ansHash[q.ID] { |
|
case ansA: |
|
userAns = model.NormalQ |
|
case ansB: |
|
userAns = model.ViolationQ |
|
default: |
|
userAns = model.UnKownQ |
|
} |
|
rs = append(rs, &model.Rs{ |
|
ID: q.OriginID, |
|
Question: q.Question, |
|
Ans: userAns, |
|
TrueAns: q.Ans, |
|
AvID: q.AvID, |
|
Status: q.Status, |
|
Source: q.Source, |
|
Ctime: q.Ctime, |
|
Mtime: q.Mtime, |
|
}) |
|
} |
|
return |
|
} |
|
|
|
// PendantRec . |
|
func (s *Service) PendantRec(c context.Context, arg *model.ReqPendant) (err error) { |
|
var ( |
|
ok bool |
|
status int8 |
|
hid, ret int64 |
|
his *model.AnswerHistory |
|
) |
|
if hid, status, err = s.answerDao.PendantHistory(c, arg.MID); err != nil { |
|
return |
|
} |
|
if hid != arg.HID { |
|
log.Warn("mid(%d) arg.hid(%d) db.hid(%d) is invald!", arg.MID, arg.HID, hid) |
|
return |
|
} |
|
if status != model.PendantNotGet { |
|
log.Warn("mid(%d) hid(%d) not first get!", arg.MID, arg.HID) |
|
return |
|
} |
|
his, err = s.historyByHid(c, arg.HID) |
|
if err != nil { |
|
return |
|
} |
|
if his.Score < model.Score60 || his.IsFirstPass != 1 { |
|
log.Warn("mid(%d) hid(%d) score(%d) isFirstPass(%d) not pass or first answer !", arg.MID, arg.HID, his.Score, his.IsFirstPass) |
|
return |
|
} |
|
if _, ok = _pendantIDNameMap[int(his.RankID)]; !ok { |
|
log.Warn("mid(%d) get illegal pid(%d) by answer first!", arg.MID, int(his.RankID)) |
|
return |
|
} |
|
if ret, err = s.answerDao.UpPendantHistory(c, arg.MID, arg.HID); err != nil { |
|
return |
|
} |
|
if ret <= 0 { |
|
log.Warn("mid(%d) hid(%d) pid(%d) history answer not get!", arg.MID, arg.HID, int(his.RankID)) |
|
return |
|
} |
|
s.missch.Do(c, func(ctx context.Context) { |
|
if pendantErr := s.accountDao.GivePendant(ctx, arg.MID, int64(his.RankID), model.PenDantDays, metadata.String(c, metadata.RemoteIP)); pendantErr != nil { |
|
log.Error("s.accountDao.GivePendant(%d,%d) error(%+v)", arg.MID, int64(his.RankID), pendantErr) |
|
} |
|
}) |
|
return |
|
}
|
|
|