Create & Init Project...

app/interface/main/app-wall/service/unicom/BUILD

@@ -0,0 +1,66 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["unicom_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cache.go",
+        "databus.go",
+        "infoc.go",
+        "pack.go",
+        "service.go",
+        "unicom.go",
+    ],
+    importpath = "go-common/app/interface/main/app-wall/service/unicom",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/interface/main/app-wall/dao/account:go_default_library",
+        "//app/interface/main/app-wall/dao/live:go_default_library",
+        "//app/interface/main/app-wall/dao/seq:go_default_library",
+        "//app/interface/main/app-wall/dao/shopping:go_default_library",
+        "//app/interface/main/app-wall/dao/unicom:go_default_library",
+        "//app/interface/main/app-wall/model:go_default_library",
+        "//app/interface/main/app-wall/model/unicom:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/log/infoc:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/queue/databus/report:go_default_library",
+        "//library/stat/prom: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/app-wall/service/unicom/cache.go

@@ -0,0 +1,203 @@
+package unicom
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/app/interface/main/app-wall/model/unicom"
+	"go-common/library/cache/memcache"
+	"go-common/library/ecode"
+	log "go-common/library/log"
+)
+
+const (
+	_initIPUnicomKey = "ipunicom_%v_%v"
+)
+
+// loadUnicomIP load unicom ip
+func (s *Service) loadUnicomIP() {
+	unicomIP, err := s.dao.IPSync(context.TODO())
+	if err != nil {
+		log.Error("s.dao.IPSync error(%v)", err)
+		return
+	}
+	s.unicomIpCache = unicomIP
+	tmp := map[string]*unicom.UnicomIP{}
+	for _, u := range s.unicomIpCache {
+		key := fmt.Sprintf(_initIPUnicomKey, u.Ipbegin, u.Ipend)
+		tmp[key] = u
+	}
+	s.unicomIpSQLCache = tmp
+	log.Info("loadUnicomIPCache success")
+}
+
+// loadIPlimit ip limit
+func (s *Service) loadIPlimit(c *conf.Config) {
+	hosts := make(map[string]struct{}, len(c.IPLimit.Addrs))
+	for k, v := range c.IPLimit.Addrs {
+		for _, ipStr := range v {
+			key := fmt.Sprintf(_initIPlimitKey, k, ipStr)
+			if _, ok := hosts[key]; !ok {
+				hosts[key] = struct{}{}
+			}
+		}
+	}
+	s.operationIPlimit = hosts
+	log.Info("load operationIPlimit success")
+}
+
+// loadUnicomIPOrder load unciom ip order update
+func (s *Service) loadUnicomIPOrder(now time.Time) {
+	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 := s.unicomIpSQLCache[key]; ok {
+			delete(s.unicomIpSQLCache, 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 s.unicomIpSQLCache {
+		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")
+}
+
+func (s *Service) loadUnicomPacks() {
+	pack, err := s.dao.UserPacks(context.TODO())
+	if err != nil {
+		log.Error("s.dao.UserPacks error(%v)", err)
+		return
+	}
+	s.unicomPackCache = pack
+}
+
+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
+	}
+	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 success")
+}
+
+// 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
+	}
+	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
+}

app/interface/main/app-wall/service/unicom/databus.go

@@ -0,0 +1,38 @@
+package unicom
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/app-wall/model/unicom"
+	log "go-common/library/log"
+)
+
+func (s *Service) addUserBindState(u *unicom.UserBindInfo) {
+	select {
+	case s.userBindCh <- u:
+	default:
+		log.Warn("add user bind state buffer is full")
+	}
+}
+
+func (s *Service) userbindConsumer() {
+	defer s.waiter.Done()
+	for {
+		i, ok := <-s.userBindCh
+		if !ok {
+			return
+		}
+		var (
+			err error
+		)
+		switch v := i.(type) {
+		case *unicom.UserBindInfo:
+			if err = s.userbindPub.Send(context.TODO(), strconv.FormatInt(v.MID, 10), v); err != nil {
+				log.Error("s.userbindSub.Send error(%v)", err)
+				continue
+			}
+			log.Info("s.userbindSub.Send(%+v) success", v)
+		}
+	}
+}

app/interface/main/app-wall/service/unicom/infoc.go

@@ -0,0 +1,104 @@
+package unicom
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	log "go-common/library/log"
+	binfoc "go-common/library/log/infoc"
+)
+
+type orderInfoc struct {
+	usermob   string
+	orderType string
+	ip        string
+	mobiApp   string
+	build     string
+	now       string
+}
+
+type ipInfoc struct {
+	usermob  string
+	isValide string
+	ip       string
+	mobiApp  string
+	build    string
+	now      string
+}
+
+type packInfoc struct {
+	usermob      string
+	phone        string
+	mid          string
+	requestNo    string
+	packName     string
+	packIntegral string
+	packType     string
+	now          string
+}
+
+// Infoc write data for Hadoop do analytics
+func (s *Service) unicomInfoc(mobiApp, usermob, ip string, build, orderType int, now time.Time) {
+	select {
+	case s.logCh <- orderInfoc{usermob, strconv.Itoa(orderType), ip, mobiApp, strconv.Itoa(build), strconv.FormatInt(now.Unix(), 10)}:
+	default:
+		log.Warn("unicomInfoc log buffer is full")
+	}
+}
+
+// Infoc write data for Hadoop do analytics
+func (s *Service) ipInfoc(mobiApp, usermob, ip string, build int, isValide bool, now time.Time) {
+	select {
+	case s.logCh <- ipInfoc{usermob, strconv.FormatBool(isValide), ip, mobiApp, strconv.Itoa(build), strconv.FormatInt(now.Unix(), 10)}:
+	default:
+		log.Warn("ipInfoc log buffer is full")
+	}
+}
+
+func (s *Service) unicomInfocproc() {
+	var (
+		unicominf2 = binfoc.New(conf.Conf.UnicomUserInfoc2)
+		ipinf2     = binfoc.New(conf.Conf.UnicomIpInfoc2)
+	)
+	for {
+		i, ok := <-s.logCh
+		if !ok {
+			log.Warn("infoc proc exit")
+			return
+		}
+		switch v := i.(type) {
+		case orderInfoc:
+			unicominf2.Info(v.now, "0", v.usermob, v.orderType, v.ip, v.mobiApp, v.build)
+		case ipInfoc:
+			ipinf2.Info(v.now, "0", v.isValide, v.ip, v.usermob, v.mobiApp, v.build)
+		}
+	}
+}
+
+// unicomPackInfoc unicom pack infoc
+func (s *Service) unicomPackInfoc(usermob, packName, orderNumber string, phone, packIntegral, packType int, mid int64, now time.Time) {
+	select {
+	case s.packCh <- packInfoc{usermob, strconv.Itoa(phone), strconv.FormatInt(mid, 10),
+		orderNumber, packName, strconv.Itoa(packIntegral), strconv.Itoa(packType), strconv.FormatInt(now.Unix(), 10)}:
+	default:
+		log.Warn("unicomPackInfoc log buffer is full")
+	}
+}
+
+func (s *Service) unicomPackInfocproc() {
+	var (
+		packinf = binfoc.New(conf.Conf.UnicomPackInfoc)
+	)
+	for {
+		i, ok := <-s.packCh
+		if !ok {
+			log.Warn("infoc proc exit")
+			return
+		}
+		switch v := i.(type) {
+		case packInfoc:
+			packinf.Info(v.now, "0", v.usermob, v.phone, v.mid, v.requestNo, v.packName, v.packIntegral, v.packType)
+		}
+	}
+}

app/interface/main/app-wall/service/unicom/pack.go

@@ -0,0 +1,69 @@
+package unicom
+
+import (
+	"context"
+	"time"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// PrivilegePack
+func (s *Service) Pack(c context.Context, usermob string, mid int64, now time.Time) (msg string, err error) {
+	row := s.unicomInfo(c, usermob, now)
+	u, ok := row[usermob]
+	if !ok || u == nil {
+		err = ecode.NothingFound
+		msg = "该卡号尚未开通哔哩哔哩专属免流服务"
+		return
+	}
+	var (
+		result int64
+	)
+	userpacke, err := s.userPack(c, usermob)
+	if err != nil {
+		log.Error("s.userPack error(%v)", err)
+		msg = "特权礼包领取失败"
+		return
+	}
+	var (
+		unicomPackOk bool
+		userPackOk   bool
+		user         map[int64]struct{}
+	)
+	if user, unicomPackOk = userpacke[usermob]; unicomPackOk {
+		_, userPackOk = user[mid]
+	}
+	if !unicomPackOk && !userPackOk {
+		result, err = s.dao.InPack(c, usermob, mid)
+		if err != nil {
+			log.Error("s.pack.InPack(%s, %s) error(%v)", usermob, mid, err)
+		} else if result == 0 {
+			err = ecode.RequestErr
+			msg = "每张卡只能领取一次特权礼包哦"
+			log.Error("s.pack.InPackc(%s,%s) error(%v) result==0", usermob, mid, err)
+		} else {
+			if err = s.live.Pack(c, mid, u.CardType); err != nil {
+				msg = "礼包领取失败"
+				log.Error("s.live.Pack mid error(%v)", mid, err)
+			}
+		}
+	} else if unicomPackOk {
+		err = ecode.NotModified
+		msg = "每张卡只能领取一次特权礼包哦"
+	} else if userPackOk {
+		err = ecode.NotModified
+		msg = "每个账号只能领取一次哦"
+	} else {
+		msg = "领取成功，特权礼包将在1~3个⼯工作⽇日内发放到您的账号"
+	}
+	return
+}
+
+func (s *Service) userPack(c context.Context, usermob string) (pack map[string]map[int64]struct{}, err error) {
+	if pack, err = s.dao.Pack(c, usermob); err != nil {
+		log.Error("s.pack.Pack usermob:%v error(%v)", usermob, err)
+		return
+	}
+	return
+}

app/interface/main/app-wall/service/unicom/service.go

@@ -0,0 +1,97 @@
+package unicom
+
+import (
+	"sync"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	accdao "go-common/app/interface/main/app-wall/dao/account"
+	liveDao "go-common/app/interface/main/app-wall/dao/live"
+	seqDao "go-common/app/interface/main/app-wall/dao/seq"
+	shopDao "go-common/app/interface/main/app-wall/dao/shopping"
+	unicomDao "go-common/app/interface/main/app-wall/dao/unicom"
+	"go-common/app/interface/main/app-wall/model/unicom"
+	"go-common/library/queue/databus"
+	"go-common/library/stat/prom"
+)
+
+const (
+	_initIPlimitKey = "iplimit_%v_%v"
+)
+
+type Service struct {
+	c                *conf.Config
+	dao              *unicomDao.Dao
+	live             *liveDao.Dao
+	seqdao           *seqDao.Dao
+	accd             *accdao.Dao
+	shop             *shopDao.Dao
+	tick             time.Duration
+	unicomIpCache    []*unicom.UnicomIP
+	unicomIpSQLCache map[string]*unicom.UnicomIP
+	operationIPlimit map[string]struct{}
+	unicomPackCache  []*unicom.UserPack
+	// infoc
+	logCh      chan interface{}
+	packCh     chan interface{}
+	packLogCh  chan interface{}
+	userBindCh chan interface{}
+	// waiter
+	waiter sync.WaitGroup
+	// databus
+	userbindPub *databus.Databus
+	// prom
+	pHit  *prom.Prom
+	pMiss *prom.Prom
+}
+
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:                c,
+		dao:              unicomDao.New(c),
+		live:             liveDao.New(c),
+		seqdao:           seqDao.New(c),
+		accd:             accdao.New(c),
+		shop:             shopDao.New(c),
+		tick:             time.Duration(c.Tick),
+		unicomIpCache:    []*unicom.UnicomIP{},
+		unicomIpSQLCache: map[string]*unicom.UnicomIP{},
+		operationIPlimit: map[string]struct{}{},
+		unicomPackCache:  []*unicom.UserPack{},
+		// databus
+		userbindPub: databus.New(c.UnicomDatabus),
+		// infoc
+		logCh:      make(chan interface{}, 1024),
+		packCh:     make(chan interface{}, 1024),
+		packLogCh:  make(chan interface{}, 1024),
+		userBindCh: make(chan interface{}, 1024),
+		// prom
+		pHit:  prom.CacheHit,
+		pMiss: prom.CacheMiss,
+	}
+	// now := time.Now()
+	s.loadIPlimit(c)
+	s.loadUnicomIP()
+	// s.loadUnicomIPOrder(now)
+	s.loadUnicomPacks()
+	// s.loadUnicomFlow()
+	go s.loadproc()
+	go s.unicomInfocproc()
+	go s.unicomPackInfocproc()
+	go s.addUserPackLogproc()
+	s.waiter.Add(1)
+	go s.userbindConsumer()
+	return
+}
+
+// cacheproc load cache
+func (s *Service) loadproc() {
+	for {
+		time.Sleep(s.tick)
+		// now := time.Now()
+		s.loadUnicomIP()
+		// s.loadUnicomIPOrder(now)
+		s.loadUnicomPacks()
+		// s.loadUnicomFlow()
+	}
+}

app/interface/main/app-wall/service/unicom/unicom.go

@@ -0,0 +1,961 @@
+package unicom
+
+import (
+	"bytes"
+	"context"
+	"crypto/des"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-wall/model"
+	"go-common/app/interface/main/app-wall/model/unicom"
+	account "go-common/app/service/main/account/model"
+	"go-common/library/ecode"
+	log "go-common/library/log"
+	"go-common/library/queue/databus/report"
+)
+
+const (
+	_unicomKey     = "unicom"
+	_unicomPackKey = "unicom_pack"
+)
+
+// InOrdersSync insert OrdersSync
+func (s *Service) InOrdersSync(c context.Context, usermob, ip string, u *unicom.UnicomJson, now time.Time) (err error) {
+	if !s.iplimit(_unicomKey, ip) {
+		err = ecode.AccessDenied
+		return
+	}
+	var result int64
+	if result, err = s.dao.InOrdersSync(c, usermob, u, now); err != nil || result == 0 {
+		log.Error("unicom_s.dao.OrdersSync (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%v) error(%v) or result==0",
+			usermob, u.Cpid, u.Spid, u.TypeInt, u.Ordertypes, u.Channelcode, u.Ordertime, u.Canceltime, u.Endtime, u.Province, u.Area, u.Videoid, err)
+	}
+	return
+}
+
+// InAdvanceSync insert AdvanceSync
+func (s *Service) InAdvanceSync(c context.Context, usermob, ip string, u *unicom.UnicomJson, now time.Time) (err error) {
+	if !s.iplimit(_unicomKey, ip) {
+		err = ecode.AccessDenied
+		return
+	}
+	var result int64
+	if result, err = s.dao.InAdvanceSync(c, usermob, u, now); err != nil || result == 0 {
+		log.Error("unicom_s.dao.InAdvanceSync (%s,%s,%s,%s,%s,%s,%s,%s,%v) error(%v) or result==0",
+			usermob, u.Userphone, u.Cpid, u.Spid, u.Ordertypes, u.Channelcode, u.Province, u.Area, err)
+	}
+	return
+}
+
+// FlowSync update OrdersSync
+func (s *Service) FlowSync(c context.Context, flowbyte int, usermob, time, ip string, now time.Time) (err error) {
+	if !s.iplimit(_unicomKey, ip) {
+		err = ecode.AccessDenied
+		return
+	}
+	var result int64
+	if result, err = s.dao.FlowSync(c, flowbyte, usermob, time, now); err != nil || result == 0 {
+		log.Error("unicom_s.dao.OrdersSync(%s, %s, %s) error(%v) or result==0", usermob, time, flowbyte, err)
+	}
+	return
+}
+
+// InIPSync
+func (s *Service) InIPSync(c context.Context, ip string, u *unicom.UnicomIpJson, now time.Time) (err error) {
+	if !s.iplimit(_unicomKey, ip) {
+		err = ecode.AccessDenied
+		return
+	}
+	var result int64
+	if result, err = s.dao.InIPSync(c, u, now); err != nil {
+		log.Error("s.dao.InIpSync(%s,%s) error(%v)", u.Ipbegin, u.Ipend, err)
+	} else if result == 0 {
+		err = ecode.RequestErr
+		log.Error("unicom_s.dao.InIpSync(%s,%s) error(%v) result==0", u.Ipbegin, u.Ipend, err)
+	}
+	return
+}
+
+// UserFlow
+func (s *Service) UserFlow(c context.Context, usermob, mobiApp, ip string, build int, now time.Time) (res *unicom.Unicom, msg string, err error) {
+	var (
+		row       map[string]*unicom.Unicom
+		orderType int
+	)
+	row = s.unicomInfo(c, usermob, now)
+	res, msg, err = s.uState(row, usermob, now)
+	switch err {
+	case ecode.NothingFound:
+		orderType = 1
+	case ecode.NotModified:
+		orderType = 3
+	default:
+		orderType = 2
+	}
+	s.unicomInfoc(mobiApp, usermob, ip, build, orderType, now)
+	return
+}
+
+// unicomInfo
+func (s *Service) unicomInfo(c context.Context, usermob string, now time.Time) (res map[string]*unicom.Unicom) {
+	var (
+		err error
+		us  []*unicom.Unicom
+	)
+	res = map[string]*unicom.Unicom{}
+	if us, err = s.dao.UnicomCache(c, usermob); err == nil && len(us) > 0 {
+		s.pHit.Incr("unicoms_cache")
+	} else {
+		if us, 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(us) > 0 {
+			if err = s.dao.AddUnicomCache(c, usermob, us); err != nil {
+				log.Error("s.dao.AddUnicomCache usermob(%v) error(%v)", usermob, err)
+				return
+			}
+		}
+	}
+	if len(us) > 0 {
+		row := &unicom.Unicom{}
+		channel := &unicom.Unicom{}
+		for _, u := range us {
+			if u.TypeInt == 1 && now.Unix() <= int64(u.Endtime) {
+				*row = *u
+				continue
+			} else if u.TypeInt == 0 {
+				if int64(row.Ordertime) == 0 {
+					*row = *u
+				} else if int64(row.Ordertime) < int64(u.Ordertime) {
+					continue
+				}
+				*row = *u
+				continue
+			} else if u.TypeInt == 1 {
+				if int64(row.Ordertime) > int64(u.Ordertime) {
+					continue
+				}
+				*channel = *u
+			}
+		}
+		if row.Spid == 0 && channel.Spid == 0 {
+			return
+		} else if row.Spid == 0 && channel.Spid > 0 {
+			row = channel
+		}
+		res[usermob] = row
+	}
+	return
+}
+
+// UserState
+func (s *Service) UserState(c context.Context, usermob, mobiApp, ip string, build int, now time.Time) (res *unicom.Unicom, msg string, err error) {
+	var (
+		orderType int
+	)
+	row := s.unicomInfo(c, usermob, now)
+	res, msg, err = s.uState(row, usermob, now)
+	switch err {
+	case ecode.NothingFound:
+		orderType = 1
+	case ecode.NotModified:
+		orderType = 3
+	default:
+		orderType = 2
+	}
+	s.unicomInfoc(mobiApp, usermob, ip, build, orderType, now)
+	return
+}
+
+// UnicomState
+func (s *Service) UnicomState(c context.Context, usermob, mobiApp, ip string, build int, now time.Time) (res *unicom.Unicom, err error) {
+	var (
+		ok bool
+	)
+	row := s.unicomInfo(c, usermob, now)
+	if res, ok = row[usermob]; !ok {
+		res = &unicom.Unicom{Unicomtype: 1}
+	} else if res.TypeInt == 1 && now.Unix() > int64(res.Endtime) {
+		res.Unicomtype = 3
+	} else if res.TypeInt == 1 {
+		res.Unicomtype = 4
+	} else if res.TypeInt == 0 {
+		res.Unicomtype = 2
+	}
+	log.Info("unicomstate_type:%v unicomstate_type_usermob:%v", res.Unicomtype, usermob)
+	s.unicomInfoc(mobiApp, usermob, ip, build, res.Unicomtype, now)
+	return
+}
+
+// UserFlowState
+func (s *Service) UserFlowState(c context.Context, usermob string, now time.Time) (res *unicom.Unicom, err error) {
+	row := s.unicomInfo(c, usermob, now)
+	var ok bool
+	if res, ok = row[usermob]; !ok {
+		res = &unicom.Unicom{Unicomtype: 1}
+	} else if res.TypeInt == 1 {
+		res.Unicomtype = 3
+	} else if res.TypeInt == 0 {
+		res.Unicomtype = 2
+	}
+	return
+}
+
+// uState
+func (s *Service) uState(unicom map[string]*unicom.Unicom, usermob string, now time.Time) (res *unicom.Unicom, msg string, err error) {
+	var ok bool
+	if res, ok = unicom[usermob]; !ok {
+		err = ecode.NothingFound
+		msg = "该卡号尚未开通哔哩哔哩专属免流服务"
+	} else if res.TypeInt == 1 && now.Unix() > int64(res.Endtime) {
+		err = ecode.NotModified
+		msg = "该卡号哔哩哔哩专属免流服务已退订且已过期"
+	}
+	return
+}
+
+// IsUnciomIP is unicom ip
+func (s *Service) IsUnciomIP(ipUint uint32, ipStr, mobiApp string, build int, now time.Time) (err error) {
+	if !model.IsIPv4(ipStr) {
+		err = ecode.NothingFound
+		return
+	}
+	isValide := s.unciomIPState(ipUint)
+	s.ipInfoc(mobiApp, "", ipStr, build, isValide, now)
+	if isValide {
+		return
+	}
+	err = ecode.NothingFound
+	return
+}
+
+// UserUnciomIP
+func (s *Service) UserUnciomIP(ipUint uint32, ipStr, usermob, mobiApp string, build int, now time.Time) (res *unicom.UnicomUserIP) {
+	res = &unicom.UnicomUserIP{
+		IPStr:    ipStr,
+		IsValide: false,
+	}
+	if !model.IsIPv4(ipStr) {
+		return
+	}
+	if res.IsValide = s.unciomIPState(ipUint); !res.IsValide {
+		log.Error("unicom_user_ip:%v unicom_ip_usermob:%v", ipStr, usermob)
+	}
+	s.ipInfoc(mobiApp, usermob, ipStr, build, res.IsValide, now)
+	return
+}
+
+// Order unicom user order
+func (s *Service) Order(c context.Context, usermobDes, channel string, ordertype int, now time.Time) (res *unicom.BroadbandOrder, msg string, err error) {
+	var (
+		usermob string
+	)
+	var (
+		_aesKey = []byte("9ed226d9")
+	)
+	bs, err := base64.StdEncoding.DecodeString(usermobDes)
+	if err != nil {
+		log.Error("base64.StdEncoding.DecodeString(%s) error(%v)", usermobDes, err)
+		return
+	}
+	bs, err = s.DesDecrypt(bs, _aesKey)
+	if err != nil {
+		log.Error("unicomSvc.DesDecrypt error(%v)", err)
+		return
+	}
+	if len(bs) > 32 {
+		usermob = string(bs[:32])
+	} else {
+		usermob = string(bs)
+	}
+	row := s.unicomInfo(c, usermob, now)
+	if u, ok := row[usermob]; ok {
+		if u.Spid != 979 && u.Spid != 0 && u.TypeInt == 0 {
+			err = ecode.NotModified
+			msg = "您当前是流量卡并且已生效无法再订购流量包"
+			return
+		}
+	}
+	if res, msg, err = s.dao.Order(c, usermobDes, channel, ordertype); err != nil {
+		log.Error("s.dao.Order usermobDes(%v) error(%v)", usermobDes, err)
+		return
+	}
+	return
+}
+
+// CancelOrder unicom user cancel order
+func (s *Service) CancelOrder(c context.Context, usermob string) (res *unicom.BroadbandOrder, msg string, err error) {
+	if res, msg, err = s.dao.CancelOrder(c, usermob); err != nil {
+		log.Error("s.dao.CancelOrder usermob(%v) error(%v)", usermob, err)
+		return
+	}
+	return
+}
+
+// UnicomSMSCode unicom sms code
+func (s *Service) UnicomSMSCode(c context.Context, phone string, now time.Time) (msg string, err error) {
+	if msg, err = s.dao.SendSmsCode(c, phone); err != nil {
+		log.Error("s.dao.SendSmsCode phone(%v) error(%v)", phone, err)
+		return
+	}
+	return
+}
+
+// AddUnicomBind unicom user bind
+func (s *Service) AddUnicomBind(c context.Context, phone string, code int, mid int64, now time.Time) (msg string, err error) {
+	var (
+		usermobDes string
+		usermob    string
+		ub         *unicom.UserBind
+		result     int64
+		res        *unicom.Unicom
+	)
+	if usermobDes, msg, err = s.dao.SmsNumber(c, phone, code); err != nil {
+		log.Error("s.dao.SmsNumber error(%v)", err)
+		return
+	}
+	if usermobDes == "" {
+		err = ecode.NotModified
+		msg = "激活失败，请重新输入验证码激活"
+		return
+	}
+	var (
+		_aesKey = []byte("9ed226d9")
+	)
+	bs, err := base64.StdEncoding.DecodeString(usermobDes)
+	if err != nil {
+		log.Error("base64.StdEncoding.DecodeString(%s) error(%v)", usermobDes, err)
+		return
+	}
+	bs, err = s.DesDecrypt(bs, _aesKey)
+	if err != nil {
+		log.Error("unicomSvc.DesDecrypt error(%v)", err)
+		return
+	}
+	if len(bs) > 32 {
+		usermob = string(bs[:32])
+	} else {
+		usermob = string(bs)
+	}
+	row := s.unicomInfo(c, usermob, now)
+	if res, msg, err = s.uState(row, usermob, now); err != nil {
+		return
+	}
+	if res.Spid == 979 {
+		err = ecode.NotModified
+		msg = "该业务只支持哔哩哔哩免流卡"
+		return
+	}
+	if _, err = s.unicomBindInfo(c, mid); err == nil {
+		err = ecode.NotModified
+		msg = "该账户已绑定过手机号"
+		return
+	}
+	if midtmp := s.unicomBindMIdByPhone(c, phone); midtmp > 0 {
+		err = ecode.NotModified
+		msg = "该手机号已被注册"
+		return
+	}
+	if ub, err = s.dao.UserBindOld(c, phone); err != nil || ub == nil {
+		phoneInt, _ := strconv.Atoi(phone)
+		ub = &unicom.UserBind{
+			Usermob: usermob,
+			Phone:   phoneInt,
+			Mid:     mid,
+			State:   1,
+		}
+	} else {
+		ub.Mid = mid
+		ub.State = 1
+	}
+	if result, err = s.dao.InUserBind(c, ub); err != nil || result == 0 {
+		log.Error("s.dao.InUserBind ub(%v) error(%v) or result==0", ub, err)
+		return
+	}
+	if err = s.dao.AddUserBindCache(c, mid, ub); err != nil {
+		log.Error("s.dao.AddUserBindCache error(%v)", err)
+		return
+	}
+	// databus
+	s.addUserBindState(&unicom.UserBindInfo{MID: ub.Mid, Phone: ub.Phone, Action: "unicom_welfare_bind"})
+	return
+}
+
+// ReleaseUnicomBind release unicom bind
+func (s *Service) ReleaseUnicomBind(c context.Context, mid int64, phone int) (msg string, err error) {
+	var (
+		result int64
+		ub     *unicom.UserBind
+	)
+	if ub, err = s.unicomBindInfo(c, mid); err != nil {
+		msg = "用户未绑定手机号"
+		return
+	}
+	ub.State = 0
+	if err = s.dao.DeleteUserBindCache(c, mid); err != nil {
+		log.Error("s.dao.DeleteUserBindCache error(%v)", err)
+		return
+	}
+	if result, err = s.dao.InUserBind(c, ub); err != nil || result == 0 {
+		log.Error("s.dao.InUserBind ub(%v) error(%v) or result==0", ub, err)
+		return
+	}
+	// databus
+	s.addUserBindState(&unicom.UserBindInfo{MID: ub.Mid, Phone: ub.Phone, Action: "unicom_welfare_untied"})
+	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 {
+		s.pHit.Incr("unicoms_userbind_cache")
+	} else {
+		if res, err = s.dao.UserBind(c, mid); err != nil {
+			log.Error("s.dao.UserBind error(%v)", err)
+			return
+		}
+		s.pMiss.Incr("unicoms_userbind_cache")
+		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
+}
+
+func (s *Service) unicomBindMIdByPhone(c context.Context, phone string) (mid int64) {
+	var err error
+	if mid, err = s.dao.UserBindPhoneMid(c, phone); err != nil {
+		log.Error("s.dao.UserBindPhoneMid error(%v)", phone)
+		return
+	}
+	return
+}
+
+// UserBind user bind
+func (s *Service) UserBind(c context.Context, mid int64) (res *unicom.UserBind, msg string, err error) {
+	var (
+		acc *account.Info
+		ub  *unicom.UserBind
+	)
+	if acc, err = s.accd.Info(c, mid); err != nil {
+		log.Error("s.accd.info error(%v)", err)
+		return
+	}
+	res = &unicom.UserBind{
+		Name: acc.Name,
+		Mid:  acc.Mid,
+	}
+	if ub, err = s.unicomBindInfo(c, mid); err != nil {
+		log.Error("s.userBindInfo error(%v)", err)
+		err = nil
+	}
+	if ub != nil {
+		res.Phone = ub.Phone
+		res.Integral = ub.Integral
+		res.Flow = ub.Flow
+	}
+	return
+}
+
+// UnicomPackList unicom pack list
+func (s *Service) UnicomPackList() (res []*unicom.UserPack) {
+	res = s.unicomPackCache
+	return
+}
+
+// UnicomPackReceive unicom pack receive
+func (s *Service) UnicomPackReceive(c context.Context, mid int64, packID int64, now time.Time) (msg string, err error) {
+	var (
+		pack             *unicom.UserPack
+		userbind         *unicom.UserBind
+		requestNo        int64
+		unicomOrderID    string
+		unicomOutorderID string
+		u                *unicom.Unicom
+	)
+	if userbind, err = s.unicomBindInfo(c, mid); err != nil {
+		err = ecode.NotModified
+		msg = "用户未绑定手机号"
+		return
+	}
+	row := s.unicomInfo(c, userbind.Usermob, now)
+	if u, msg, err = s.uState(row, userbind.Usermob, now); err != nil {
+		return
+	}
+	if u.Spid == 979 {
+		err = ecode.NotModified
+		msg = "该业务只支持哔哩哔哩免流卡"
+		return
+	}
+	if pack, err = s.unicomPackInfos(c, packID); err != nil {
+		err = ecode.NotModified
+		msg = "该礼包不存在"
+		return
+	}
+	if pack.Capped != 0 && pack.Amount == 0 {
+		err = ecode.NotModified
+		msg = "该礼包不存在"
+		return
+	}
+	if userbind.Integral < pack.Integral {
+		err = ecode.NotModified
+		msg = "福利点不足"
+		return
+	}
+	if requestNo, err = s.seqdao.SeqID(c); err != nil {
+		log.Error("unicom_s.seqdao.SeqID error (%v)", err)
+		return
+	}
+	switch pack.Type {
+	case 0:
+		if err = s.dao.UserFlowWaitCache(c, userbind.Phone); err == nil {
+			err = ecode.NotModified
+			msg = "请间隔一分钟之后再领取流量包"
+			return
+		}
+		if msg, err = s.dao.FlowPre(c, userbind.Phone, requestNo, now); err != nil {
+			log.Error("s.dao.FlowPre error(%v)", err)
+			return
+		}
+		if unicomOrderID, unicomOutorderID, msg, err = s.dao.FlowExchange(c, userbind.Phone, pack.Param, requestNo, now); err != nil {
+			log.Error("s.dao.FlowExchange error(%v)", err)
+			return
+		}
+		uf := &unicom.UnicomUserFlow{
+			Phone:      userbind.Phone,
+			Mid:        mid,
+			Integral:   pack.Integral,
+			Flow:       0,
+			Orderid:    unicomOrderID,
+			Outorderid: unicomOutorderID,
+			Desc:       pack.Desc,
+		}
+		key := strconv.Itoa(userbind.Phone) + unicomOutorderID
+		if err = s.addUserFlowCache(c, key, uf); err != nil {
+			log.Error("s.addUserFlowCache error(%v)", err)
+			return
+		}
+		if err = s.dao.AddUserFlowWaitCache(c, userbind.Phone); err != nil {
+			log.Error("s.dao.AddUserFlowWaitCache error(%v)", err)
+			return
+		}
+	case 1:
+		var batchID int
+		if batchID, err = strconv.Atoi(pack.Param); err != nil {
+			log.Error("batchID(%v) strconv.Atoi error(%v)", pack.Param, err)
+			msg = "礼包参数错误"
+			err = ecode.RequestErr
+			return msg, err
+		}
+		if msg, err = s.accd.AddVIP(c, mid, requestNo, batchID, pack.Desc); err != nil {
+			log.Error("s.accd.AddVIP error(%v)", err)
+			return msg, err
+		}
+	case 2:
+		var day int
+		if day, err = strconv.Atoi(pack.Param); err != nil {
+			log.Error("day(%v) strconv.Atoi error(%v)", pack.Param, err)
+			msg = "礼包参数错误"
+			err = ecode.RequestErr
+			return msg, err
+		}
+		if msg, err = s.live.AddVip(c, mid, day); err != nil {
+			log.Error("s.live.AddVip error(%v)", err)
+			return "", err
+		}
+	case 3:
+		var acc *account.Info
+		if acc, err = s.accd.Info(c, mid); err != nil {
+			log.Error("s.accd.info error(%v)", err)
+			return
+		}
+		if msg, err = s.shop.Coupon(c, pack.Param, mid, acc.Name); err != nil {
+			log.Error("s.shop.Coupon error(%v)", err)
+			return
+		}
+	}
+	var (
+		p            = &unicom.UserPack{}
+		ub           = &unicom.UserBind{}
+		requestNoStr string
+		result       int64
+	)
+	if pack.Capped != 0 {
+		*p = *pack
+		p.Amount = p.Amount - 1
+		if p.Amount == 0 {
+			if err = s.dao.DeleteUserPackCache(c, p.ID); err != nil {
+				log.Error("s.dao.DeleteUserPackCache error(%v)", err)
+				return
+			}
+			p.State = 0
+		} else {
+			if err = s.dao.AddUserPackCache(c, p.ID, p); err != nil {
+				log.Error("s.dao.AddUserPackCache error(%v)", err)
+				return
+			}
+		}
+		if result, err = s.dao.UpUserPacks(c, p, p.ID); err != nil || result == 0 {
+			log.Error("s.dao.UpUserPacks error(%v) or result==0", err)
+			return
+		}
+	}
+	*ub = *userbind
+	ub.Integral = ub.Integral - pack.Integral
+	if err = s.updateUserIntegral(c, mid, ub); err != nil {
+		log.Error("s.updateUserIntegral error(%v)", err)
+		return
+	}
+	msg = pack.Desc + ",领取成功"
+	if unicomOrderID != "" {
+		requestNoStr = unicomOrderID
+	} else {
+		requestNoStr = strconv.FormatInt(requestNo, 10)
+	}
+	log.Info("unicom_pack(%v) mid(%v)", pack.Desc+",领取成功", userbind.Mid)
+	s.unicomPackInfoc(userbind.Usermob, pack.Desc, requestNoStr, userbind.Phone, pack.Integral, int(pack.Capped), userbind.Mid, now)
+	ul := &unicom.UserPackLog{
+		Phone:     userbind.Phone,
+		Usermob:   userbind.Usermob,
+		Mid:       userbind.Mid,
+		RequestNo: requestNoStr,
+		Type:      pack.Type,
+		Desc:      pack.Desc,
+		UserDesc:  ("您当前已领取" + pack.Desc + "，扣除" + strconv.Itoa(pack.Integral) + "福利点"),
+		Integral:  pack.Integral,
+	}
+	s.addUserPackLog(ul)
+	return
+}
+
+// UnicomFlowPack unicom flow pack
+func (s *Service) UnicomFlowPack(c context.Context, mid int64, flowID string, now time.Time) (msg string, err error) {
+	var (
+		userbind         *unicom.UserBind
+		ub               = &unicom.UserBind{}
+		requestNo        int64
+		flowDesc         string
+		flow             int
+		unicomOrderID    string
+		unicomOutorderID string
+		u                *unicom.Unicom
+	)
+	if userbind, err = s.unicomBindInfo(c, mid); err != nil {
+		err = ecode.NotModified
+		msg = "用户未绑定手机号"
+		return
+	}
+	row := s.unicomInfo(c, userbind.Usermob, now)
+	if u, msg, err = s.uState(row, userbind.Usermob, now); err != nil {
+		return
+	}
+	if u.Spid == 979 {
+		err = ecode.NotModified
+		msg = "该业务只支持哔哩哔哩免流卡"
+		return
+	}
+	switch flowID {
+	case "01":
+		flow = 100
+		flowDesc = "100MB流量包"
+	case "02":
+		flow = 200
+		flowDesc = "200MB流量包"
+	case "03":
+		flow = 300
+		flowDesc = "300MB流量包"
+	case "04":
+		flow = 500
+		flowDesc = "500MB流量包"
+	case "05":
+		flow = 1024
+		flowDesc = "1024MB流量包"
+	case "06":
+		flow = 2048
+		flowDesc = "2048MB流量包"
+	default:
+		err = ecode.RequestErr
+		msg = "流量包参数错误"
+		return
+	}
+	if userbind.Flow < flow {
+		err = ecode.NotModified
+		msg = "可用流量不足"
+		return
+	}
+	if err = s.dao.UserFlowWaitCache(c, userbind.Phone); err == nil {
+		err = ecode.NotModified
+		msg = "请间隔一分钟之后再领取流量包"
+		return
+	}
+	if requestNo, err = s.seqdao.SeqID(c); err != nil {
+		log.Error("unicom_s.seqdao.SeqID error (%v)", err)
+		return
+	}
+	if unicomOrderID, unicomOutorderID, msg, err = s.dao.FlowExchange(c, userbind.Phone, flowID, requestNo, now); err != nil {
+		log.Error("s.dao.FlowExchange error(%v)", err)
+		return
+	}
+	uf := &unicom.UnicomUserFlow{
+		Phone:      userbind.Phone,
+		Mid:        mid,
+		Integral:   0,
+		Flow:       flow,
+		Orderid:    unicomOrderID,
+		Outorderid: unicomOutorderID,
+		Desc:       flowDesc,
+	}
+	key := strconv.Itoa(userbind.Phone) + unicomOutorderID
+	if err = s.addUserFlowCache(c, key, uf); err != nil {
+		log.Error("s.addUserFlowCache error(%v)", err)
+		return
+	}
+	*ub = *userbind
+	ub.Flow = ub.Flow - flow
+	if err = s.updateUserIntegral(c, mid, ub); err != nil {
+		log.Error("s.updateUserIntegral error(%v)", err)
+		return
+	}
+	msg = flowDesc + ",领取成功"
+	log.Info("unicom_pack(%v) mid(%v)", flowDesc+",领取成功", userbind.Mid)
+	s.unicomPackInfoc(userbind.Usermob, flowDesc, unicomOrderID, userbind.Phone, flow, 0, userbind.Mid, now)
+	ul := &unicom.UserPackLog{
+		Phone:     userbind.Phone,
+		Usermob:   userbind.Usermob,
+		Mid:       userbind.Mid,
+		RequestNo: unicomOrderID,
+		Type:      0,
+		Desc:      flowDesc,
+		UserDesc:  ("您当前已领取" + flowDesc + "，扣除" + strconv.Itoa(flow) + "MB流量"),
+		Integral:  flow,
+	}
+	s.addUserPackLog(ul)
+	if err = s.dao.AddUserFlowWaitCache(c, userbind.Phone); err != nil {
+		log.Error("s.dao.AddUserFlowWaitCache error(%v)", err)
+		return
+	}
+	return
+}
+
+// UserBindLog user bind week log
+func (s *Service) UserBindLog(c context.Context, mid int64, now time.Time) (res []*unicom.UserLog, err error) {
+	if res, err = s.dao.SearchUserBindLog(c, mid, now); err != nil {
+		log.Error("unicom s.dao.SearchUserBindLog error(%v)", err)
+		return
+	}
+	return
+}
+
+// WelfareBindState welfare user bind state
+func (s *Service) WelfareBindState(c context.Context, mid int64) (res int) {
+	if ub, err := s.dao.UserBindCache(c, mid); err == nil && ub != nil {
+		res = 1
+	}
+	return
+}
+
+func (s *Service) updateUserIntegral(c context.Context, mid int64, ub *unicom.UserBind) (err error) {
+	var result int64
+	if err = s.dao.AddUserBindCache(c, mid, ub); err != nil {
+		log.Error("s.dao.AddUserBindCache error(%v)", err)
+		return
+	}
+	if result, err = s.dao.UpUserIntegral(c, ub); err != nil {
+		log.Error("s.dao.UpUserIntegral error(%v) ", err)
+		return
+	}
+	if result == 0 {
+		log.Error("s.dao.UpUserIntegral result==0")
+		err = ecode.NotModified
+		return
+	}
+	return
+}
+
+// unicomPackInfos unicom pack infos
+func (s *Service) unicomPackInfos(c context.Context, id int64) (res *unicom.UserPack, err error) {
+	var (
+		ub  *unicom.UserPack
+		row = map[int64]*unicom.UserPack{}
+		ok  bool
+	)
+	if ub, err = s.dao.UserPackCache(c, id); err == nil {
+		res = ub
+		s.pHit.Incr("unicoms_pack_cache")
+	} else {
+		if row, err = s.dao.UserPackByID(c, id); err != nil {
+			log.Error("s.dao.UserBind error(%v)", err)
+			return
+		}
+		s.pMiss.Incr("unicoms_pack_cache")
+		ub, ok = row[id]
+		if !ok {
+			err = ecode.NothingFound
+			return
+		}
+		if err = s.dao.AddUserPackCache(c, id, ub); err != nil {
+			log.Error("s.dao.AddUserPackCache id(%d) error(%v)", id, err)
+			return
+		}
+		res = ub
+	}
+	return
+}
+
+// unciomIPState
+func (s *Service) unciomIPState(ipUint uint32) (isValide bool) {
+	for _, u := range s.unicomIpCache {
+		if u.IPStartUint <= ipUint && u.IPEndUint >= ipUint {
+			isValide = true
+			return
+		}
+	}
+	isValide = false
+	return
+}
+
+// unicomIp ip limit
+func (s *Service) iplimit(k, ip string) bool {
+	key := fmt.Sprintf(_initIPlimitKey, k, ip)
+	if _, ok := s.operationIPlimit[key]; ok {
+		return true
+	}
+	return false
+}
+
+// DesDecrypt
+func (s *Service) DesDecrypt(src, key []byte) ([]byte, error) {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]byte, len(src))
+	dst := out
+	bs := block.BlockSize()
+	if len(src)%bs != 0 {
+		return nil, errors.New("crypto/cipher: input not full blocks")
+	}
+	for len(src) > 0 {
+		block.Decrypt(dst, src[:bs])
+		src = src[bs:]
+		dst = dst[bs:]
+	}
+	out = s.zeroUnPadding(out)
+	return out, nil
+}
+
+// zeroUnPadding
+func (s *Service) zeroUnPadding(origData []byte) []byte {
+	return bytes.TrimFunc(origData,
+		func(r rune) bool {
+			return r == rune(0)
+		})
+}
+
+func (s *Service) addUserFlowCache(c context.Context, key string, uf *unicom.UnicomUserFlow) (err error) {
+	if err = s.dao.AddUserFlowCache(c, key); err != nil {
+		log.Error("s.dao.AddUserFlowCache error(%v)", err)
+		return
+	}
+	var flowList map[string]*unicom.UnicomUserFlow
+	if flowList, err = s.dao.UserFlowListCache(c); err != nil {
+		log.Error("s.dao.UserFlowListCache error(%v)", err)
+		return
+	}
+	if flowList == nil {
+		flowList = map[string]*unicom.UnicomUserFlow{
+			key: uf,
+		}
+	} else {
+		flowList[key] = uf
+	}
+	if err = s.dao.AddUserFlowListCache(c, flowList); err != nil {
+		log.Error("s.dao.AddUserFlowListCache error(%v)", err)
+		return
+	}
+	return
+}
+
+// UserPacksLog user pack logs
+func (s *Service) UserPacksLog(c context.Context, starttime, now time.Time, start int, ip string) (res []*unicom.UserPackLog, err error) {
+	if !s.iplimit(_unicomPackKey, ip) {
+		err = ecode.AccessDenied
+		return
+	}
+	var (
+		endday time.Time
+	)
+	if starttime.Month() >= now.Month() && starttime.Year() >= now.Year() {
+		res = []*unicom.UserPackLog{}
+		return
+	}
+	if endInt := starttime.AddDate(0, 1, -1).Day(); start > endInt {
+		res = []*unicom.UserPackLog{}
+		return
+	} else if start == endInt {
+		endday = starttime.AddDate(0, 1, 0)
+	} else {
+		endday = starttime.AddDate(0, 0, start)
+	}
+	if res, err = s.dao.UserPacksLog(c, endday.AddDate(0, 0, -1), endday); err != nil {
+		log.Error("user pack logs s.dao.UserPacksLog error(%v)", err)
+		return
+	}
+	if len(res) == 0 {
+		res = []*unicom.UserPackLog{}
+	}
+	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) addUserPackLogproc() {
+	for {
+		i, ok := <-s.packLogCh
+		if !ok {
+			log.Warn("user pack log proc exit")
+			return
+		}
+		var (
+			c      = context.TODO()
+			result int64
+			err    error
+			logID  = 91
+		)
+		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
+			}
+			report.User(&report.UserInfo{
+				Mid:      v.Mid,
+				Business: logID,
+				Action:   "unicom_userpack_deduct",
+				Ctime:    time.Now(),
+				Content: map[string]interface{}{
+					"phone":     v.Phone,
+					"pack_desc": v.UserDesc,
+					"integral":  (0 - v.Integral),
+				},
+			})
+		}
+	}
+}

app/interface/main/app-wall/service/unicom/unicom_test.go

@@ -0,0 +1,158 @@
+package unicom
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	s *Service
+)
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		f(s)
+	}
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	s = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestUserFlow(t *testing.T) {
+	Convey("Unicom UserFlow", t, WithService(func(s *Service) {
+		res, _, err := s.UserFlow(context.TODO(), "", "iphone", "127.0.0.1", 111, time.Now())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestUserState(t *testing.T) {
+	Convey("Unicom UserState", t, WithService(func(s *Service) {
+		res, _, err := s.UserState(context.TODO(), "", "iphone", "127.0.0.1", 111, time.Now())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestUnicomState(t *testing.T) {
+	Convey("Unicom UnicomState", t, WithService(func(s *Service) {
+		res, err := s.UnicomState(context.TODO(), "", "iphone", "127.0.0.1", 111, time.Now())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestUserFlowState(t *testing.T) {
+	Convey("Unicom UserFlowState", t, WithService(func(s *Service) {
+		res, err := s.UserFlowState(context.TODO(), "", time.Now())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestIsUnciomIP(t *testing.T) {
+	Convey("Unicom IsUnciomIP", t, WithService(func(s *Service) {
+		err := s.IsUnciomIP(0, "127.0.0.1", "iphone", 0, time.Now())
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestUserUnciomIP(t *testing.T) {
+	Convey("Unicom UserUnciomIP", t, WithService(func(s *Service) {
+		err := s.UserUnciomIP(0, "127.0.0.1", "", "iphone", 0, time.Now())
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestOrder(t *testing.T) {
+	Convey("Unicom Order", t, WithService(func(s *Service) {
+		res, _, err := s.Order(context.TODO(), "", "", 0, time.Now())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestCancelOrder(t *testing.T) {
+	Convey("Unicom CancelOrder", t, WithService(func(s *Service) {
+		res, _, err := s.CancelOrder(context.TODO(), "")
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestUnicomSMSCode(t *testing.T) {
+	Convey("Unicom UnicomSMSCode", t, WithService(func(s *Service) {
+		res, err := s.UnicomSMSCode(context.TODO(), "", time.Now())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestAddUnicomBind(t *testing.T) {
+	Convey("Unicom AddUnicomBind", t, WithService(func(s *Service) {
+		res, err := s.AddUnicomBind(context.TODO(), "", 1, 1, time.Now())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestReleaseUnicomBind(t *testing.T) {
+	Convey("Unicom ReleaseUnicomBind", t, WithService(func(s *Service) {
+		res, err := s.ReleaseUnicomBind(context.TODO(), 1, 1)
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestUserBind(t *testing.T) {
+	Convey("Unicom UserBind", t, WithService(func(s *Service) {
+		res, _, err := s.UserBind(context.TODO(), 1)
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestUnicomPackList(t *testing.T) {
+	Convey("Unicom UnicomPackList", t, WithService(func(s *Service) {
+		res := s.UnicomPackList()
+		So(res, ShouldNotBeEmpty)
+	}))
+}
+
+func TestUnicomPackReceive(t *testing.T) {
+	Convey("Unicom UnicomPackReceive", t, WithService(func(s *Service) {
+		res, _ := s.UnicomPackReceive(context.TODO(), 1, 1, time.Now())
+		So(res, ShouldNotBeEmpty)
+	}))
+}
+
+func TestUnicomUnicomFlowPack(t *testing.T) {
+	Convey("Unicom UnicomFlowPack", t, WithService(func(s *Service) {
+		res, _ := s.UnicomFlowPack(context.TODO(), 1, "", time.Now())
+		So(res, ShouldNotBeEmpty)
+	}))
+}
+
+func TestUnicomloadUnicomFlow(t *testing.T) {
+	Convey("Unicom loadUnicomFlow", t, WithService(func(s *Service) {
+		s.loadUnicomFlow()
+	}))
+}
+
+func TestUnicomloadUnicomIPOrder(t *testing.T) {
+	Convey("Unicom loadUnicomIPOrder", t, WithService(func(s *Service) {
+		s.loadUnicomIPOrder(time.Now())
+	}))
+}