138 lines
3.3 KiB
Go
138 lines
3.3 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"math/rand"
|
|
"time"
|
|
|
|
"go-common/app/admin/main/coupon/model"
|
|
"go-common/library/ecode"
|
|
"go-common/library/log"
|
|
)
|
|
|
|
// CodePage code page.
|
|
func (s *Service) CodePage(c context.Context, a *model.ArgCouponCode) (res *model.CodePage, err error) {
|
|
res = new(model.CodePage)
|
|
var (
|
|
count int64
|
|
b *model.CouponBatchInfo
|
|
now = time.Now().Unix()
|
|
)
|
|
if count, err = s.dao.CountCode(c, a); err != nil {
|
|
return
|
|
}
|
|
if count <= 0 {
|
|
return
|
|
}
|
|
if res.CodeList, err = s.dao.CodeList(c, a); err != nil {
|
|
return
|
|
}
|
|
for _, v := range res.CodeList {
|
|
if b, err = s.BatchInfo(c, v.BatchToken); err != nil {
|
|
return
|
|
}
|
|
if b.ExpireDay == -1 && b.ExpireTime <= now {
|
|
v.State = model.CodeStateExpire
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// CodeBlock code block.
|
|
func (s *Service) CodeBlock(c context.Context, a *model.ArgCouponCode) (err error) {
|
|
var code *model.CouponCode
|
|
if code, err = s.dao.CodeByID(c, a.ID); err != nil {
|
|
return
|
|
}
|
|
if code == nil || code.State != model.CodeStateNotUse {
|
|
return ecode.RequestErr
|
|
}
|
|
return s.dao.UpdateCodeBlock(c, &model.CouponCode{ID: a.ID, State: model.CodeStateBlock, Ver: code.Ver})
|
|
}
|
|
|
|
// CodeUnBlock code un block.
|
|
func (s *Service) CodeUnBlock(c context.Context, a *model.ArgCouponCode) (err error) {
|
|
var code *model.CouponCode
|
|
if code, err = s.dao.CodeByID(c, a.ID); err != nil {
|
|
return
|
|
}
|
|
if code == nil || code.State != model.CodeStateBlock {
|
|
return ecode.RequestErr
|
|
}
|
|
return s.dao.UpdateCodeBlock(c, &model.CouponCode{ID: a.ID, State: model.CodeStateNotUse, Ver: code.Ver})
|
|
}
|
|
|
|
// ExportCode export code.
|
|
func (s *Service) ExportCode(c context.Context, a *model.ArgCouponCode) (res []string, err error) {
|
|
if a.BatchToken == "" {
|
|
return nil, ecode.RequestErr
|
|
}
|
|
var cs []*model.CouponCode
|
|
a.Ps = 1000
|
|
a.Pn = 1
|
|
for {
|
|
if cs, err = s.dao.CodeList(context.Background(), a); err != nil {
|
|
return
|
|
}
|
|
if len(cs) == 0 {
|
|
break
|
|
}
|
|
for _, v := range cs {
|
|
res = append(res, v.Code)
|
|
}
|
|
a.Pn++
|
|
}
|
|
return
|
|
}
|
|
|
|
// InitCodes init codes
|
|
func (s *Service) InitCodes(c context.Context, token string) (err error) {
|
|
var info *model.CouponBatchInfo
|
|
if info, err = s.dao.BatchInfo(c, token); err != nil {
|
|
return
|
|
}
|
|
if info == nil {
|
|
return
|
|
}
|
|
if info.MaxCount == 0 || info.MaxCount > model.BatchCodeMaxCount {
|
|
return
|
|
}
|
|
// init code.
|
|
go func() {
|
|
log.Info("init code start arg[%s,%d]", token, info.MaxCount)
|
|
cs := []*model.CouponCode{}
|
|
for i := int64(0); i < info.MaxCount; i++ {
|
|
cs = append(cs, &model.CouponCode{
|
|
BatchToken: token,
|
|
State: model.CodeStateNotUse,
|
|
Code: codeToken(i),
|
|
CouponType: model.CouponAllowance,
|
|
})
|
|
if len(cs) == int(info.MaxCount) || len(cs)%model.BatchAddCodeSlice == 0 {
|
|
if err = s.dao.BatchAddCode(context.Background(), cs); err != nil {
|
|
log.Error("init code error[%s,%v]", token, err)
|
|
return
|
|
}
|
|
log.Info("init code ing arg[%s,%d,%d]", token, info.MaxCount, i)
|
|
time.Sleep(50 * time.Millisecond)
|
|
cs = []*model.CouponCode{}
|
|
}
|
|
}
|
|
log.Info("init code end arg[%s,%d]", token, info.MaxCount)
|
|
}()
|
|
return
|
|
}
|
|
|
|
func codeToken(i int64) string {
|
|
hash := md5.New()
|
|
unix := time.Now().UnixNano()
|
|
key := fmt.Sprintf("%v,%v,%v", unix, i, rand.Intn(100000000))
|
|
hash.Write([]byte(key))
|
|
sum := hash.Sum(nil)
|
|
code := hex.EncodeToString(sum)
|
|
return code[12:24]
|
|
}
|