Create & Init Project...

app/interface/main/credit/service/BUILD

@@ -0,0 +1,76 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "appeal_test.go",
+        "blocked_test.go",
+        "jury_test.go",
+        "labour_test.go",
+        "service_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/credit/conf:go_default_library",
+        "//app/interface/main/credit/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "appeal.go",
+        "blocked.go",
+        "extra_func.go",
+        "jury.go",
+        "labour.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/interface/main/credit/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/credit/conf:go_default_library",
+        "//app/interface/main/credit/dao:go_default_library",
+        "//app/interface/main/credit/model:go_default_library",
+        "//app/service/main/account/api:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/archive/api/gorpc:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//app/service/main/filter/api/grpc/v1:go_default_library",
+        "//app/service/main/member/api/gorpc:go_default_library",
+        "//app/service/main/member/model:go_default_library",
+        "//app/service/main/member/model/block:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//library/time:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/credit/service/appeal.go

@@ -0,0 +1,76 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/credit/model"
+	"go-common/library/ecode"
+	xtime "go-common/library/time"
+
+	"github.com/pkg/errors"
+)
+
+// AddAppeal  add a new appeal .
+func (s *Service) AddAppeal(c context.Context, btid, bid, mid int64, reason string) (err error) {
+	var (
+		isID   bool
+		origin string
+		ctime  xtime.Time
+		caseID int64
+	)
+	infos, err := s.BlockedUserList(c, mid)
+	if err != nil {
+		err = errors.Wrap(err, "s.dao.BlockedUserList error")
+		return
+	}
+	for _, v := range infos {
+		if bid == v.ID {
+			isID = true
+			origin = v.OriginContent
+			ctime = v.CTime
+			caseID = v.CaseID
+		}
+	}
+	if !isID {
+		err = ecode.CreditBlockNotExist
+		return
+	}
+	if xtime.Time(time.Now().AddDate(0, 0, -7).Unix()) > ctime {
+		err = ecode.CreditBlockExpired
+		return
+	}
+	if err = s.dao.AddAppeal(c, s.tagMap[int8(btid)], btid, caseID, mid, model.Business, origin, reason); err != nil {
+		err = errors.Wrap(err, "s.AddAppeal error")
+	}
+	return
+}
+
+// AppealState appeal status .
+func (s *Service) AppealState(c context.Context, mid, bid int64) (state bool, err error) {
+	block, err := s.BlockedInfoAppeal(c, bid, mid)
+	if err != nil {
+		err = errors.Wrap(err, "BlockedInfo error")
+		return
+	}
+	if block == nil || block.UID != mid {
+		err = ecode.CreditBlockNotExist
+		return
+	}
+	if xtime.Time(time.Now().AddDate(0, 0, -7).Unix()) > block.CTime {
+		err = ecode.CreditBlockExpired
+		return
+	}
+	aps, err := s.dao.AppealList(c, mid, model.Business)
+	if err != nil {
+		err = errors.Wrap(err, "s.dao.AppealList error")
+		return
+	}
+	for _, v := range aps {
+		if block.CaseID == v.Oid {
+			return
+		}
+	}
+	state = true
+	return
+}

app/interface/main/credit/service/appeal_test.go

@@ -0,0 +1,25 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// TestAddAppeal add appeal testing.
+func TestAddAppeal(t *testing.T) {
+	Convey("TestAddAppeal", t, func() {
+		err := s.AddAppeal(context.TODO(), 1, 111, 2222, "测试")
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestAppealState appealstate testing.
+func TestAppealState(t *testing.T) {
+	Convey("TestAddAppeal", t, func() {
+		state, err := s.AppealState(context.TODO(), 1, 111)
+		So(err, ShouldBeNil)
+		So(state, ShouldEqual, true)
+	})
+}

app/interface/main/credit/service/blocked.go

@@ -0,0 +1,503 @@
+package service
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/credit/model"
+	acmdl "go-common/app/service/main/account/api"
+	blkmdl "go-common/app/service/main/member/model/block"
+	xsql "go-common/library/database/sql"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	xtime "go-common/library/time"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	_emptyAnnounce  = []*model.BlockedAnnouncement{}
+	_emptyBlockInfo = []*model.BlockedInfo{}
+)
+
+// BlockedUserCard get user blocked card info.
+func (s *Service) BlockedUserCard(c context.Context, mid int64) (card *model.BlockedUserCard, err error) {
+	var (
+		count   int
+		profile *acmdl.ProfileReply
+	)
+	accArg := &acmdl.MidReq{Mid: mid}
+	if profile, err = s.accountClient.Profile3(c, accArg); err != nil {
+		err = errors.Wrap(err, "accountClient.Profile3")
+		return
+	}
+	card = &model.BlockedUserCard{UID: mid, Uname: profile.Profile.Name, Face: profile.Profile.Face}
+	if count, err = s.dao.BlockedCount(c, mid); err != nil {
+		return
+	}
+	card.BlockedSum = count
+	bms, err := s.memRPC.BlockInfo(c, &blkmdl.RPCArgInfo{MID: mid})
+	if err != nil {
+		return
+	}
+	card.BlockedStatus = int(bms.BlockStatus)
+	status := int8(bms.BlockStatus)
+	if status == model.BlockStatusForever || status == model.BlockStatusOn {
+		card.BlockedStatus = 1
+		// TODO nothing record in credit.
+		if count <= 0 {
+			card.BlockedSum = 1
+		}
+	}
+	if status == model.BlockStatusForever {
+		card.BlockedForever = model.BlockedStateForever
+	}
+	card.BlockedEndTime = bms.EndTime
+	card.MoralNum = int(profile.Profile.Moral)
+	if status != 0 {
+		delta := time.Until(time.Unix(bms.EndTime, 0))
+		if int(delta) > 0 {
+			card.BlockedRestDay = int64(delta / (time.Hour * 24))
+			if delta%(time.Hour*24) > 0 {
+				card.BlockedRestDay++
+			}
+		}
+		if card.AnsWerStatus, err = s.dao.AnswerStatus(c, mid, time.Unix(bms.StartTime, 0)); err != nil {
+			return
+		}
+	}
+	return
+}
+
+// BlockedUserList get user blocked info list
+func (s *Service) BlockedUserList(c context.Context, mid int64) (r []*model.BlockedInfo, err error) {
+	var mc = true
+	if r, err = s.dao.BlockedUserListCache(c, mid); err != nil {
+		err = nil
+		mc = false
+	}
+	if len(r) > 0 {
+		return
+	}
+	if r, err = s.dao.BlockedUserList(c, mid); err != nil {
+		return
+	}
+	if mc && len(r) > 0 {
+		s.addCache(func() {
+			s.dao.SetBlockedUserListCache(context.TODO(), mid, r)
+		})
+	}
+	return
+}
+
+// BlockedInfo blocked info
+func (s *Service) BlockedInfo(c context.Context, id int64) (info *model.BlockedInfo, err error) {
+	var mc = true
+	if info, err = s.dao.BlockedInfoCache(c, id); err != nil {
+		err = nil
+		mc = false
+	}
+	if info != nil {
+		if int8(info.PublishStatus) == model.PublishStatusClose {
+			err = ecode.NothingFound
+		}
+		return
+	}
+	if info, err = s.dao.BlockedInfoByID(c, id); err != nil {
+		err = errors.Wrapf(err, "BlockedInfoByID(%d)", id)
+		return
+	}
+	if info == nil || (int8(info.PublishStatus) == model.PublishStatusClose) {
+		err = ecode.NothingFound
+		return
+	}
+	if mc {
+		s.addBlockedCache(c, info)
+	}
+	return
+}
+
+// BlockedInfoAppeal get blocked info for appeal .
+func (s *Service) BlockedInfoAppeal(c context.Context, id, mid int64) (info *model.BlockedInfo, err error) {
+	defer func() {
+		if err == nil && info != nil && info.ID != 0 {
+			if mid != info.UID {
+				err = ecode.NothingFound
+			}
+		}
+	}()
+	var mc = true
+	if info, err = s.dao.BlockedInfoCache(c, id); err != nil {
+		err = nil
+		mc = false
+	}
+	if info != nil {
+		return
+	}
+	if info, err = s.dao.BlockedInfoByID(c, id); err != nil {
+		err = errors.Wrapf(err, "BlockedInfoByID(%d)", id)
+		return
+	}
+	if info == nil {
+		err = ecode.NothingFound
+		return
+	}
+	if mc {
+		s.addBlockedCache(c, info)
+	}
+	return
+}
+
+func (s *Service) addBlockedCache(c context.Context, info *model.BlockedInfo) {
+	var card *acmdl.CardReply
+	if card, _ = s.userInfo(c, info.UID); card != nil {
+		info.Uname = card.Card.Name
+		info.Face = card.Card.Face
+	}
+	info.Build()
+	s.addCache(func() {
+		s.dao.SetBlockedInfoCache(context.TODO(), info.ID, info)
+	})
+}
+
+// BlockedList blocked info list, public default.
+func (s *Service) BlockedList(c context.Context, oType, bType int8, pn, ps int) (res []*model.BlockedInfo, err error) {
+	var (
+		start  = (pn - 1) * ps
+		end    = pn * ps
+		ok     bool
+		ids    []int64
+		missed []int64
+		cache  = true
+	)
+	if ok, err = s.dao.ExpireBlockedIdx(c, oType, bType); ok && err == nil {
+		if ids, err = s.dao.BlockedIdxCache(c, oType, bType, start, end-1); err != nil {
+			return
+		}
+	} else {
+		var ls, tmpls []*model.BlockedInfo
+		if ls, err = s.dao.BlockedList(c, oType, bType); err != nil {
+			return
+		}
+		switch {
+		case len(ls) <= int(start):
+			tmpls = _emptyBlockInfo
+		case len(ls) <= int(end):
+			tmpls = ls[start:]
+		default:
+			tmpls = ls[start:end]
+		}
+		s.addCache(func() {
+			s.dao.LoadBlockedIdx(context.TODO(), oType, bType, ls)
+		})
+		for _, id := range tmpls {
+			ids = append(ids, id.ID)
+		}
+	}
+	if res, missed, err = s.dao.BlockedInfosCache(c, ids); err != nil {
+		err = nil
+		cache = false
+		missed = ids
+	}
+	var missInfos []*model.BlockedInfo
+	if len(missed) != 0 {
+		missInfos, err = s.dao.BlockedInfos(c, missed)
+		if err != nil {
+			return
+		}
+		res = append(res, missInfos...)
+	}
+	var (
+		mids []int64
+		oids []int64
+	)
+	for _, i := range res {
+		mids = append(mids, i.UID)
+		oids = append(oids, i.ID)
+	}
+	arg := &acmdl.MidsReq{
+		Mids: mids,
+	}
+	cards, err := s.accountClient.Infos3(c, arg)
+	if err != nil {
+		err = errors.Wrap(err, "Infos")
+		return
+	}
+	reply, _ := s.dao.ReplysCount(c, oids)
+	for _, i := range res {
+		if card, ok := cards.Infos[i.UID]; ok {
+			i.Uname = card.Name
+			i.Face = card.Face
+		}
+		i.CommentSum = reply[strconv.FormatInt(i.ID, 10)]
+		i.Build()
+	}
+	if cache {
+		s.addCache(func() {
+			s.dao.SetBlockedInfosCache(context.TODO(), missInfos)
+		})
+	}
+	return
+}
+
+// AnnouncementInfo get announcement detail.
+func (s *Service) AnnouncementInfo(c context.Context, aid int64) (res *model.BlockedAnnouncement, err error) {
+	var ok bool
+	if res, ok = s.announcement.amap[aid]; !ok {
+		err = ecode.NothingFound
+	}
+	return
+}
+
+// AnnouncementList get announcement list.
+func (s *Service) AnnouncementList(c context.Context, tp int8, pn, ps int64) (resp *model.AnnounceList, err error) {
+	var (
+		ok    bool
+		start = (pn - 1) * ps
+		end   = pn * ps
+		alist []*model.BlockedAnnouncement
+		count int64
+	)
+	resp = &model.AnnounceList{
+		List: _emptyAnnounce,
+	}
+	if tp == model.PublishTypedef {
+		resp.List = s.announcement.def
+		resp.Count = int64(len(s.announcement.def))
+		return
+	}
+	if alist, ok = s.announcement.alist[tp]; !ok {
+		return
+	}
+	count = int64(len(alist))
+	resp.Count = count
+	switch {
+	case count < start:
+	case end >= count:
+		resp.List = alist[start:]
+	default:
+		resp.List = alist[start:end]
+	}
+	return
+}
+
+// LoadAnnouncement load AnnouncementList.
+func (s *Service) LoadAnnouncement(c context.Context) {
+	res, err := s.dao.AnnouncementList(c)
+	if err != nil {
+		return
+	}
+	var (
+		def     []*model.BlockedAnnouncement
+		new     = make([]*model.BlockedAnnouncement, 0, model.PublishInitLen)
+		top     = make([]*model.BlockedAnnouncement, 0, model.PublishInitLen)
+		alist   = make(map[int8][]*model.BlockedAnnouncement)
+		topList = make(map[int8][]*model.BlockedAnnouncement)
+		amap    = make(map[int64]*model.BlockedAnnouncement)
+	)
+	for _, ann := range res {
+		if ann.StickStatus == 1 {
+			top = append(top, ann)
+			topList[ann.Ptype] = append(topList[ann.Ptype], ann)
+		} else if len(new) < model.PublishInitLen {
+			new = append(new, ann)
+		}
+		if ann.StickStatus != 1 {
+			alist[ann.Ptype] = append(alist[ann.Ptype], ann)
+		}
+		amap[ann.ID] = ann
+	}
+	for t, p := range alist {
+		alist[t] = append(topList[t], p...)
+	}
+	if len(top) < model.PublishInitLen {
+		lack := model.PublishInitLen - len(top)
+		if lack > len(new) {
+			def = append(top, new...)
+		} else {
+			def = append(top, new[:lack]...)
+		}
+	} else {
+		def = top[:model.PublishInitLen]
+	}
+	if len(def) == 0 {
+		def = _emptyAnnounce
+	}
+	s.announcement.def = def
+	s.announcement.alist = alist
+	s.announcement.amap = amap
+}
+
+// BlockedNumUser get blocked user number.
+func (s *Service) BlockedNumUser(c context.Context, mid int64) (blockedSum *model.ResBlockedNumUser, err error) {
+	blockedSum = &model.ResBlockedNumUser{}
+	blockedSum.BlockedSum, err = s.dao.BlockedNumUser(c, mid)
+	return
+}
+
+// BatchPublishs get publish info list.
+func (s *Service) BatchPublishs(c context.Context, ids []int64) (res map[int64]*model.BlockedAnnouncement, err error) {
+	res, err = s.dao.BatchPublishs(c, ids)
+	return
+}
+
+// AddBlockedInfo add blocked info.
+func (s *Service) AddBlockedInfo(c context.Context, argJB *model.ArgJudgeBlocked) (err error) {
+	if argJB.OID == 0 && argJB.OPName == "" {
+		log.Error("origin_type(%d) oper_id(%d) && operator_name(%s) not both empty!", argJB.OType, argJB.OID, argJB.OPName)
+		err = ecode.RequestErr
+		return
+	}
+	if argJB.OID == 0 && argJB.OPName != "" {
+		argJB.OID = s.managers[argJB.OPName]
+	}
+	if (argJB.PType == model.PunishTypeForever && argJB.BForever != model.InBlockedForever) ||
+		(argJB.BForever == model.InBlockedForever && argJB.PType != model.PunishTypeForever) {
+		argJB.PType = model.PunishTypeForever
+		argJB.BForever = model.InBlockedForever
+	}
+	if argJB.PType == model.PunishTypeForever && argJB.BForever == model.InBlockedForever {
+		argJB.BDays = 0
+	}
+	bi := &model.BlockedInfo{
+		UID:            argJB.MID,
+		OID:            argJB.OID,
+		BlockedDays:    int64(argJB.BDays),
+		BlockedForever: int64(argJB.BForever),
+		BlockedRemark:  argJB.BRemark,
+		MoralNum:       int64(argJB.MoralNum),
+		OriginContent:  argJB.OContent,
+		OriginTitle:    argJB.OTitle,
+		OriginType:     int64(argJB.OType),
+		OriginURL:      argJB.OURL,
+		PunishTime:     xtime.Time(time.Now().Unix()),
+		PunishType:     int64(argJB.PType),
+		ReasonType:     int64(argJB.RType),
+		BlockedType:    int64(model.PunishBlock),
+		OperatorName:   argJB.OPName,
+	}
+	return s.dao.AddBlockedInfo(c, bi)
+}
+
+// AddBatchBlockedInfo add batch blocked info.
+func (s *Service) AddBatchBlockedInfo(c context.Context, argJBs *model.ArgJudgeBatchBlocked) (err error) {
+	if argJBs.OID == 0 && argJBs.OPName == "" {
+		log.Error("origin_type(%d) oper_id(%d) && operator_name(%s) not both empty!", argJBs.OType, argJBs.OID, argJBs.OPName)
+		err = ecode.RequestErr
+		return
+	}
+	if argJBs.OID == 0 && argJBs.OPName != "" {
+		argJBs.OID = s.managers[argJBs.OPName]
+	}
+	if (argJBs.PType == model.PunishTypeForever && argJBs.BForever != model.InBlockedForever) ||
+		(argJBs.BForever == model.InBlockedForever && argJBs.PType != model.PunishTypeForever) {
+		argJBs.PType = model.PunishTypeForever
+		argJBs.BForever = model.InBlockedForever
+	}
+	if argJBs.PType == model.PunishTypeForever && argJBs.BForever == model.InBlockedForever {
+		argJBs.BDays = 0
+	}
+	var bis []*model.BlockedInfo
+	for _, mid := range argJBs.MID {
+		bi := &model.BlockedInfo{
+			UID:            mid,
+			OID:            argJBs.OID,
+			BlockedDays:    int64(argJBs.BDays),
+			BlockedForever: int64(argJBs.BForever),
+			BlockedRemark:  argJBs.BRemark,
+			MoralNum:       int64(argJBs.MoralNum),
+			OriginContent:  argJBs.OContent,
+			OriginTitle:    argJBs.OTitle,
+			OriginType:     int64(argJBs.OType),
+			OriginURL:      argJBs.OURL,
+			PunishTime:     xtime.Time(argJBs.PTime),
+			PunishType:     int64(argJBs.PType),
+			ReasonType:     int64(argJBs.RType),
+			BlockedType:    int64(model.PunishBlock),
+			OperatorName:   argJBs.OPName,
+		}
+		bis = append(bis, bi)
+	}
+	// begin tran
+	var tx *xsql.Tx
+	if tx, err = s.dao.BeginTran(c); err != nil {
+		err = errors.Wrap(err, "s.dao.BeginTran()")
+		return
+	}
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+		} else {
+			tx.Commit()
+		}
+	}()
+	err = s.dao.TxAddBlockedInfo(tx, bis)
+	return
+}
+
+// BLKHistorys get blocked historys list.
+func (s *Service) BLKHistorys(c context.Context, ah *model.ArgHistory) (rhs *model.ResBLKHistorys, err error) {
+	count, err := s.dao.BLKHistoryCount(c, ah)
+	if err != nil {
+		err = errors.Wrap(err, "s.dao.BLKHistoryCount")
+		return
+	}
+	rhs = &model.ResBLKHistorys{
+		TotalCount: count,
+		PN:         ah.PN,
+		PS:         ah.PS,
+		Items:      _emptyBlockInfo,
+	}
+	if count == 0 {
+		return
+	}
+	rhs.Items, err = s.dao.BLKHistorys(c, ah)
+	if err != nil {
+		err = errors.Wrap(err, "s.dao.BLKHistorys")
+		return
+	}
+	var uids []int64
+	for _, item := range rhs.Items {
+		uids = append(uids, item.UID)
+	}
+	infoMap, err := s.infoMap(c, uids)
+	if err != nil {
+		err = errors.Wrap(err, "s.infoMap")
+		return
+	}
+	for _, item := range rhs.Items {
+		if info, ok := infoMap[item.UID]; ok {
+			item.Uname = info.Name
+			item.Face = info.Face
+		}
+		item.Build()
+	}
+	return
+}
+
+// BatchBLKInfos mutli get blocked info by ids.
+func (s *Service) BatchBLKInfos(c context.Context, ids []int64) (items map[int64]*model.BlockedInfo, err error) {
+	items, err = s.dao.BlockedInfoIDs(c, ids)
+	if err != nil {
+		err = errors.Wrap(err, "s.dao.BLKHistorys")
+		return
+	}
+	var uids []int64
+	for _, item := range items {
+		uids = append(uids, item.UID)
+	}
+	infoMap, err := s.infoMap(c, uids)
+	if err != nil {
+		err = errors.Wrap(err, "s.infoMap")
+		return
+	}
+	for _, item := range items {
+		if info, ok := infoMap[item.UID]; ok {
+			item.Uname = info.Name
+			item.Face = info.Face
+		}
+		item.Build()
+	}
+	return
+}

app/interface/main/credit/service/blocked_test.go

@@ -0,0 +1,88 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// TestBatchBLKInfos .
+func TestBatchBLKInfos(t *testing.T) {
+	Convey("TestBatchBLKInfos", t, func() {
+		res, err := s.BatchBLKInfos(context.TODO(), []int64{1111, 222})
+		So(err, ShouldBeNil)
+		out, err := json.Marshal(res)
+		So(err, ShouldBeNil)
+		So(out, ShouldNotBeNil)
+	})
+}
+
+// TestBlockedUserCard .
+func TestBlockedUserCard(t *testing.T) {
+	Convey("TestBlockedUserCard", t, func() {
+		res, err := s.BlockedUserCard(context.TODO(), 21432418)
+		So(err, ShouldBeNil)
+		out, err := json.Marshal(res)
+		So(err, ShouldBeNil)
+		So(out, ShouldNotBeNil)
+	})
+}
+
+// TestBlockedUserList .
+func TestBlockedUserList(t *testing.T) {
+	Convey("TestBlockedUserList", t, func() {
+		res, err := s.BlockedUserList(context.TODO(), 1)
+		So(err, ShouldBeNil)
+		out, err := json.Marshal(res)
+		So(err, ShouldBeNil)
+		So(out, ShouldNotBeNil)
+	})
+}
+
+// TestBlockedInfo .
+func TestBlockedInfo(t *testing.T) {
+	Convey("TestBlockedInfo", t, func() {
+		res, err := s.BlockedInfo(context.TODO(), 1475)
+		So(err, ShouldBeNil)
+		out, err := json.Marshal(res)
+		So(err, ShouldBeNil)
+		So(out, ShouldNotBeNil)
+	})
+}
+
+// TestBlockedList .
+func TestBlockedList(t *testing.T) {
+	Convey("TestBlockedList", t, func() {
+		res, err := s.BlockedList(context.TODO(), 0, -1, 1, 5)
+		So(err, ShouldBeNil)
+		out, err := json.Marshal(res)
+		So(err, ShouldBeNil)
+		So(out, ShouldNotBeNil)
+	})
+}
+
+// TestAnnouncementInfo .
+func TestAnnouncementInfo(t *testing.T) {
+	Convey("TestAnnouncementInfo", t, func() {
+		s.LoadAnnouncement(context.TODO())
+		res, err := s.AnnouncementInfo(context.TODO(), 48)
+		So(err, ShouldBeNil)
+		out, err := json.Marshal(res)
+		So(err, ShouldBeNil)
+		So(out, ShouldNotBeNil)
+	})
+}
+
+// TestAnnouncementList .
+func TestAnnouncementList(t *testing.T) {
+	Convey("TestAnnouncementList", t, func() {
+		s.LoadAnnouncement(context.TODO())
+		res, err := s.AnnouncementList(context.TODO(), 1, 1, 3)
+		So(err, ShouldBeNil)
+		out, err := json.Marshal(res)
+		So(err, ShouldBeNil)
+		So(out, ShouldNotBeNil)
+	})
+}

app/interface/main/credit/service/extra_func.go

@@ -0,0 +1,228 @@
+package service
+
+import (
+	"context"
+	"math/rand"
+	"sync"
+	"time"
+
+	model "go-common/app/interface/main/credit/model"
+	acmdl "go-common/app/service/main/account/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+)
+
+func (s *Service) caseVoteID(c context.Context, mid int64, pubCid int64) (cid int64, err error) {
+	// 获取发放中cids的列表
+	mcases, err := s.dao.GrantCases(c)
+	if err != nil {
+		log.Error("s.dao.GrantCases error(%v)", err)
+		return
+	}
+	if len(mcases) == 0 {
+		log.Warn("no grant cases(%+v)!", mcases)
+		return
+	}
+	// 7天内已投cids
+	weekcases, err := s._caseObtainMID(c, mid, 7, model.CaseObtainNoToday)
+	if err != nil {
+		log.Error("s._caseObtainMID(%d, 7, %t) error(%v)", mid, model.CaseObtainNoToday, err)
+		return
+	}
+	// 今天内已投cids
+	todaycases, err := s._caseObtainMID(c, mid, 0, model.CaseObtainToday)
+	if err != nil {
+		log.Error("s._caseObtainMID(%d, 0, %t) error(%v)", mid, model.CaseObtainToday, err)
+		return
+	}
+	todayPubVote := 0
+	tpmcids := make(map[int64]struct{})
+	// 今天已投cid的map
+	for _, tcase := range todaycases {
+		if tcase.CaseType == model.JudeCaseTypePublic {
+			tpmcids[tcase.ID] = struct{}{}
+			todayPubVote++
+		}
+	}
+	vcids := []int64{}
+	for wcid := range weekcases {
+		vcids = append(vcids, wcid)
+	}
+	for cid, m := range mcases {
+		if _, ok := tpmcids[cid]; !ok && m.CaseType == model.JudeCaseTypePublic {
+			todayPubVote++
+		}
+		// 把被举报人是风纪委用户自己和结案时间后10分钟的稿件  加入用户已投稿列表
+		if m.Mid == mid || m.Etime.Time().Add(-time.Duration(s.c.Judge.ReservedTime)).Before(time.Now()) {
+			vcids = append(vcids, cid)
+			continue
+		}
+	}
+	tLen := len(todaycases)
+	// 获取案件最大数判断
+	if int64(tLen-todayPubVote) >= s.c.Judge.CaseObtainMax {
+		err = ecode.CreditCaseMax
+		return
+	}
+	// 制作非可投cids的map
+	vmcids := make(map[int64]struct{})
+	for _, uncid := range vcids {
+		vmcids[uncid] = struct{}{}
+	}
+	// 小众
+	pteCids := make([]int64, 0)
+	// 大众
+	pubCids := make([]int64, 0)
+	// 大众cid的map
+	mpCids := make(map[int64]struct{})
+	// 取出可投cids
+	for kcid, m := range mcases {
+		if _, ok := vmcids[kcid]; ok {
+			continue
+		}
+		if m.CaseType == model.JudeCaseTypePublic {
+			pubCids = append(pubCids, kcid)
+			mpCids[kcid] = struct{}{}
+		} else {
+			pteCids = append(pteCids, kcid)
+		}
+	}
+	pubLen := len(pubCids)
+	pteLen := len(pteCids)
+	// 没有可投的案件
+	if pubLen+pteLen == 0 {
+		log.Warn("mid(%d) no case can vote!", mid)
+		return
+	}
+	var caseType int8
+	_, ok := mpCids[pubCid]
+	if pubCid != 0 && !ok {
+		return
+	}
+	if pubCid != 0 && ok {
+		cid = pubCid
+		caseType = model.JudeCaseTypePublic
+	} else {
+		radio := rand.New(rand.NewSource(time.Now().UnixNano()))
+		if pubLen > 0 {
+			cid = s._randCid(pubCids, radio)
+			caseType = model.JudeCaseTypePublic
+		} else if pteLen > 0 {
+			cid = s._randCid(pteCids, radio)
+			caseType = model.JudeCaseTypePrivate
+		}
+	}
+	// db插入用户投票数据
+	if err = s.dao.InsVote(c, mid, cid, s.c.Judge.CaseCheckTime); err != nil {
+		log.Error("s.dao.InsVote( mid(%d), cid(%d), s.c.Judge.CaseCheckTime(%d)) error(%v)", mid, cid, s.c.Judge.CaseCheckTime, err)
+		return
+	}
+	mcid := &model.SimCase{ID: cid, CaseType: caseType}
+	// 从redis的set中设置用户已投cids
+	if err = s.dao.SetVoteCaseMID(c, mid, mcid); err != nil {
+		log.Error("s.dao.SetVoteCaseMID(%d,%+v) error(%v)", mid, mcid, err)
+		return
+	}
+	log.Info("CaseObtain mid:%d total:%d CaseObtainMax:%d cid:%d", mid, int64(tLen+todayPubVote), s.c.Judge.CaseObtainMax, cid)
+	// db插入case投放总数
+	if err = s.dao.AddCaseVoteTotal(c, "put_total", cid, 1); err != nil {
+		log.Error("s.dao.InsVote( mid(%d), cid(%d), s.c.Judge.CaseCheckTime(%d)) error(%v)", mid, cid, s.c.Judge.CaseCheckTime, err)
+	}
+	return
+}
+
+// 获取用户N天内已投列表
+func (s *Service) _caseObtainMID(c context.Context, mid int64, day int, isToday bool) (cases map[int64]*model.SimCase, err error) {
+	isExpired, err := s.dao.IsExpiredObtainMID(c, mid, isToday)
+	if err != nil {
+		log.Error("s.dao.IsExpiredObtainMID(%d,%t) error(%v)", mid, isToday, err)
+		return
+	}
+	if isExpired {
+		cases, err = s.dao.CaseObtainMID(c, mid, isToday)
+		if err != nil {
+			log.Error("s.dao.CaseObtainByMID(%d,%t) error(%v)", mid, isToday, err)
+			return
+		}
+	} else {
+		if cases, err = s.dao.LoadVoteIDsMid(c, mid, day); err != nil {
+			log.Error("s.dao.LoadVoteIDsMid(%d,%d) error(%v)", mid, day, err)
+			return
+		}
+		if len(cases) == 0 {
+			return
+		}
+		s.addCache(func() {
+			if err = s.dao.LoadVoteCaseMID(context.TODO(), mid, cases, isToday); err != nil {
+				log.Error("s.dao.LoadVoteCaseMID(%d,%v,%t) error(%v)", mid, cases, isToday, err)
+				return
+			}
+		})
+	}
+	return
+}
+
+// cid 取值的随机算法
+func (s *Service) _randCid(cids []int64, radio *rand.Rand) (cid int64) {
+	// 随机取出数组的游标
+	rand := int64(radio.Intn(len(cids)))
+	cid = cids[rand]
+	return
+}
+
+// 列表批量异步获取用户信息
+func (s *Service) infoMap(c context.Context, uids []int64) (infoMap map[int64]*acmdl.Info, err error) {
+	total := len(uids)
+	pageNum := total / model.JuryMultiJuryerInfoMax
+	if total%model.JuryMultiJuryerInfoMax != 0 {
+		pageNum++
+	}
+	var (
+		g  errgroup.Group
+		lk sync.RWMutex
+	)
+	infoMap = make(map[int64]*acmdl.Info, total)
+	for i := 0; i < pageNum; i++ {
+		start := i * model.JuryMultiJuryerInfoMax
+		end := (i + 1) * model.JuryMultiJuryerInfoMax
+		if end > total {
+			end = total
+		}
+		g.Go(func() (err error) {
+			var (
+				arg = &acmdl.MidsReq{Mids: uids[start:end]}
+				res *acmdl.InfosReply
+			)
+			if res, err = s.accountClient.Infos3(c, arg); err != nil {
+				log.Error("s.accountClient.Infos3(%v) error(%v)", arg, err)
+				err = nil
+			} else {
+				for uid, info := range res.Infos {
+					lk.Lock()
+					infoMap[uid] = info
+					lk.Unlock()
+				}
+			}
+			return
+		})
+	}
+	if err = g.Wait(); err != nil {
+		log.Error("g.Wait() error(%v)", err)
+	}
+	return
+}
+
+// userInfo one user card.
+func (s *Service) userInfo(c context.Context, mid int64) (card *acmdl.CardReply, err error) {
+	if mid == 0 {
+		return
+	}
+	arg := &acmdl.MidReq{
+		Mid: mid,
+	}
+	if card, err = s.accountClient.Card3(c, arg); err != nil {
+		log.Error("s.accountClient.Card3(%+v) error(%+v)", arg, err)
+	}
+	return
+}

app/interface/main/credit/service/jury_test.go

@@ -0,0 +1,239 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	credit "go-common/app/interface/main/credit/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// TestSpJuryCase .
+func TestSpJuryCase(t *testing.T) {
+	Convey("TestSpJuryCase", t, func() {
+		mid := int64(27515259)
+		cid := int64(797)
+		bc, err := s.SpJuryCase(context.TODO(), mid, cid)
+		So(err, ShouldBeNil)
+		So(bc, ShouldNotBeNil)
+	})
+}
+
+// TestVoteInfoMID .
+func TestVoteInfoMID(t *testing.T) {
+	Convey("TestVoteInfoMID", t, func() {
+		mid := int64(27515259)
+		cid := int64(797)
+		bc, err := s.VoteInfoCache(context.TODO(), mid, cid)
+		So(err, ShouldBeNil)
+		So(bc, ShouldNotBeNil)
+	})
+}
+
+// TestObtainCase .
+func TestObtainCase(t *testing.T) {
+	Convey("TestObtainCase", t, func() {
+		mid := int64(88889018)
+		cid, err := s.caseVoteID(context.TODO(), mid, 0)
+		So(err, ShouldBeNil)
+		So(cid, ShouldNotBeNil)
+	})
+}
+
+// TestServiceApply
+func TestServiceApply(t *testing.T) {
+	Convey("TestServiceApply", t, func() {
+		var (
+			mid int64 = 2089809
+			c         = context.TODO()
+		)
+		err := s.Apply(c, mid)
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestServiceRequirement
+func TestServiceRequirement(t *testing.T) {
+	Convey("TestServiceApply", t, func() {
+		var (
+			mid int64 = 88889019
+			c         = context.TODO()
+		)
+		jr, err := s.Requirement(c, mid)
+		So(err, ShouldBeNil)
+		So(jr, ShouldNotBeNil)
+	})
+}
+
+// TestServiceJury
+func TestServiceJury(t *testing.T) {
+	Convey("TestServiceJury", t, func() {
+		var (
+			mid int64 = 27515274
+			c         = context.TODO()
+		)
+		res, err := s.Jury(c, mid)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+// TestServiceCaseObtain
+func TestServiceCaseObtain(t *testing.T) {
+	Convey("TestServiceJury", t, func() {
+		var (
+			mid int64 = 21432418
+			c         = context.TODO()
+		)
+		cid, err := s.CaseObtain(c, mid, 308)
+		So(err, ShouldBeNil)
+		So(cid, ShouldNotBeNil)
+	})
+}
+
+// TestServiceVote .
+func TestServiceVote(t *testing.T) {
+	Convey("TestServiceVote", t, func() {
+		var (
+			mid int64 = 9
+			cid int64 = 1
+			v   int8  = 2
+			c         = context.TODO()
+		)
+		err := s.Vote(c, mid, cid, v, 1, 1, 1, "", []int64{1, 2, 3}, []int64{4, 5, 6})
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestServiceVoteInfo(t *testing.T) {
+	Convey("TestServiceVoteInfo", t, func() {
+		var (
+			mid int64 = 9
+			cid int64 = 1
+			c         = context.TODO()
+		)
+		res, err := s.VoteInfo(c, mid, cid)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func TestServiceCaseInfo(t *testing.T) {
+	Convey("TestServiceCaseInfo", t, func() {
+		var (
+			c         = context.TODO()
+			cid int64 = 304
+		)
+		res, err := s.CaseInfo(c, cid)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func TestServiceJuryCase(t *testing.T) {
+	Convey("TestServiceJuryCase", t, func() {
+		var (
+			mid int64 = 27515274
+			cid int64 = 708
+			c         = context.TODO()
+		)
+		res, err := s.JuryCase(c, mid, cid)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func TestServiceCaseList(t *testing.T) {
+	Convey("TestServiceCaseList", t, func() {
+		var (
+			mid int64 = 21432418
+			pn  int64 = 1
+			ps  int64 = 10
+			c         = context.TODO()
+		)
+		res, err := s.CaseList(c, mid, ps, pn)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func TestService_KPIList(t *testing.T) {
+	Convey("TestService_KPIList", t, func() {
+		var (
+			err error
+			c   = context.TODO()
+			res []*credit.KPI
+		)
+		res, err = s.KPIList(c, 88889017)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func TestCaseOpinion(t *testing.T) {
+	Convey("TestCaseOpinion", t, func() {
+		res, _, err := s.CaseOpinion(context.TODO(), 679, 1, 3)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func TestVoteOpinion(t *testing.T) {
+	Convey("TestVoteOpinion", t, func() {
+		res, _, err := s.VoteOpinion(context.TODO(), 679, 1, 3, 1)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func TestAddBlockedCases(t *testing.T) {
+	Convey("TestVoteOpinion", t, func() {
+		var (
+			bc []*credit.ArgJudgeCase
+			b  = &credit.ArgJudgeCase{}
+			b1 = &credit.ArgJudgeCase{}
+		)
+		b.MID = 1
+		b.Operator = "a"
+		b.OContent = "'aaaaa,"
+		b.PunishResult = 1
+		b.OTitle = "ot"
+		b.OType = 1
+		b.OURL = "ou"
+		b.BlockedDays = 1
+		b.ReasonType = 1
+		b.RelationID = "1-1"
+		b.RPID = 11
+		b.Type = 1
+		b.OID = 1111
+		b.MID = 1
+
+		b1.Operator = "b"
+		b1.OContent = ",'bbbbb'''"
+		b1.PunishResult = 2
+		b1.OTitle = "ot"
+		b1.OType = 1
+		b1.OURL = "ou"
+		b1.BlockedDays = 2
+		b1.ReasonType = 2
+		b1.RelationID = "1-1"
+		b1.RPID = 22
+		b1.Type = 2
+		b1.OID = 22222
+		bc = append(bc, b)
+		bc = append(bc, b1)
+		err := s.AddBlockedCases(context.TODO(), bc)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestCaseObtainByID(t *testing.T) {
+	Convey("TestVoteOpinion", t, func() {
+		var (
+			c = context.TODO()
+		)
+		err := s.CaseObtainByID(c, 88889018, 309)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/credit/service/labour.go

@@ -0,0 +1,231 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	model "go-common/app/interface/main/credit/model"
+	"go-common/app/service/main/archive/api"
+	arcMDL "go-common/app/service/main/archive/model/archive"
+	blkmdl "go-common/app/service/main/member/model/block"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	xtime "go-common/library/time"
+	"go-common/library/xstr"
+)
+
+// AddQs add labour question.
+func (s *Service) AddQs(c context.Context, qs *model.LabourQs) (err error) {
+	return s.dao.AddQs(c, qs)
+}
+
+// SetQs set labour question field.
+func (s *Service) SetQs(c context.Context, id int64, ans int64, status int64) (err error) {
+	return s.dao.SetQs(c, id, ans, status)
+}
+
+// DelQs del labour question.
+func (s *Service) DelQs(c context.Context, id int64, isDel int64) (err error) {
+	return s.dao.DelQs(c, id, isDel)
+}
+
+// GetQs get question.
+func (s *Service) GetQs(c context.Context, mid int64) (qs []*model.LabourQs, err error) {
+	var (
+		ok                   bool
+		arc                  *api.Arc
+		getids, qsids, avids []int64
+		marc                 map[int64]*api.Arc
+		block                *blkmdl.RPCResInfo
+	)
+	defer func() {
+		if err == nil {
+			if len(avids) != 0 {
+				marc, _ = s.arcRPC.Archives3(c, &arcMDL.ArgAids2{Aids: avids, RealIP: metadata.String(c, metadata.RemoteIP)})
+			}
+			for _, q := range qs {
+				qsids = append(qsids, q.ID)
+				if arc, ok = marc[q.AvID]; !ok {
+					log.Warn("aid(%d) is not extists, [mid(%d)-qid(%d)]", q.AvID, mid, q.ID)
+					q.AvID = 0
+					continue
+				}
+				q.AvTitle = arc.Title
+				if !model.ArcVisible(arc.State) {
+					log.Warn("aid(%d) atitle(%s) state(%d) is not visible, [mid(%d)-qid(%d)]", q.AvID, q.AvTitle, arc.State, mid, q.ID)
+					q.AvID = 0
+				}
+			}
+			qsCache := &model.QsCache{
+				Stime: xtime.Time(time.Now().Unix()),
+				QsStr: xstr.JoinInts(qsids),
+			}
+			s.dao.SetQsCache(c, mid, qsCache)
+		}
+	}()
+	if block, err = s.memRPC.BlockInfo(c, &blkmdl.RPCArgInfo{MID: mid}); err != nil {
+		return
+	}
+	status := int8(block.BlockStatus)
+	if status == model.BlockStatusNone {
+		err = ecode.CreditNoblock
+		return
+	}
+	if status == model.BlockStatusForever {
+		err = ecode.CreditForeverBlock
+		return
+	}
+	var qsIDs *model.AIQsID
+	qsIDs, err = s.dao.GetQS(c, mid)
+	if err != nil {
+		log.Error("s.dao.GetQS(%d,%s) error(%+v)", mid, metadata.String(c, metadata.RemoteIP), err)
+		err = nil
+		qs = s.question
+		avids = s.avIDs
+		return
+	}
+	getids = append(getids, qsIDs.Pend...)
+	getids = append(getids, qsIDs.Done...)
+	idStr := xstr.JoinInts(getids)
+	if _, qs, avids, err = s.dao.QsAllList(c, idStr); err != nil {
+		return
+	}
+	if len(qs) != s.c.Property.QsNum {
+		log.Warn("creditQsNumError(mid:%d,idstr:%s,qs:%+v),len:%d", mid, idStr, qs, len(qs))
+		qs = s.question
+		avids = s.avIDs
+	}
+	return
+}
+
+// CommitQs commit questions.
+func (s *Service) CommitQs(c context.Context, mid int64, refer string, ua string, buvid string, ans *model.LabourAns) (commitRs *model.CommitRs, err error) {
+	var (
+		num   int64
+		qs    map[int64]*model.LabourQs
+		block *blkmdl.RPCResInfo
+	)
+	if block, err = s.memRPC.BlockInfo(c, &blkmdl.RPCArgInfo{MID: mid}); err != nil {
+		return
+	}
+	status := int8(block.BlockStatus)
+	if status == model.BlockStatusNone {
+		err = ecode.CreditNoblock
+		return
+	}
+	if status == model.BlockStatusForever {
+		err = ecode.CreditForeverBlock
+		return
+	}
+	if len(ans.ID) != s.c.Property.QsNum || len(ans.Answer) != s.c.Property.QsNum {
+		err = ecode.CreditAnsNumError
+		log.Error("CreditAnsNumError(mid:%d,id:%+v，ans:%+v)", mid, ans.ID, ans.Answer)
+		return
+	}
+	idStr := xstr.JoinInts(ans.ID)
+	qsCache, _ := s.dao.GetQsCache(c, mid)
+	if qsCache == nil || qsCache.QsStr != idStr {
+		err = ecode.RequestErr
+		return
+	}
+	if qs, _, _, err = s.dao.QsAllList(c, idStr); err != nil {
+		return
+	}
+	if len(qs) != s.c.Property.QsNum {
+		log.Error("CreditRightAnsNumError(mid:%d,qs:%+v)", mid, qs)
+	}
+	for id, qsid := range ans.ID {
+		if ans.Answer[id] != 1 && ans.Answer[id] != 2 {
+			err = ecode.RequestErr
+			log.Error("CreditAnsError(mid:%d,id:%+v，ans:%+v)", mid, ans.ID, ans.Answer)
+			return
+		}
+		if v, ok := qs[qsid]; ok {
+			if v.Ans == ans.Answer[id] {
+				num++
+			}
+		}
+	}
+	commitRs = &model.CommitRs{}
+	commitRs.Score = num * s.c.Property.PerScore
+	if commitRs.Score >= 100 {
+		commitRs.Score = 100
+		if status == model.BlockStatusNone {
+			commitRs.Day = 0
+		} else {
+			rts := time.Until(time.Unix(block.EndTime, 0))
+			commitRs.Day = int64(rts / (time.Hour * 24))
+			if int64(rts%(time.Hour*24)) > 0 {
+				commitRs.Day++
+			}
+		}
+	}
+	anstr, err := json.Marshal(ans)
+	if err != nil {
+		log.Error("json.Marshal() error(%v)", err)
+		return
+	}
+	id, err := s.dao.AddAnsLog(c, mid, commitRs.Score, string(anstr), qsCache.Stime)
+	if err != nil {
+		return
+	}
+	var msg model.DataBusResult
+	msg.Mid = mid
+	msg.Buvid = buvid
+	msg.IP = metadata.String(c, metadata.RemoteIP)
+	msg.Ua = ua
+	msg.Refer = refer
+	msg.Score = commitRs.Score
+	for idx, qsid := range ans.ID {
+		var rs = model.Rs{}
+		rs.ID = qsid
+		rs.Ans = ans.Answer[idx]
+		if v, ok := qs[qsid]; ok {
+			rs.Question = v.Question
+			rs.TrueAns = v.Ans
+			rs.AvID = v.AvID
+			rs.Status = v.Status
+			rs.Source = v.Source
+			rs.Ctime = v.Ctime
+			rs.Mtime = v.Mtime
+		}
+		msg.Rs = append(msg.Rs, rs)
+	}
+	if err = s.dao.PubLabour(c, id, msg); err != nil {
+		log.Error("s.dao.PubLabour(%d,%+v) error(%+v)", id, msg, err)
+		return
+	}
+	log.Info("PubLabour id(%d) msg(%+v)", id, msg)
+	s.dao.DelQsCache(c, mid)
+	return
+}
+
+// IsAnswered labour check user is answwered question between the time.
+func (s *Service) IsAnswered(c context.Context, mid int64, mtime int64) (state int8, err error) {
+	var (
+		mc    = true
+		found bool
+	)
+	if state, found, err = s.dao.GetAnswerStateCache(c, mid); err != nil {
+		err = nil
+		mc = false
+	}
+	if found {
+		return
+	}
+	var status bool
+	if status, err = s.dao.AnswerStatus(c, mid, time.Unix(mtime, 0)); err != nil {
+		return
+	}
+	if status {
+		state = model.LabourOkAnswer
+	}
+	if mc {
+		s.addCache(func() {
+			s.dao.SetAnswerStateCache(context.TODO(), mid, state)
+		})
+	}
+	return
+}

app/interface/main/credit/service/labour_test.go

@@ -0,0 +1,53 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/credit/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// TestServiceAddQs .
+func TestServiceAddQs(t *testing.T) {
+	Convey("TestServiceAddQs", t, func() {
+		qs := &model.LabourQs{}
+		qs.Question = "test"
+		qs.AvID = 666
+		qs.Source = 1
+		err := s.AddQs(context.TODO(), qs)
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestServiceSetQs
+func TestServiceSetQs(t *testing.T) {
+	Convey("TestServiceSetQs", t, func() {
+		var (
+			c            = context.TODO()
+			id     int64 = 3
+			ans    int64 = 2
+			status int64 = 2
+		)
+		err := s.SetQs(c, id, ans, status)
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestCommit .
+func TestCommit(t *testing.T) {
+	Convey("TestCommit", t, func() {
+		ans := &model.LabourAns{
+			ID:     []int64{},
+			Answer: []int64{},
+		}
+		for i := 0; i < 40; i++ {
+			ans.ID = append(ans.ID, int64(i))
+			ans.Answer = append(ans.Answer, 1)
+		}
+		res, err := s.CommitQs(context.TODO(), 88895349, "aa", "1", "11", ans)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}

app/interface/main/credit/service/service.go

@@ -0,0 +1,226 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/credit/conf"
+	dao "go-common/app/interface/main/credit/dao"
+	model "go-common/app/interface/main/credit/model"
+	accgrpc "go-common/app/service/main/account/api"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	fligrpc "go-common/app/service/main/filter/api/grpc/v1"
+	memrpc "go-common/app/service/main/member/api/gorpc"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+// Service struct of service.
+type Service struct {
+	dao *dao.Dao
+	// rpc
+	arcRPC *arcrpc.Service2
+	memRPC *memrpc.Service
+	// grpc
+	accountClient accgrpc.AccountClient
+	fliClient     fligrpc.FilterClient
+	// conf
+	c        *conf.Config
+	question []*model.LabourQs
+	avIDs    []int64
+	missch   chan func()
+	// announcement
+	announcement *announcement
+	managers     map[string]int64
+	tagMap       map[int8]int64
+}
+
+type announcement struct {
+	def   []*model.BlockedAnnouncement
+	alist map[int8][]*model.BlockedAnnouncement
+	amap  map[int64]*model.BlockedAnnouncement
+}
+
+// New create service instance and return.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:      c,
+		dao:    dao.New(c),
+		missch: make(chan func(), 1024000),
+		arcRPC: arcrpc.New2(c.RPCClient2.Archive),
+		memRPC: memrpc.New(c.RPCClient2.Member),
+		tagMap: make(map[int8]int64),
+		announcement: &announcement{
+			def:   make([]*model.BlockedAnnouncement, 0, 4),
+			alist: make(map[int8][]*model.BlockedAnnouncement),
+			amap:  make(map[int64]*model.BlockedAnnouncement),
+		},
+	}
+	var err error
+	if s.fliClient, err = fligrpc.NewClient(c.GRPCClient.Filter); err != nil {
+		panic(errors.WithMessage(err, "Failed to dial filter service"))
+	}
+	if s.accountClient, err = accgrpc.NewClient(c.GRPCClient.Account); err != nil {
+		panic(errors.WithMessage(err, "Failed to dial account service"))
+	}
+	s.initTag()
+	s.loadConf()
+	s.loadQuestion()
+	s.loadManager()
+	s.LoadAnnouncement(context.TODO())
+	go s.loadConfproc()
+	go s.loadQuestionproc()
+	go s.loadManagerproc()
+	go s.loadAnnouncementproc()
+	go s.cacheproc()
+	return
+}
+
+func (s *Service) loadConfproc() {
+	for {
+		time.Sleep(time.Duration(s.c.Judge.ConfTimer))
+		s.loadConf()
+	}
+}
+
+func (s *Service) loadQuestionproc() {
+	for {
+		time.Sleep(time.Duration(s.c.Judge.ConfTimer))
+		s.loadQuestion()
+	}
+}
+
+func (s *Service) loadManagerproc() {
+	for {
+		time.Sleep(time.Duration(s.c.Judge.LoadManagerTime))
+		s.loadManager()
+	}
+}
+
+func (s *Service) loadAnnouncementproc() {
+	for {
+		time.Sleep(time.Duration(s.c.Judge.ConfTimer))
+		s.LoadAnnouncement(context.TODO())
+	}
+}
+
+func (s *Service) loadConf() {
+	m, err := s.dao.LoadConf(context.TODO())
+	if err != nil {
+		log.Error("loadConf error(%v)", err)
+		return
+	}
+	if s.c.Judge.CaseGiveHours, err = strconv.ParseInt(m["case_give_hours"], 10, 64); err != nil {
+		log.Error("loadConf CaseGiveHours error(%v)", err)
+	}
+	if s.c.Judge.CaseCheckTime, err = strconv.ParseInt(m["case_check_hours"], 10, 64); err != nil {
+		log.Error("loadConf CaseCheckTime error(%v)", err)
+	}
+	if s.c.Judge.JuryRatio, err = strconv.ParseInt(m["jury_vote_radio"], 10, 64); err != nil {
+		log.Error("loadConf JuryRatio error(%v)", err)
+	}
+	if s.c.Judge.JudgeRadio, err = strconv.ParseInt(m["case_judge_radio"], 10, 64); err != nil {
+		log.Error("loadConf JudgeRadio error(%v)", err)
+	}
+	if s.c.Judge.CaseVoteMin, err = strconv.ParseInt(m["case_vote_min"], 10, 64); err != nil {
+		log.Error("loadConf CaseVoteMin error(%v)", err)
+	}
+	if s.c.Judge.CaseObtainMax, err = strconv.ParseInt(m["case_obtain_max"], 10, 64); err != nil {
+		log.Error("loadConf CaseObtainMax error(%v)", err)
+	}
+	if s.c.Judge.CaseVoteMax, err = strconv.ParseInt(m["case_vote_max"], 10, 64); err != nil {
+		log.Error("loadConf CaseVoteMax error(%v)", err)
+	}
+	if s.c.Judge.JuryApplyMax, err = strconv.ParseInt(m["jury_apply_max"], 10, 64); err != nil {
+		log.Error("loadConf JuryApplyMax error(%v)", err)
+	}
+	if s.c.Judge.CaseLoadMax, err = strconv.Atoi(m["case_load_max"]); err != nil {
+		log.Error("loadConf CaseLoadMax error(%v)", err)
+	}
+	var caseLoadSwitch int64
+	if caseLoadSwitch, err = strconv.ParseInt(m["case_load_switch"], 10, 64); err != nil {
+		log.Error("loadConf CaseLoadSwitch error(%v)", err)
+	}
+	s.c.Judge.CaseLoadSwitch = int8(caseLoadSwitch)
+	if _, ok := m["vote_num"]; !ok {
+		s.c.Judge.VoteNum.RateS = 1
+		s.c.Judge.VoteNum.RateA = 1
+		s.c.Judge.VoteNum.RateB = 1
+		s.c.Judge.VoteNum.RateC = 1
+		s.c.Judge.VoteNum.RateD = 1
+		return
+	}
+	if err = json.Unmarshal([]byte(m["vote_num"]), &s.c.Judge.VoteNum); err != nil {
+		log.Error("loadConf vote_num error(%v)", err)
+	}
+}
+
+func (s *Service) initTag() {
+	s.tagMap[model.OriginReply] = s.c.TagID.Reply
+	s.tagMap[model.OriginDM] = s.c.TagID.DM
+	s.tagMap[model.OriginMsg] = s.c.TagID.Msg
+	s.tagMap[model.OriginTag] = s.c.TagID.Tag
+	s.tagMap[model.OriginMember] = s.c.TagID.Member
+	s.tagMap[model.OriginArchive] = s.c.TagID.Archive
+	s.tagMap[model.OriginMusic] = s.c.TagID.Music
+	s.tagMap[model.OriginArticle] = s.c.TagID.Article
+	s.tagMap[model.OriginSpaceTop] = s.c.TagID.SpaceTop
+}
+
+func (s *Service) loadManager() {
+	managers, err := s.dao.Managers(context.TODO())
+	if err != nil {
+		log.Error("s.dao.Managers error(%v)", err)
+		return
+	}
+	s.managers = managers
+}
+
+func (s *Service) loadQuestion() {
+	audit, avIDs, err := s.dao.LastAuditQuestion(context.TODO())
+	if err != nil {
+		log.Error("s.dao.LastAuditQuestion error(%v)", err)
+		return
+	}
+	noAudit, noAvIDs, err := s.dao.LastNoAuditQuestion(context.TODO())
+	if err != nil {
+		log.Error("s.dao.LastNoAuditQuestion error(%v)", err)
+		return
+	}
+	audit = append(audit, noAudit...)
+	avIDs = append(avIDs, noAvIDs...)
+	s.question = audit
+	s.avIDs = avIDs
+}
+
+// Ping check server ok.
+func (s *Service) Ping(c context.Context) (err error) {
+	if err = s.dao.Ping(c); err != nil {
+		return
+	}
+	return s.dao.Ping(c)
+}
+
+// Close dao.
+func (s *Service) Close() {
+	s.dao.Close()
+}
+
+func (s *Service) addCache(f func()) {
+	select {
+	case s.missch <- f:
+	default:
+		log.Warn("cacheproc chan full")
+	}
+}
+
+// cacheproc is a routine for executing closure.
+func (s *Service) cacheproc() {
+	for {
+		f := <-s.missch
+		f()
+	}
+}

app/interface/main/credit/service/service_test.go

@@ -0,0 +1,55 @@
+package service
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/credit/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	s *Service
+)
+
+// func CleanCache() {
+// 	c := context.TODO()
+// 	pool := redis.NewPool(conf.Conf.Redis.Config)
+// 	pool.Get(c).Do("FLUSHDB")
+// }
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/convey-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	s = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+// func WithService(f func(s *Service)) func() {
+// 	return func() {
+// 		Reset(func() { CleanCache() })
+// 		f(s)
+// 	}
+// }
+
+func Test_LoadConf(t *testing.T) {
+	Convey("should return err be nil", t, func() {
+		s.loadConf()
+		fmt.Printf("%+v", s.c.Judge)
+	})
+}
+
+func Test_BatchBLKCases(t *testing.T) {
+	ids := []int64{111, 22, 333}
+	Convey("return someting", t, func() {
+		cas, err := s.BatchBLKCases(context.TODO(), ids)
+		So(err, ShouldBeNil)
+		So(cas, ShouldNotBeNil)
+	})
+}