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.
819 lines
24 KiB
819 lines
24 KiB
package service |
|
|
|
import ( |
|
"crypto/md5" |
|
"encoding/hex" |
|
"encoding/json" |
|
"fmt" |
|
"math" |
|
"math/rand" |
|
"strconv" |
|
"strings" |
|
"time" |
|
"unicode/utf8" |
|
|
|
"go-common/app/interface/main/answer/model" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
"go-common/library/text/translate/chinese" |
|
|
|
"github.com/pkg/errors" |
|
"golang.org/x/net/context" |
|
) |
|
|
|
const ( |
|
_hashSalt = "bilirqeust" |
|
// _ansURI = "/answer/img?qs_id=%v&ans1_hash=%s&ans2_hash=%s&ans3_hash=%s&ans4_hash=%s" |
|
_baseTypeID = 36 // 官方基础题库 |
|
_rankBtn = 7 * 24 * time.Hour |
|
_minType = 3 |
|
_maxType = 10 |
|
) |
|
|
|
var ( |
|
_typeIdsMapping = map[int][]int{ |
|
100001: {15, 16, 17}, |
|
100002: {29, 30}, |
|
100003: {12, 13}, |
|
// 22: 21, |
|
// 24: 23, |
|
// 35: 31, 36: 31, |
|
// 32: 30, 33: 30, 34: 30, |
|
// 29: 28, 37: 28, 7: 28, 8: 28, |
|
// 41: 5, 42: 5, 43: 5, 44: 5, 45: 5, 46: 5, 47: 5, 48: 5, 49: 5, 50: 5, 51: 5, 52: 5, |
|
} |
|
// 对外展示方式1 |
|
_typeMap1 = []*model.TypeInfo{ |
|
{Name: "游戏", Subs: []*model.SubType{ |
|
{ID: 8, Name: "动作射击"}, |
|
{ID: 9, Name: "冒险格斗"}, |
|
{ID: 100003, Name: "策略模拟"}, |
|
// {ID: 13, Name: "策略模拟"}, |
|
{ID: 14, Name: "音乐体育"}, |
|
}}, |
|
{Name: "影视", Subs: []*model.SubType{ |
|
{ID: 15, Name: "纪录片"}, |
|
{ID: 16, Name: "电影"}, |
|
{ID: 17, Name: "电视剧"}, |
|
}}, |
|
{Name: "科技", Subs: []*model.SubType{ |
|
{ID: 18, Name: "军事"}, |
|
{ID: 19, Name: "地理"}, |
|
{ID: 20, Name: "历史"}, |
|
{ID: 21, Name: "文学"}, |
|
{ID: 22, Name: "数学"}, |
|
{ID: 23, Name: "物理"}, |
|
{ID: 24, Name: "化学"}, |
|
{ID: 25, Name: "生物"}, |
|
{ID: 26, Name: "数码科技"}, |
|
}}, |
|
{Name: "动画", Subs: []*model.SubType{ |
|
{ID: 27, Name: "国创"}, |
|
{ID: 28, Name: "番剧"}, |
|
}}, |
|
{Name: "艺术", Subs: []*model.SubType{ |
|
{ID: 100002, Name: "音乐"}, |
|
// {ID: 30, Name: "音乐"}, |
|
{ID: 31, Name: "绘画"}, |
|
}}, |
|
{Name: "流行前线", Subs: []*model.SubType{ |
|
{ID: 32, Name: "娱乐"}, |
|
{ID: 33, Name: "时尚"}, |
|
{ID: 34, Name: "运动"}, |
|
}}, |
|
{Name: "鬼畜", Subs: []*model.SubType{ |
|
{ID: 35, Name: "鬼畜"}, |
|
}}, |
|
} |
|
// 推荐分区映射 |
|
_recTypeIDMap = map[int]map[string][]int{ |
|
124: {"main_tid": []int{1, 167}, "sub_tid": []int{3, 129}}, |
|
127: {"main_tid": []int{1, 167}, "sub_tid": []int{3, 4}}, |
|
126: {"main_tid": []int{3, 119}, "sub_tid": []int{1}}, |
|
123: {"main_tid": []int{3}, "sub_tid": []int{129, 119}}, |
|
121: {"main_tid": []int{36, 177}, "sub_tid": []int{160}}, |
|
125: {"main_tid": []int{4}, "sub_tid": []int{129}}, |
|
129: {"main_tid": []int{36, 177}, "sub_tid": []int{160}}, |
|
130: {"main_tid": []int{23, 11}, "sub_tid": []int{160}}, |
|
128: {"main_tid": []int{119}, "sub_tid": []int{160}}, |
|
} |
|
) |
|
|
|
// BaseQ base question. |
|
func (s *Service) BaseQ(c context.Context, mid int64, lang string, mobile bool) (res *model.AnsQueDetailList, err error) { |
|
var aqs *model.AnsQuesList |
|
if aqs, err = s.BaseQs(c, mid, lang, mobile); err != nil { |
|
err = errors.Wrapf(err, "s.ansRPC.BaseQs(%d,%t)", mid, mobile) |
|
return |
|
} |
|
res = s.convertModel(aqs) |
|
return |
|
} |
|
|
|
// BaseQs get base question |
|
func (s *Service) BaseQs(c context.Context, mid int64, lang string, mobile bool) (rqs *model.AnsQuesList, err error) { |
|
var ( |
|
ids []int64 |
|
now = time.Now() |
|
) |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
h, err := s.history(c, mid) |
|
if err == nil && h != nil { |
|
if h.StartTime.Add(s.answerDuration()).After(now) && h.Score == 0 { |
|
if h.StepExtraCompleteTime != 0 { |
|
err = ecode.AnswerProNoPass // extra question pass |
|
return |
|
} |
|
err = ecode.AnswerExtraNoPass |
|
return |
|
} |
|
if h.Score > 0 && h.IsPassCaptcha == 0 { |
|
err = ecode.AnswerCaptchaNoPassed |
|
return |
|
} |
|
} |
|
ids, err = s.answerDao.IdsCache(c, mid, model.Q) |
|
if err != nil || len(ids) != s.c.Answer.BaseNum { |
|
ids, err = s.answerDao.QidByType(c, _baseTypeID, uint8(s.c.Answer.BaseNum)) |
|
if err != nil { |
|
log.Error("s.answerDao.QidByType(%d,%d) error(%v)", _baseTypeID, s.c.Answer.BaseNum, err) |
|
return |
|
} |
|
if len(ids) == 0 { |
|
err = ecode.AnswerQsNumErr |
|
log.Error("qidByType ids len(%d) is 0", len(ids)) |
|
return |
|
} |
|
} |
|
rqs, err = s.concatData(c, mid, ids, lang, mobile, s.c.Answer.BaseNum) |
|
if err != nil { |
|
log.Error("BaseQs s.concatData(%d, %d, %d) error(%v)", c, mid, ids, err) |
|
return |
|
} |
|
at := &model.AnswerTime{ |
|
Stime: now, |
|
Etimes: 0, |
|
} |
|
err = s.answerDao.SetExpireCache(c, mid, at) |
|
rqs.CurrentTime = at.Stime |
|
rqs.EndTime = at.Stime.Add(s.answerDuration()) |
|
s.answerDao.DelIdsCache(c, mid, model.BaseExtraPassQ) |
|
s.answerDao.DelIdsCache(c, mid, model.BaseExtraNoPassQ) |
|
return |
|
} |
|
|
|
// ConvertExtraQs extra question. |
|
func (s *Service) ConvertExtraQs(c context.Context, mid int64, lang string, mobile bool) (res *model.AnsQueDetailList, err error) { |
|
var ans *model.AnsQuesList |
|
if ans, err = s.ExtraQs(c, mid, lang, mobile); err != nil { |
|
err = errors.Wrapf(err, "s.ansRPC.ExtraQues(%d,%t)", mid, mobile) |
|
return |
|
} |
|
res = s.convertExtraModel(ans) |
|
return |
|
} |
|
|
|
// ExtraQs extra question. |
|
func (s *Service) ExtraQs(c context.Context, mid int64, lang string, mobile bool) (rqs *model.AnsQuesList, err error) { |
|
var ( |
|
ids []int64 |
|
passids []int64 |
|
npassids []int64 |
|
now = time.Now() |
|
) |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
h, err := s.checkExtraState(c, mid, now) |
|
if err != nil { |
|
return |
|
} |
|
// keep on answer |
|
passids, _ = s.answerDao.IdsCache(c, mid, model.BaseExtraPassQ) |
|
npassids, err = s.answerDao.IdsCache(c, mid, model.BaseExtraNoPassQ) |
|
if err != nil || len(passids) != s.c.Answer.BaseExtraPassNum || len(npassids) != s.c.Answer.BaseExtraNoPassNum { |
|
var ( |
|
ok bool |
|
) |
|
ok, passids, npassids = s.extraQueByBigData(c, mid, "") |
|
if !ok { |
|
// if bigdata get extra mid faild |
|
passids, err = s.answerDao.ExtraQidByType(c, model.BaseExtraPassQ, uint8(s.c.Answer.BaseExtraPassNum)) |
|
if err != nil { |
|
log.Error("s.answerDao.ExtraQidByType(%d, %d, %d) error(%v)", model.BaseExtraPassQ, s.c.Answer.BaseExtraPassNum, len(passids), err) |
|
return |
|
} |
|
if len(passids) != s.c.Answer.BaseExtraPassNum { |
|
err = ecode.AnswerQsNumErr |
|
log.Warn("passids lenth(%d) neq BaseExtraPassNum(%d)", len(passids), s.c.Answer.BaseExtraPassNum) |
|
return |
|
} |
|
npassids, err = s.answerDao.ExtraQidByType(c, model.BaseExtraNoPassQ, uint8(s.c.Answer.BaseExtraNoPassNum)) |
|
if err != nil { |
|
log.Error("s.answerDao.ExtraQidByType(%d, %d, %d) error(%v)", model.BaseExtraNoPassQ, s.c.Answer.BaseExtraNoPassNum, len(npassids), err) |
|
return |
|
} |
|
if len(npassids) != s.c.Answer.BaseExtraNoPassNum { |
|
err = ecode.AnswerQsNumErr |
|
log.Warn("npassids lenth(%d) neq BaseExtraNoPassNum(%d)", len(npassids), s.c.Answer.BaseExtraNoPassNum) |
|
return |
|
} |
|
} |
|
} |
|
ids = append(passids, npassids...) |
|
rqs, err = s.concatExtraData(c, mid, ids, passids, npassids, lang, mobile, s.c.Answer.BaseExtraPassNum+s.c.Answer.BaseExtraNoPassNum) |
|
if err != nil { |
|
log.Error("BaseExtraQs s.concatExtraData(%d, %d, %d) error(%v)", c, mid, ids, err) |
|
return |
|
} |
|
rqs.CurrentTime = now |
|
rqs.EndTime = h.StartTime.Add(s.answerDuration()) |
|
if _, err = s.answerDao.UpdateExtraStartTime(c, h.ID, mid, now); err != nil { |
|
log.Error("s.answerDao.UpdateExtraStartTime( %d, %d) error(%v)", h.ID, mid, err) |
|
return |
|
} |
|
h.StepExtraStartTime = now |
|
h.Mtime = now |
|
s.userActionLog(mid, model.ExtraStartTime, h) |
|
s.answerDao.DelHistoryCache(c, mid) |
|
return |
|
} |
|
|
|
func (s *Service) checkExtraState(c context.Context, mid int64, now time.Time) (h *model.AnswerHistory, err error) { |
|
h, err = s.history(c, mid) |
|
if err != nil { |
|
log.Error("s.history(%v) is nil error(%v)", h, err) |
|
err = ecode.AnswerBaseNotPassed |
|
return |
|
} |
|
if h != nil { |
|
if h.Score > 0 && h.IsPassCaptcha == 0 { |
|
err = ecode.AnswerCaptchaNoPassed |
|
return |
|
} |
|
// if base pass |
|
if h.StartTime.Add(s.answerDuration()).After(now) && h.Score == 0 { |
|
if h.StepExtraCompleteTime != 0 { |
|
err = ecode.AnswerProNoPass |
|
} |
|
return |
|
} |
|
err = ecode.AnswerBaseNotPassed |
|
return |
|
} |
|
err = ecode.AnswerBaseNotPassed |
|
return |
|
} |
|
|
|
// ProTypes get promotion types. |
|
func (s *Service) proTypes(c context.Context, mid int64) (res *model.ProTypes, err error) { |
|
var ( |
|
repro bool |
|
ah *model.AnswerHistory |
|
now = time.Now() |
|
) |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
if ah, err = s.checkBase(c, mid, now); err != nil { |
|
return |
|
} |
|
qsidsMc, err := s.answerDao.IdsCache(c, mid, model.Q) |
|
if err == nil && len(qsidsMc) == s.c.Answer.ProNum { |
|
repro = true |
|
} |
|
res = &model.ProTypes{List: _typeMap1, EndTime: ah.StartTime.Add(s.answerDuration()), CurrentTime: now, Repro: repro} |
|
return |
|
} |
|
|
|
// ProType type. |
|
func (s *Service) ProType(c context.Context, mid int64, lang string) (res *model.AnsProType, err error) { |
|
var ( |
|
repro string |
|
list = []*model.AnsTypeList{} |
|
) |
|
rpcRes, err := s.proTypes(c, mid) |
|
if err != nil { |
|
log.Error("s.proTypes(%+d) error (%v)", mid, err) |
|
return |
|
} |
|
for _, vt := range rpcRes.List { |
|
var sub = []*model.AnsType{} |
|
for _, vst := range vt.Subs { |
|
ansType := &model.AnsType{ID: vst.ID, Name: vst.Name} |
|
if lang == model.LangZhTW { |
|
ansType.Name = chinese.Convert(c, ansType.Name) |
|
} |
|
sub = append(sub, ansType) |
|
} |
|
ansTypeList := &model.AnsTypeList{Name: vt.Name, Fields: sub} |
|
if lang == model.LangZhTW { |
|
ansTypeList.Name = chinese.Convert(c, ansTypeList.Name) |
|
} |
|
list = append(list, ansTypeList) |
|
} |
|
if rpcRes.Repro { |
|
repro = "yes" |
|
} else { |
|
repro = "no" |
|
} |
|
res = &model.AnsProType{List: list, CurrentTime: rpcRes.CurrentTime.Unix(), EndTime: rpcRes.EndTime.Unix(), Repro: repro} |
|
return |
|
} |
|
|
|
// ConvertProQues pro question. |
|
func (s *Service) ConvertProQues(c context.Context, mid int64, tIds string, lang string, mobile bool) (res []*model.AnsQueDetail, err error) { |
|
var ( |
|
ans *model.AnsQuesList |
|
ansdl *model.AnsQueDetailList |
|
) |
|
if ans, err = s.ProQues(c, mid, tIds, lang, mobile); err != nil { |
|
err = errors.Wrapf(err, "s.ProQues(%d,%v,%t)", mid, tIds, mobile) |
|
return |
|
} |
|
ansdl = s.convertModel(ans) |
|
res = ansdl.QuesList |
|
return |
|
} |
|
|
|
// ProQues question info. |
|
func (s *Service) ProQues(c context.Context, mid int64, qtsStr string, lang string, mobile bool) (rqs *model.AnsQuesList, err error) { |
|
var ( |
|
ah *model.AnswerHistory |
|
now = time.Now() |
|
allQids []int64 |
|
tIds, realTIDs []int |
|
) |
|
if s.checkAnswerBlock(c, mid) { |
|
err = ecode.AnswerBlock |
|
return |
|
} |
|
if ah, err = s.checkBase(c, mid, now); err != nil { |
|
return |
|
} |
|
allQids, err = s.answerDao.IdsCache(c, mid, model.Q) |
|
if err != nil || len(allQids) != s.c.Answer.ProNum { |
|
tIDStrArr := strings.Split(qtsStr, ",") |
|
if len(tIDStrArr) < _minType || len(tIDStrArr) > _maxType { |
|
err = ecode.AnswerTypeIDsErr |
|
return |
|
} |
|
if tIds, err = sliceAtoi(tIDStrArr); err != nil { |
|
err = ecode.AnswerTypeIDsErr |
|
return |
|
} |
|
for _, qt := range tIds { |
|
if qt <= 0 { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
if mapIDS, ok := _typeIdsMapping[qt]; ok { |
|
realTIDs = append(realTIDs, mapIDS...) |
|
continue |
|
} |
|
realTIDs = append(realTIDs, qt) |
|
} |
|
num := math.Ceil(float64(s.c.Answer.ProNum) / float64(len(realTIDs))) |
|
log.Warn("realTIDs:%v", realTIDs) |
|
for _, qt := range realTIDs { |
|
var t []int64 |
|
t, err = s.answerDao.QidByType(c, qt, uint8(num)) |
|
if err != nil { |
|
log.Error("s.answerDao.QidByType(%d, %f, %d) error(%+v)", qt, num, len(t), err) |
|
return |
|
} |
|
if len(t) == 0 { |
|
log.Error("mid:%d the QidByType(%d, %f, %d) of len is 0", mid, qt, num, len(t)) |
|
err = ecode.AnswerMidDBQueErr |
|
return |
|
} |
|
allQids = append(allQids, t...) |
|
} |
|
if len(allQids) == 0 || len(allQids) < s.c.Answer.ProNum { |
|
log.Error("ProQues allQids len is 0 or allQids len less(%d, %d, %f, %v, %d)", len(allQids), s.c.Answer.ProNum, num, realTIDs, mid) |
|
err = ecode.NothingFound |
|
return |
|
} |
|
} |
|
if rqs, err = s.concatData(c, mid, allQids, lang, mobile, s.c.Answer.ProNum); err != nil { |
|
log.Error("ProQues s.concatData(%d, %d, %d) error(%v)", c, mid, allQids, err) |
|
return |
|
} |
|
if _, err = s.answerDao.UpdateStepTwoTime(c, ah.ID, mid, now); err != nil { |
|
return |
|
} |
|
ah.StepTwoStartTime = now |
|
ah.Mtime = now |
|
s.userActionLog(mid, model.ProQues, ah) |
|
s.answerDao.DelHistoryCache(c, mid) |
|
return |
|
} |
|
|
|
func (s *Service) checkBase(c context.Context, mid int64, now time.Time) (ah *model.AnswerHistory, err error) { |
|
ah, err = s.history(c, mid) |
|
if err != nil || ah == nil || ah.StartTime.Add(s.answerDuration()).Before(now) || ah.Score != 0 || ah.StepOneCompleteTime == 0 { |
|
err = ecode.AnswerBaseNotPassed |
|
log.Error("checkBase(%d, %v) AnswerExpire error(%v)", mid, now, err) |
|
return |
|
} |
|
if ah.StepExtraCompleteTime == 0 { |
|
err = ecode.AnswerExtraNoPass |
|
return |
|
} |
|
if ah.Score > 0 && ah.IsPassCaptcha == 0 { |
|
err = ecode.AnswerCaptchaNoPassed |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) checkTime(c context.Context, mid int64, now time.Time) (at *model.AnswerTime, rs bool) { |
|
var err error |
|
if at, err = s.answerDao.ExpireCache(c, mid); err != nil { |
|
return |
|
} |
|
if at == nil || at.Stime.Add(s.answerDuration()).Before(now) { |
|
return |
|
} |
|
rs = true |
|
return |
|
} |
|
|
|
func (s *Service) concatData(c context.Context, mid int64, ids []int64, lang string, mobile bool, qs int) (rqs *model.AnsQuesList, err error) { |
|
var ( |
|
list []*model.AnsQue |
|
qm map[int64]*model.Question |
|
) |
|
if qm, err = s.answerDao.ByIds(c, ids); err != nil { |
|
log.Error("s.answerDao.ByIds(%v) error(%v)", ids, err) |
|
err = ecode.NothingFound |
|
return |
|
} |
|
for _, d := range ids { |
|
i := qm[d] |
|
rq := s.imgPosition(c, i, mid, lang, mobile) |
|
list = append(list, rq) |
|
} |
|
if len(list) > qs { |
|
list = list[:qs] |
|
} |
|
rqs = &model.AnsQuesList{QuesList: list} |
|
if err := s.answerDao.SetIdsCache(c, mid, ids, model.Q); err != nil { |
|
log.Error("s.answerDao.SetIdsCache(%d, %d) error(%v)", mid, ids, err) |
|
} |
|
log.Info("s.concatData load que success(%d, %v, %v, %d)", mid, ids, mobile, qs) |
|
return |
|
} |
|
|
|
func (s *Service) concatExtraData(c context.Context, mid int64, ids []int64, passids []int64, nopassids []int64, lang string, mobile bool, qs int) (rqs *model.AnsQuesList, err error) { |
|
var ( |
|
list []*model.AnsQue |
|
qm map[int64]*model.ExtraQst |
|
) |
|
if qm, err = s.answerDao.ExtraByIds(c, ids); err != nil || len(qm) < qs { |
|
log.Error("s.answerDao.ExtraByIds(%v) error(%+v)", ids, err) |
|
return |
|
} |
|
for _, d := range ids { |
|
i := qm[d] |
|
rq := s.imgExtraPosition(c, i, mid, lang, mobile) |
|
list = append(list, rq) |
|
} |
|
if len(list) > qs { |
|
list = list[:qs] |
|
} |
|
rqs = &model.AnsQuesList{QuesList: list} |
|
if err = s.answerDao.SetIdsCache(c, mid, passids, model.BaseExtraPassQ); err != nil { |
|
log.Error("s.answerDao.SetIdsCache(%d, %d) error(%v)", mid, passids, err) |
|
return |
|
} |
|
if err = s.answerDao.SetIdsCache(c, mid, nopassids, model.BaseExtraNoPassQ); err != nil { |
|
log.Error("s.answerDao.SetIdsCache(%d, %d) error(%v)", mid, nopassids, err) |
|
return |
|
} |
|
log.Info("s.concatData extra load que success(%d, %v, %v, %d)", mid, ids, mobile, qs) |
|
return |
|
} |
|
|
|
// ansHash get answer hash. |
|
func (s *Service) ansHash(mid int64, ans string) (ansHash string) { |
|
h := md5.New() |
|
h.Write([]byte(fmt.Sprintf("%s%d%s", ans, mid, _hashSalt))) |
|
return hex.EncodeToString(h.Sum(nil)) |
|
} |
|
|
|
func (s *Service) imgPosition(c context.Context, qs *model.Question, mid int64, lang string, mobile bool) (rq *model.AnsQue) { |
|
var ( |
|
y float64 |
|
qsLineLength float64 = 36 |
|
questionFontSize float64 = 10 |
|
questionTitleSize float64 = 12 |
|
ans = make([]*model.AnsPosition, 4) |
|
imgStr = "v3_%s_A-%s_B-%s_C-%s_D-%s_%s" |
|
p = map[bool]string{true: "H5", false: "PC"} |
|
bfsHost = "https://i0.hdslb.com/bfs/member/" |
|
as [4]string |
|
) |
|
rq = &model.AnsQue{ID: qs.ID} |
|
if mobile { |
|
qsLineLength = 11 |
|
questionFontSize = 12 |
|
questionTitleSize = 16 |
|
} |
|
|
|
qsLength := utf8.RuneCountInString(qs.Question) |
|
if float64(qsLength) > qsLineLength { |
|
line := math.Ceil(float64(qsLength) / qsLineLength) |
|
rq.Height = 2 * line * questionTitleSize |
|
rq.PositionY = y |
|
} else { |
|
rq.Height = 2 * questionTitleSize |
|
} |
|
y = rq.Height |
|
|
|
if lang == model.LangZhTW { |
|
qs.Question = chinese.Convert(c, qs.Question) |
|
qs.Ans[0] = chinese.Convert(c, qs.Ans[0]) |
|
qs.Ans[1] = chinese.Convert(c, qs.Ans[1]) |
|
qs.Ans[2] = chinese.Convert(c, qs.Ans[2]) |
|
qs.Ans[3] = chinese.Convert(c, qs.Ans[3]) |
|
} |
|
idx := rand.Perm(4) |
|
for i := range qs.Ans { |
|
ans[i] = &model.AnsPosition{ |
|
AnsHash: s.ansHash(mid, qs.Ans[idx[i]]), |
|
Height: 2 * questionFontSize, |
|
PositionY: y, |
|
} |
|
y += 2 * questionFontSize |
|
as[i] = qs.Ans[idx[i]] |
|
} |
|
m := md5.New() |
|
m.Write([]byte(fmt.Sprintf(imgStr, strconv.FormatInt(qs.ID, 10), as[0], as[1], as[2], as[3], p[mobile]))) |
|
fname := hex.EncodeToString(m.Sum(nil)) + ".jpg" |
|
if s.c.Answer.Debug { |
|
fname = fmt.Sprintf("debug_%s", fname) |
|
} |
|
rq.Img = bfsHost + fname |
|
rq.Ans = ans |
|
return |
|
} |
|
|
|
func (s *Service) imgExtraPosition(c context.Context, qs *model.ExtraQst, mid int64, lang string, mobile bool) (rq *model.AnsQue) { |
|
var ( |
|
y float64 |
|
qsLineLength float64 = 36 |
|
questionFontSize float64 = 10 |
|
questionTitleSize float64 = 12 |
|
ans = make([]*model.AnsPosition, 2) |
|
imgStr = "%s_A-%s_B-%s_%s" |
|
p = map[bool]string{true: "H5", false: "PC"} |
|
bfsHost = "https://i0.hdslb.com/bfs/member/" |
|
as [2]string |
|
) |
|
rq = &model.AnsQue{ID: qs.ID} |
|
if mobile { |
|
qsLineLength = 11 |
|
questionFontSize = 12 |
|
questionTitleSize = 16 |
|
} |
|
|
|
qsLength := utf8.RuneCountInString(qs.Question) |
|
if float64(qsLength) > qsLineLength { |
|
line := math.Ceil(float64(qsLength) / qsLineLength) |
|
rq.Height = 2 * line * questionTitleSize |
|
rq.PositionY = y |
|
} else { |
|
rq.Height = 2 * questionTitleSize |
|
} |
|
y = rq.Height |
|
if lang == model.LangZhTW { |
|
as = [2]string{chinese.Convert(c, model.ExtraAnsA), chinese.Convert(c, model.ExtraAnsB)} |
|
} else { |
|
as = [2]string{model.ExtraAnsA, model.ExtraAnsB} |
|
} |
|
|
|
for k, v := range as { |
|
ans[k] = &model.AnsPosition{ |
|
AnsHash: s.ansHash(mid, v), |
|
Height: 2 * questionFontSize, |
|
PositionY: y, |
|
} |
|
y += 2 * questionFontSize |
|
} |
|
|
|
m := md5.New() |
|
m.Write([]byte(fmt.Sprintf(imgStr, strconv.FormatInt(qs.OriginID, 10), as[0], as[1], p[mobile]))) |
|
fname := hex.EncodeToString(m.Sum(nil)) + ".jpg" |
|
if s.c.Answer.Debug { |
|
fname = fmt.Sprintf("debug_%s", fname) |
|
} |
|
rq.Img = bfsHost + fname |
|
rq.Ans = ans |
|
return |
|
} |
|
|
|
func (s *Service) loadQidsCache() { |
|
qs, err := s.answerDao.QidsByState(context.Background(), model.PassCheck) |
|
if len(qs) == 0 || err != nil { |
|
log.Error("s.answerDao.loadQidsCache(%d) size is zero error(%v)", model.PassCheck, err) |
|
} |
|
qmap := map[int8][]int64{} |
|
for _, q := range qs { |
|
qmap[q.TypeID] = append(qmap[q.TypeID], q.ID) |
|
} |
|
for k, v := range qmap { |
|
s.answerDao.DelQidsCache(context.Background(), int(k)) |
|
s.answerDao.SetQids(context.Background(), v, int(k)) |
|
} |
|
log.Info("s.answerDao.loadQidsCache suc(%v)", qmap) |
|
} |
|
|
|
func (s *Service) loadExtraQidsCache() { |
|
qs, err := s.answerDao.QidsExtraByState(context.Background(), model.MaxLoadQueSize) |
|
if len(qs) == 0 || err != nil { |
|
log.Error("s.answerDao.QidsExtraByState(%d) size is zero error(%v)", model.MaxLoadQueSize, err) |
|
return |
|
} |
|
qmap := map[int8][]int64{} |
|
for _, q := range qs { |
|
qmap[q.Ans] = append(qmap[q.Ans], q.ID) |
|
} |
|
for k, v := range qmap { |
|
s.answerDao.DelExtraQidsCache(context.Background(), k) |
|
s.answerDao.SetExtraQids(context.Background(), v, k) |
|
} |
|
log.Info("s.answerDao.loadExtraQidsCache suc(%v)", qmap) |
|
} |
|
|
|
// Cool . |
|
func (s *Service) Cool(c context.Context, hid, mid int64) (cool *model.AnsCool, err error) { |
|
var ( |
|
his *model.AnswerHistory |
|
types []*model.TypeInfo |
|
li = []*model.CoolPower{ |
|
{Name: "动画", Num: 0}, |
|
{Name: "艺术", Num: 0}, |
|
{Name: "游戏", Num: 0}, |
|
{Name: "科技", Num: 0}, |
|
{Name: "影视", Num: 0}, |
|
{Name: "鬼畜", Num: 0}, |
|
} |
|
completeResult = make(map[int8]int64) |
|
) |
|
his, err = s.historyByHid(c, hid) |
|
if err != nil { |
|
return |
|
} |
|
cool = &model.AnsCool{ |
|
Score: his.Score, |
|
IsSameUser: his.Mid == mid, |
|
IsFirstPass: his.IsFirstPass, |
|
Level: his.PassedLevel, |
|
Share: &model.CoolShare{}, |
|
VideoInfo: &model.CoolVideo{}, |
|
Rank: &model.CoolRank{}, |
|
} |
|
cool.CanShowRankBtn = his.Score >= 85 && his.Mtime.Before(time.Now().Add(_rankBtn)) |
|
r := _pendantIDNameMap[int(his.RankID)] |
|
if r != "" { |
|
if rid, ok := _oldPIDToNewMap[his.RankID]; ok { |
|
his.RankID = rid |
|
} |
|
rs := _rankShire[his.RankID] |
|
idx := rand.Perm(len(rs.VideoArr)) |
|
cool.ViewMore = rs.ViewMore |
|
cool.Share = rs.Share |
|
cool.VideoInfo = rs.VideoArr[idx[0]] |
|
cool.Rank = &model.CoolRank{ |
|
ID: int(his.RankID), |
|
Name: r, |
|
Img: "https://i0.hdslb.com" + _pendantIDImgMap[his.RankID], |
|
} |
|
} |
|
us, err := s.accInfo(c, his.Mid) |
|
if err != nil || us == nil { |
|
log.Error("CheckQueCaptcha accInfo(%d) info is null error(%v)", mid, err) |
|
return |
|
} |
|
cool.Name = us.Name |
|
cool.Face = us.Face |
|
if err = json.Unmarshal([]byte(his.CompleteResult), &completeResult); err != nil { |
|
log.Error("json.Unmarshal(%s) error(%v)", his.CompleteResult, err) |
|
err = nil |
|
} |
|
log.Info("hid(%d), completeResult: %v+", hid, completeResult) |
|
for k := range completeResult { |
|
for _, t := range s.questionTypeCache { |
|
if len(t.Subs) != 0 { |
|
for _, s := range t.Subs { |
|
if int64(k) == s.ID { |
|
types = append(types, &model.TypeInfo{ID: s.ID, Name: s.Name, LabelName: s.LabelName}) |
|
} |
|
} |
|
} |
|
if int64(k) == t.ID { |
|
types = append(types, t) |
|
} |
|
} |
|
} |
|
log.Info("hid(%d), cool types: %v+", hid, types) |
|
for _, t := range types { |
|
for _, p := range li { |
|
if p.Name == t.LabelName { |
|
p.Num += completeResult[int8(t.ID)] |
|
} |
|
} |
|
} |
|
log.Info("hid(%d), power types: %v+", hid, li) |
|
cool.Powers = append(cool.Powers, li...) |
|
if _, ok := _recTypeIDMap[int(his.RankID)]; ok { |
|
cool.MainTids = _recTypeIDMap[int(his.RankID)]["main_tid"] |
|
cool.SubTids = _recTypeIDMap[int(his.RankID)]["sub_tid"] |
|
} |
|
return |
|
} |
|
|
|
// ExtraScore . |
|
func (s *Service) ExtraScore(c context.Context, mid int64) (res *model.ExtraScoreReply, err error) { |
|
res = &model.ExtraScoreReply{} |
|
h, err := s.history(c, mid) |
|
if err != nil { |
|
return |
|
} |
|
res.Score = h.StepExtraScore + int64(s.c.Answer.BaseNum) |
|
return |
|
} |
|
|
|
func (s *Service) history(c context.Context, mid int64) (ah *model.AnswerHistory, err error) { |
|
cok := true |
|
if ah, err = s.answerDao.HistoryCache(c, mid); err != nil { |
|
cok = false |
|
return |
|
} |
|
if ah != nil { |
|
return |
|
} |
|
ah, err = s.answerDao.History(c, mid) |
|
if err != nil { |
|
return |
|
} |
|
if ah != nil && cok { |
|
s.answerDao.SetHistoryCache(c, mid, ah) |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) answerDuration() (d time.Duration) { |
|
return time.Duration(s.c.Answer.Duration) * time.Minute |
|
} |
|
|
|
func sliceAtoi(sa []string) ([]int, error) { |
|
si := make([]int, 0, len(sa)) |
|
for _, a := range sa { |
|
i, err := strconv.Atoi(a) |
|
if err != nil { |
|
return si, err |
|
} |
|
si = append(si, i) |
|
} |
|
return si, nil |
|
} |
|
|
|
func (s *Service) extraQueByBigData(c context.Context, mid int64, ip string) (ok bool, passids []int64, npassids []int64) { |
|
passids, npassids, err := s.accountDao.ExtraIds(c, mid, ip) |
|
if err != nil || len(passids) != s.c.Answer.BaseExtraPassNum || len(npassids) != s.c.Answer.BaseExtraNoPassNum { |
|
return |
|
} |
|
ids := append(passids, npassids...) |
|
if qm, err := s.answerDao.ExtraByIds(c, ids); err != nil || len(qm) != (s.c.Answer.BaseExtraPassNum+s.c.Answer.BaseExtraNoPassNum) { |
|
log.Error("s.answerDao.ExtraByIds(%v) error(%v)", ids, err) |
|
return |
|
} |
|
ok = true |
|
return |
|
} |
|
|
|
func (s *Service) loadtypes() (t map[int64]*model.TypeInfo) { |
|
tys, err := s.answerDao.Types(context.Background()) |
|
if err != nil { |
|
log.Error("s.questionDao.Types error(%v)", err) |
|
return |
|
} |
|
tmp := map[int64]*model.TypeInfo{} |
|
for _, v := range tys { |
|
if v.Parentid == 0 && tmp[v.ID] == nil { |
|
tmp[v.ID] = &model.TypeInfo{ID: v.ID, Name: v.Name, Subs: []*model.SubType{}} |
|
} else if tmp[v.Parentid] != nil { |
|
tmp[v.Parentid].Subs = append(tmp[v.Parentid].Subs, &model.SubType{ID: v.ID, Name: v.Name, LabelName: v.LabelName}) |
|
} |
|
} |
|
s.questionTypeCache = tmp |
|
t = tmp |
|
log.Info("load question type cacheproc success,%v", t) |
|
return |
|
}
|
|
|