654 lines
16 KiB
Go
654 lines
16 KiB
Go
package unicom
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"go-common/app/job/main/app-wall/model/unicom"
|
|
"go-common/library/cache/memcache"
|
|
"go-common/library/ecode"
|
|
"go-common/library/log"
|
|
"go-common/library/queue/databus/report"
|
|
)
|
|
|
|
const (
|
|
_initIPUnicomKey = "ipunicom_%v_%v"
|
|
)
|
|
|
|
func (s *Service) clickConsumer() {
|
|
defer s.waiter.Done()
|
|
msgs := s.clickSub.Messages()
|
|
for {
|
|
msg, ok := <-msgs
|
|
if !ok || s.closed {
|
|
log.Info("s.clickSub.Cloesd")
|
|
return
|
|
}
|
|
msg.Commit()
|
|
var (
|
|
sbs [][]byte
|
|
err error
|
|
)
|
|
if err = json.Unmarshal(msg.Value, &sbs); err != nil {
|
|
log.Error("json.Unmarshal(%v) error(%v)", msg.Value, err)
|
|
continue
|
|
}
|
|
for _, bs := range sbs {
|
|
var (
|
|
err error
|
|
click *unicom.ClickMsg
|
|
)
|
|
if click, err = s.checkMsgIllegal(bs); err != nil {
|
|
log.Error("s.checkMsgIllegal(%s) error(%v)", strings.Replace(string(bs), "\001", "|", -1), err)
|
|
continue
|
|
}
|
|
log.Info("clickConsumer s.checkMsgIllegal(%s)", strings.Replace(string(bs), "\001", "|", -1))
|
|
s.cliChan[click.AID%s.c.ChanNum] <- click
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Service) checkMsgIllegal(msg []byte) (click *unicom.ClickMsg, err error) {
|
|
var (
|
|
aid int64
|
|
clickMsg []string
|
|
plat int64
|
|
bvID string
|
|
mid int64
|
|
lv int64
|
|
ctime int64
|
|
stime int64
|
|
epid int64
|
|
ip string
|
|
seasonType int
|
|
userAgent string
|
|
)
|
|
clickMsg = strings.Split(string(msg), "\001")
|
|
if len(clickMsg) < 10 {
|
|
err = errors.New("click msg error")
|
|
return
|
|
}
|
|
if aid, err = strconv.ParseInt(clickMsg[1], 10, 64); err != nil {
|
|
err = fmt.Errorf("aid(%s) error", clickMsg[1])
|
|
return
|
|
}
|
|
if aid <= 0 {
|
|
err = fmt.Errorf("wocao aid(%s) error", clickMsg[1])
|
|
return
|
|
}
|
|
if plat, err = strconv.ParseInt(clickMsg[0], 10, 64); err != nil {
|
|
err = fmt.Errorf("plat(%s) error", clickMsg[0])
|
|
return
|
|
}
|
|
if plat != 3 && plat != 4 {
|
|
err = fmt.Errorf("plat(%d) is not android or ios", plat)
|
|
return
|
|
}
|
|
userAgent = clickMsg[10]
|
|
bvID = clickMsg[8]
|
|
if bvID == "" {
|
|
err = fmt.Errorf("bvID(%s) is illegal", clickMsg[8])
|
|
return
|
|
}
|
|
if clickMsg[4] != "" && clickMsg[4] != "0" {
|
|
if mid, err = strconv.ParseInt(clickMsg[4], 10, 64); err != nil {
|
|
err = fmt.Errorf("mid(%s) is illegal", clickMsg[4])
|
|
return
|
|
}
|
|
}
|
|
if clickMsg[5] != "" {
|
|
if lv, err = strconv.ParseInt(clickMsg[5], 10, 64); err != nil {
|
|
err = fmt.Errorf("lv(%s) is illegal", clickMsg[5])
|
|
return
|
|
}
|
|
}
|
|
if ctime, err = strconv.ParseInt(clickMsg[6], 10, 64); err != nil {
|
|
err = fmt.Errorf("ctime(%s) is illegal", clickMsg[6])
|
|
return
|
|
}
|
|
if stime, err = strconv.ParseInt(clickMsg[7], 10, 64); err != nil {
|
|
err = fmt.Errorf("stime(%s) is illegal", clickMsg[7])
|
|
return
|
|
}
|
|
if ip = clickMsg[9]; ip == "" {
|
|
err = errors.New("ip is illegal")
|
|
return
|
|
}
|
|
if clickMsg[17] != "" {
|
|
if epid, err = strconv.ParseInt(clickMsg[17], 10, 64); err != nil {
|
|
err = fmt.Errorf("epid(%s) is illegal", clickMsg[17])
|
|
return
|
|
}
|
|
if clickMsg[15] != "null" {
|
|
if seasonType, err = strconv.Atoi(clickMsg[15]); err != nil {
|
|
err = fmt.Errorf("seasonType(%s) is illegal", clickMsg[15])
|
|
return
|
|
}
|
|
}
|
|
}
|
|
click = &unicom.ClickMsg{
|
|
Plat: int8(plat),
|
|
AID: aid,
|
|
MID: mid,
|
|
Lv: int8(lv),
|
|
CTime: ctime,
|
|
STime: stime,
|
|
BvID: bvID,
|
|
IP: ip,
|
|
KafkaBs: msg,
|
|
EpID: epid,
|
|
SeasonType: seasonType,
|
|
UserAgent: userAgent,
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) cliChanProc(i int64) {
|
|
defer s.waiter.Done()
|
|
var (
|
|
cli *unicom.ClickMsg
|
|
cliChan = s.cliChan[i]
|
|
)
|
|
for {
|
|
var (
|
|
ub *unicom.UserBind
|
|
c = context.TODO()
|
|
err error
|
|
ok bool
|
|
count int
|
|
addFlow int
|
|
now = time.Now()
|
|
u *unicom.Unicom
|
|
cardType string
|
|
)
|
|
if cli, ok = <-cliChan; !ok || s.closed {
|
|
return
|
|
}
|
|
if count, err = s.dao.UserPackReceiveCache(c, cli.MID); err != nil {
|
|
log.Error("s.dao.UserBindCache error(%v) mid(%v) count(%v)", err, cli.MID, count)
|
|
continue
|
|
}
|
|
if count > 0 {
|
|
log.Info("s.dao.UserBindCache mid(%v) count(%v)", cli.MID, count)
|
|
continue
|
|
}
|
|
if ub, err = s.dao.UserBindCache(c, cli.MID); err != nil {
|
|
continue
|
|
}
|
|
if ub == nil || ub.Phone == 0 {
|
|
continue
|
|
}
|
|
res := s.unicomInfo(c, ub.Usermob, now)
|
|
if u, ok = res[ub.Usermob]; !ok || u == nil {
|
|
continue
|
|
}
|
|
switch u.Spid {
|
|
case 10019:
|
|
cardType = "22卡"
|
|
case 10020:
|
|
cardType = "33卡"
|
|
case 10021:
|
|
cardType = "小电视卡"
|
|
default:
|
|
log.Info("unicom spid equal 979 (%v)", ub)
|
|
continue
|
|
}
|
|
ub.Integral = ub.Integral + 10
|
|
switch cli.Lv {
|
|
case 0, 1, 2, 3:
|
|
addFlow = 10
|
|
case 4:
|
|
addFlow = 15
|
|
case 5:
|
|
addFlow = 20
|
|
case 6:
|
|
addFlow = 30
|
|
}
|
|
ub.Flow = ub.Flow + addFlow
|
|
if err = s.dao.AddUserBindCache(c, ub.Mid, ub); err != nil {
|
|
log.Error("s.dao.AddUserBindCache error(%v)", err)
|
|
continue
|
|
}
|
|
if err = s.dao.AddUserPackReceiveCache(c, ub.Mid, 1, now); err != nil {
|
|
log.Error("s.dao.AddUserPackReceiveCache error(%v)", err)
|
|
continue
|
|
}
|
|
s.dbcliChan[ub.Mid%s.c.ChanDBNum] <- ub
|
|
log.Info("unicom mobile cliChanProc userbind(%v)", ub)
|
|
s.unicomInfoc(ub.Usermob, ub.Phone, int(cli.Lv), 10, addFlow, cardType, ub.Mid, now)
|
|
s.addUserIntegralLog(&unicom.UserIntegralLog{Phone: ub.Phone, Mid: ub.Mid, UnicomDesc: cardType, Type: 0, Integral: 10, Flow: addFlow, Desc: "每日礼包"})
|
|
}
|
|
}
|
|
|
|
func (s *Service) dbcliChanProc(i int64) {
|
|
defer s.waiter.Done()
|
|
var (
|
|
ub *unicom.UserBind
|
|
dbcliChan = s.dbcliChan[i]
|
|
)
|
|
for {
|
|
var (
|
|
c = context.TODO()
|
|
ok bool
|
|
row int64
|
|
err error
|
|
)
|
|
if ub, ok = <-dbcliChan; !ok || s.closed {
|
|
return
|
|
}
|
|
if row, err = s.dao.UpUserIntegral(c, ub); err != nil || row == 0 {
|
|
log.Error("s.dao.UpUserIntegral ub(%v) error(%v) or result==0", ub, err)
|
|
continue
|
|
}
|
|
log.Info("unicom mobile dbcliChanProc userbind(%v)", ub)
|
|
}
|
|
}
|
|
|
|
// unicomInfo
|
|
func (s *Service) unicomInfo(c context.Context, usermob string, now time.Time) (res map[string]*unicom.Unicom) {
|
|
var (
|
|
err error
|
|
u []*unicom.Unicom
|
|
)
|
|
res = map[string]*unicom.Unicom{}
|
|
if u, err = s.dao.UnicomCache(c, usermob); err == nil && len(u) > 0 {
|
|
s.pHit.Incr("unicoms_cache")
|
|
} else {
|
|
if u, err = s.dao.OrdersUserFlow(context.TODO(), usermob); err != nil {
|
|
log.Error("unicom_s.dao.OrdersUserFlow error(%v)", err)
|
|
return
|
|
}
|
|
s.pMiss.Incr("unicoms_cache")
|
|
}
|
|
if len(u) > 0 {
|
|
row := &unicom.Unicom{}
|
|
for _, user := range u {
|
|
if user.TypeInt == 1 && now.Unix() <= int64(user.Endtime) {
|
|
*row = *user
|
|
break
|
|
} else if user.TypeInt == 0 {
|
|
if user.Spid == 979 {
|
|
continue
|
|
}
|
|
if int64(row.Ordertime) > int64(user.Ordertime) {
|
|
continue
|
|
}
|
|
*row = *user
|
|
}
|
|
}
|
|
if row.Spid == 0 {
|
|
return
|
|
}
|
|
res[usermob] = row
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) upBindAll() {
|
|
var (
|
|
orders []*unicom.UserBind
|
|
err error
|
|
start = 0
|
|
end = 1000
|
|
)
|
|
for {
|
|
var tmp []*unicom.UserBind
|
|
if tmp, err = s.dao.BindAll(context.TODO(), start, end); err != nil {
|
|
log.Error("s.dao.BindAll error(%v)", err)
|
|
return
|
|
}
|
|
start = end + start
|
|
if len(tmp) == 0 {
|
|
break
|
|
}
|
|
orders = append(orders, tmp...)
|
|
}
|
|
for _, b := range orders {
|
|
var (
|
|
c = context.TODO()
|
|
u *unicom.Unicom
|
|
ok bool
|
|
now = time.Now()
|
|
integral int
|
|
ub *unicom.UserBind
|
|
err error
|
|
cardType string
|
|
)
|
|
if now.Month() == b.Monthly.Month() && now.Year() == b.Monthly.Year() {
|
|
continue
|
|
}
|
|
res := s.unicomInfo(c, b.Usermob, now)
|
|
if u, ok = res[b.Usermob]; !ok || u == nil {
|
|
continue
|
|
}
|
|
switch u.Spid {
|
|
case 10019:
|
|
integral = 220
|
|
cardType = "22卡"
|
|
case 10020:
|
|
integral = 330
|
|
cardType = "33卡"
|
|
case 10021:
|
|
integral = 660
|
|
cardType = "小电视卡"
|
|
default:
|
|
continue
|
|
}
|
|
if ub, err = s.dao.UserBindCache(c, b.Mid); err != nil {
|
|
continue
|
|
}
|
|
if ub == nil || ub.Phone == 0 {
|
|
continue
|
|
}
|
|
ub.Integral = ub.Integral + integral
|
|
ub.Monthly = now
|
|
if err = s.dao.AddUserBindCache(c, ub.Mid, ub); err != nil {
|
|
log.Error("s.dao.AddUserBindCache error(%v)", err)
|
|
continue
|
|
}
|
|
s.dbcliChan[ub.Mid%s.c.ChanDBNum] <- ub
|
|
log.Info("unicom mobile upBindAll userbind(%v)", ub)
|
|
s.unicomInfoc(ub.Usermob, ub.Phone, 0, integral, 0, cardType, ub.Mid, now)
|
|
s.addUserIntegralLog(&unicom.UserIntegralLog{Phone: ub.Phone, Mid: ub.Mid, UnicomDesc: cardType, Type: 1, Integral: integral, Flow: 0, Desc: "每月礼包"})
|
|
}
|
|
}
|
|
|
|
func (s *Service) updatemonth(now time.Time) {
|
|
m := int(now.Month())
|
|
if lmonth, ok := s.lastmonth[m]; !ok || !lmonth {
|
|
if now.Day() == 1 {
|
|
s.upBindAll()
|
|
s.lastmonth[m] = true
|
|
if m = m + 1; m > 12 {
|
|
m = 1
|
|
}
|
|
s.lastmonth[m] = false
|
|
log.Info("updatepro user monthly integral success")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Service) loadUnicomFlow() {
|
|
var (
|
|
list map[string]*unicom.UnicomUserFlow
|
|
err error
|
|
)
|
|
if list, err = s.dao.UserFlowListCache(context.TODO()); err != nil {
|
|
log.Error("load unicom s.dao.UserFlowListCache error(%v)", err)
|
|
return
|
|
}
|
|
log.Info("load unicom flow total len(%v)", len(list))
|
|
for key, u := range list {
|
|
var (
|
|
c = context.TODO()
|
|
requestNo int64
|
|
orderstatus string
|
|
msg string
|
|
)
|
|
if err = s.dao.UserFlowCache(c, key); err != nil {
|
|
if err == memcache.ErrNotFound {
|
|
if err = s.returnPoints(c, u); err != nil {
|
|
if err != ecode.NothingFound {
|
|
log.Error("load unicom s.returnPoints error(%v)", err)
|
|
continue
|
|
}
|
|
err = nil
|
|
}
|
|
log.Info("load unicom userbind timeout flow(%v)", u)
|
|
} else {
|
|
log.Error("load unicom s.dao.UserFlowCache error(%v)", err)
|
|
continue
|
|
}
|
|
} else {
|
|
if requestNo, err = s.seqdao.SeqID(c); err != nil {
|
|
log.Error("load unicom s.seqdao.SeqID error(%v)", err)
|
|
continue
|
|
}
|
|
if orderstatus, msg, err = s.dao.FlowQry(c, u.Phone, requestNo, u.Outorderid, u.Orderid, time.Now()); err != nil {
|
|
log.Error("load unicom s.dao.FlowQry error(%v) msg(%s)", err, msg)
|
|
continue
|
|
}
|
|
log.Info("load unicom userbind flow(%v) orderstatus(%s)", u, orderstatus)
|
|
if orderstatus == "00" {
|
|
continue
|
|
} else if orderstatus != "01" {
|
|
if err = s.returnPoints(c, u); err != nil {
|
|
if err != ecode.NothingFound {
|
|
log.Error("load unicom s.returnPoints error(%v)", err)
|
|
continue
|
|
}
|
|
err = nil
|
|
}
|
|
}
|
|
}
|
|
delete(list, key)
|
|
if err = s.dao.DeleteUserFlowCache(c, key); err != nil {
|
|
log.Error("load unicom s.dao.DeleteUserFlowCache error(%v)", err)
|
|
continue
|
|
}
|
|
}
|
|
if err = s.dao.AddUserFlowListCache(context.TODO(), list); err != nil {
|
|
log.Error("load unicom s.dao.AddUserFlowListCache error(%v)", err)
|
|
return
|
|
}
|
|
log.Info("load unicom flow last len(%v) success", len(list))
|
|
}
|
|
|
|
// returnPoints retutn user integral and flow
|
|
func (s *Service) returnPoints(c context.Context, u *unicom.UnicomUserFlow) (err error) {
|
|
var (
|
|
userbind *unicom.UserBind
|
|
result int64
|
|
)
|
|
if userbind, err = s.unicomBindInfo(c, u.Mid); err != nil {
|
|
return
|
|
}
|
|
ub := &unicom.UserBind{}
|
|
*ub = *userbind
|
|
ub.Flow = ub.Flow + u.Flow
|
|
ub.Integral = ub.Integral + u.Integral
|
|
if err = s.dao.AddUserBindCache(c, ub.Mid, ub); err != nil {
|
|
log.Error("unicom s.dao.AddUserBindCache error(%v)", err)
|
|
return
|
|
}
|
|
if result, err = s.dao.UpUserIntegral(c, ub); err != nil || result == 0 {
|
|
log.Error("unicom s.dao.UpUserIntegral error(%v) or result==0", err)
|
|
return
|
|
}
|
|
var packInt int
|
|
if u.Integral > 0 {
|
|
packInt = u.Integral
|
|
} else {
|
|
packInt = u.Flow
|
|
}
|
|
ul := &unicom.UserPackLog{
|
|
Phone: u.Phone,
|
|
Usermob: ub.Usermob,
|
|
Mid: u.Mid,
|
|
RequestNo: u.Outorderid,
|
|
Type: 0,
|
|
Desc: u.Desc + ",领取失败并返还",
|
|
Integral: packInt,
|
|
}
|
|
s.addUserPackLog(ul)
|
|
s.addUserIntegralLog(&unicom.UserIntegralLog{Phone: u.Phone, Mid: u.Mid, UnicomDesc: "", Type: 2, Integral: u.Integral, Flow: u.Flow, Desc: u.Desc + ",领取失败并返还"})
|
|
log.Info("unicom_pack(%v) mid(%v)", u.Desc+",领取失败并返还", userbind.Mid)
|
|
s.unicomPackInfoc(userbind.Usermob, u.Desc+",领取失败并返还", u.Orderid, userbind.Phone, packInt, 0, userbind.Mid, time.Now())
|
|
return
|
|
}
|
|
|
|
// unicomBindInfo unicom bind info
|
|
func (s *Service) unicomBindInfo(c context.Context, mid int64) (res *unicom.UserBind, err error) {
|
|
if res, err = s.dao.UserBindCache(c, mid); err != nil {
|
|
if res, err = s.dao.UserBind(c, mid); err != nil {
|
|
log.Error("s.dao.UserBind error(%v)", err)
|
|
return
|
|
}
|
|
if res == nil {
|
|
err = ecode.NothingFound
|
|
return
|
|
}
|
|
if err = s.dao.AddUserBindCache(c, mid, res); err != nil {
|
|
log.Error("s.dao.AddUserBindCache mid(%d) error(%v)", mid, err)
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// loadUnicomIPOrder load unciom ip order update
|
|
func (s *Service) loadUnicomIPOrder(now time.Time) {
|
|
var (
|
|
dbips map[string]*unicom.UnicomIP
|
|
err error
|
|
)
|
|
if dbips, err = s.loadUnicomIP(context.TODO()); err != nil {
|
|
log.Error("s.loadUnicomIP", err)
|
|
return
|
|
}
|
|
if len(dbips) == 0 {
|
|
log.Error("db cache ip len 0")
|
|
return
|
|
}
|
|
unicomIP, err := s.dao.UnicomIP(context.TODO(), now)
|
|
if err != nil {
|
|
log.Error("s.dao.UnicomIP(%v)", err)
|
|
return
|
|
}
|
|
if len(unicomIP) == 0 {
|
|
log.Info("unicom ip orders is null")
|
|
return
|
|
}
|
|
tx, err := s.dao.BeginTran(context.TODO())
|
|
if err != nil {
|
|
log.Error("s.dao.BeginTran error(%v)", err)
|
|
return
|
|
}
|
|
for _, uip := range unicomIP {
|
|
key := fmt.Sprintf(_initIPUnicomKey, uip.Ipbegin, uip.Ipend)
|
|
if _, ok := dbips[key]; ok {
|
|
delete(dbips, key)
|
|
continue
|
|
}
|
|
var (
|
|
result int64
|
|
)
|
|
if result, err = s.dao.InUnicomIPSync(tx, uip, time.Now()); err != nil || result == 0 {
|
|
tx.Rollback()
|
|
log.Error("s.dao.InUnicomIPSync error(%v)", err)
|
|
return
|
|
}
|
|
}
|
|
for _, uold := range dbips {
|
|
var (
|
|
result int64
|
|
)
|
|
if result, err = s.dao.UpUnicomIP(tx, uold.Ipbegin, uold.Ipend, 0, time.Now()); err != nil || result == 0 {
|
|
tx.Rollback()
|
|
log.Error("s.dao.UpUnicomIP error(%v)", err)
|
|
return
|
|
}
|
|
}
|
|
if err = tx.Commit(); err != nil {
|
|
log.Error("tx.Commit error(%v)", err)
|
|
return
|
|
}
|
|
log.Info("update unicom ip success")
|
|
}
|
|
|
|
// loadUnicomIP load unicom ip
|
|
func (s *Service) loadUnicomIP(c context.Context) (res map[string]*unicom.UnicomIP, err error) {
|
|
var unicomIP []*unicom.UnicomIP
|
|
unicomIP, err = s.dao.IPSync(c)
|
|
if err != nil {
|
|
log.Error("s.dao.IPSync error(%v)", err)
|
|
return
|
|
}
|
|
tmp := map[string]*unicom.UnicomIP{}
|
|
for _, u := range unicomIP {
|
|
key := fmt.Sprintf(_initIPUnicomKey, u.Ipbegin, u.Ipend)
|
|
tmp[key] = u
|
|
}
|
|
res = tmp
|
|
log.Info("loadUnicomIPCache success")
|
|
return
|
|
}
|
|
|
|
func (s *Service) addUserPackLog(u *unicom.UserPackLog) {
|
|
select {
|
|
case s.packLogCh <- u:
|
|
default:
|
|
log.Warn("user pack log buffer is full")
|
|
}
|
|
}
|
|
|
|
func (s *Service) addUserIntegralLog(u *unicom.UserIntegralLog) {
|
|
select {
|
|
case s.integralLogCh[u.Mid%s.c.ChanDBNum] <- u:
|
|
default:
|
|
log.Warn("user add integral and flow log buffer is full")
|
|
}
|
|
}
|
|
|
|
func (s *Service) addUserPackLogproc() {
|
|
for {
|
|
i, ok := <-s.packLogCh
|
|
if !ok || s.closed {
|
|
log.Warn("user pack log proc exit")
|
|
return
|
|
}
|
|
var (
|
|
c = context.TODO()
|
|
result int64
|
|
err error
|
|
)
|
|
switch v := i.(type) {
|
|
case *unicom.UserPackLog:
|
|
if result, err = s.dao.InUserPackLog(c, v); err != nil || result == 0 {
|
|
log.Error("s.dao.UpUserIntegral error(%v) or result==0", err)
|
|
continue
|
|
}
|
|
log.Info("unicom user flow or integral back mid(%d) phone(%d)", v.Mid, v.Phone)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Service) addUserIntegralLogproc(i int64) {
|
|
var (
|
|
dbcliChan = s.integralLogCh[i]
|
|
)
|
|
for {
|
|
i, ok := <-dbcliChan
|
|
if !ok || s.closed {
|
|
log.Warn("user pack log proc exit")
|
|
return
|
|
}
|
|
var (
|
|
logID = 91
|
|
)
|
|
switch v := i.(type) {
|
|
case *unicom.UserIntegralLog:
|
|
// if result, err = s.dao.InUserIntegralLog(c, v); err != nil || result == 0 {
|
|
// log.Error("s.dao.InUserIntegralLog error(%v) or result==0", err)
|
|
// continue
|
|
// }
|
|
report.User(&report.UserInfo{
|
|
Mid: v.Mid,
|
|
Business: logID,
|
|
Action: "unicom_userpack_add",
|
|
Ctime: time.Now(),
|
|
Content: map[string]interface{}{
|
|
"phone": v.Phone,
|
|
"pack_desc": v.Desc,
|
|
"integral": v.Integral,
|
|
},
|
|
})
|
|
}
|
|
}
|
|
}
|