Create & Init Project...

app/service/main/secure/dao/BUILD

@@ -0,0 +1,67 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "hbase.go",
+        "http.go",
+        "memcache.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/service/main/secure/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/secure/conf:go_default_library",
+        "//app/service/main/secure/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/hbase.v2:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/tsuna/gohbase/hrpc:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao_test.go",
+        "hbase_test.go",
+        "http_test.go",
+        "memcache_test.go",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/secure/conf:go_default_library",
+        "//app/service/main/secure/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/bouk/monkey:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey: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/service/main/secure/dao/dao.go

@@ -0,0 +1,52 @@
+package dao
+
+import (
+	"time"
+
+	"go-common/app/service/main/secure/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/database/sql"
+	bm "go-common/library/net/http/blademaster"
+
+	"go-common/library/database/hbase.v2"
+)
+
+// Dao struct info of Dao.
+type Dao struct {
+	db                *sql.DB
+	ddldb             *sql.DB
+	c                 *conf.Config
+	redis             *redis.Pool
+	hbase             *hbase.Client
+	locsExpire        int32
+	expire            int64
+	doubleCheckExpire int64
+	mc                *memcache.Pool
+	// http
+	httpClient *bm.Client
+}
+
+// New new a Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:                 c,
+		redis:             redis.NewPool(c.Redis.Config),
+		expire:            int64(time.Duration(c.Redis.Expire) / time.Second),
+		doubleCheckExpire: int64(time.Duration(c.Redis.DoubleCheck) / time.Second),
+		db:                sql.NewMySQL(c.Mysql.Secure),
+		ddldb:             sql.NewMySQL(c.Mysql.DDL),
+		hbase:             hbase.NewClient(c.HBase.Config),
+		mc:                memcache.NewPool(c.Memcache.Config),
+		locsExpire:        int32(time.Duration(c.Memcache.Expire) / time.Second),
+		httpClient:        bm.NewClient(c.HTTPClient),
+	}
+	return
+}
+
+// Close close connections of mc, redis, db.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

app/service/main/secure/dao/dao_test.go

@@ -0,0 +1,37 @@
+package dao
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/service/main/secure/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account.secure-service")
+		flag.Set("conf_appid", "main.account.secure-service")
+		flag.Set("conf_token", "02bebea2b9e0b8d5b0433b2a59b8bc68")
+		flag.Set("tree_id", "2864")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../cmd/secure-service-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/service/main/secure/dao/hbase.go

@@ -0,0 +1,172 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"crypto/md5"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"strconv"
+	"time"
+
+	"go-common/app/service/main/secure/model"
+	"go-common/library/log"
+	xtime "go-common/library/time"
+
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+var (
+	tableLog  = "ugc:login_log"
+	familyTS  = "ts"
+	familyTSB = []byte(familyTS)
+
+	tableSecure = "ugc:secure"
+	familyEcpt  = "ecpt"
+	familyEcptB = []byte(familyEcpt)
+	columnid    = "id"
+	columnloc   = "loc"
+	columntp    = "tp"
+	columnip    = "ip"
+	columnts    = "ts"
+	// familyFB     = "feedback"
+	// familyFBB    = []byte(familyFB)
+)
+
+// rowKey return key string.
+func rowKey(mid int64) string {
+	sum := md5.Sum([]byte(strconv.FormatInt(mid, 10)))
+	return fmt.Sprintf("%x", sum)
+}
+func exKey(mid, ts int64, ip uint32) string {
+	return fmt.Sprintf("%d%d_%d_%d", mid%10, mid, ts, ip)
+}
+func exStartkey(mid int64) string {
+	return fmt.Sprintf("%d%d", mid%10, mid)
+}
+func exStopKey(mid int64) string {
+	return fmt.Sprintf("%d%d", mid%10, mid+1)
+}
+
+// AddLocs add login log.
+func (d *Dao) AddLocs(c context.Context, mid, locid, ts int64) (err error) {
+	var (
+		locB        = make([]byte, 8)
+		key         = rowKey(mid)
+		column      = strconv.FormatInt(ts, 10)
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.WriteTimeout))
+	)
+	defer cancel()
+	binary.BigEndian.PutUint64(locB, uint64(locid))
+	values := map[string]map[string][]byte{familyTS: {column: locB}}
+	if _, err = d.hbase.PutStr(ctx, tableLog, key, values); err != nil {
+		log.Error("hbase.Put error(%v)", err)
+	}
+	return
+}
+
+// Locs get all login location.
+func (d *Dao) Locs(c context.Context, mid int64) (locs map[int64]int64, err error) {
+	var (
+		result      *hrpc.Result
+		key         = rowKey(mid)
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableLog, key); err != nil {
+		log.Error("d.hbase.Get error(%v)", err)
+		return
+	}
+	if result == nil {
+		return
+	}
+	locs = make(map[int64]int64)
+	for _, c := range result.Cells {
+
+		if c != nil && len(c.Value) == 8 && bytes.Equal(c.Family, familyTSB) {
+			locid := int64(binary.BigEndian.Uint64(c.Value))
+			locs[locid]++
+		}
+	}
+	return
+}
+
+// AddException add feedback.
+func (d *Dao) AddException(c context.Context, l *model.Log) (err error) {
+	var (
+		idB         = make([]byte, 8)
+		ipB         = make([]byte, 8)
+		tsB         = make([]byte, 8)
+		key         = exKey(l.Mid, int64(l.Time), l.IP)
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.WriteTimeout))
+	)
+	defer cancel()
+	binary.BigEndian.PutUint64(idB, uint64(l.LocationID))
+	binary.BigEndian.PutUint64(ipB, uint64(l.IP))
+	binary.BigEndian.PutUint64(tsB, uint64(l.Time))
+	values := map[string]map[string][]byte{familyEcpt: {
+		columnid:  idB,
+		columnloc: []byte(l.Location),
+		columnts:  tsB,
+		columnip:  ipB,
+	}}
+	if _, err = d.hbase.PutStr(ctx, tableSecure, key, values); err != nil {
+		log.Error("hbase.Put error(%v)", err)
+	}
+	return
+}
+
+// AddFeedBack add feedback
+func (d *Dao) AddFeedBack(c context.Context, l *model.Log) (err error) {
+	var (
+		tpB         = make([]byte, 8)
+		key         = exKey(l.Mid, int64(l.Time), l.IP)
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.WriteTimeout))
+	)
+	defer cancel()
+	binary.BigEndian.PutUint64(tpB, uint64(l.Type))
+	values := map[string]map[string][]byte{familyEcpt: {columntp: tpB}}
+	if _, err = d.hbase.PutStr(ctx, tableSecure, key, values); err != nil {
+		log.Error("hbase.Put error(%v)", err)
+	}
+	return
+}
+
+// ExceptionLoc get exception loc.
+func (d *Dao) ExceptionLoc(c context.Context, mid int64) (eps []*model.Expection, err error) {
+	var (
+		scanner     hrpc.Scanner
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+	)
+	defer cancel()
+	scanner, err = d.hbase.ScanRangeStr(ctx, tableSecure, exStartkey(mid), exStopKey(mid))
+	if err != nil {
+		log.Error("d.hbase.ScanRangeStr error(%v)", err)
+		return
+	}
+	for {
+		result, err = scanner.Next()
+		if err != nil {
+			if err == io.EOF {
+				err = nil
+			}
+			return
+		}
+		ep := new(model.Expection)
+		for _, c := range result.Cells {
+			if c != nil && bytes.Equal(c.Family, familyEcptB) {
+				switch string(c.Qualifier) {
+				case columnts:
+					ep.Time = xtime.Time(binary.BigEndian.Uint64(c.Value))
+				case columntp:
+					ep.FeedBack = int8(binary.BigEndian.Uint64(c.Value))
+				case columnip:
+					ep.IP = binary.BigEndian.Uint64(c.Value)
+				}
+			}
+		}
+		eps = append(eps, ep)
+	}
+}

app/service/main/secure/dao/hbase_test.go

@@ -0,0 +1,66 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/service/main/secure/model"
+	xtime "go-common/library/time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestAddLocs(t *testing.T) {
+	Convey("TestAddLocs", t, func() {
+		err := d.AddLocs(context.TODO(), 2, 3, 11)
+		d.AddLocs(context.TODO(), 2, 4, 12)
+		d.AddLocs(context.TODO(), 2, 4, 13)
+		d.AddLocs(context.TODO(), 2, 4, 14)
+		d.AddLocs(context.TODO(), 2, 3, 15)
+		So(err, ShouldBeNil)
+
+	})
+}
+
+func TestLocs(t *testing.T) {
+	Convey("TestLocs", t, func() {
+		locs, err := d.Locs(context.TODO(), 2)
+		So(err, ShouldBeNil)
+		So(locs, ShouldNotBeNil)
+	})
+}
+
+func TestAddEcpt(t *testing.T) {
+	Convey("TestAddEcpt", t, func() {
+		err := d.AddException(context.TODO(), &model.Log{Mid: 2, Time: xtime.Time(1111), IP: 222, LocationID: 3, Location: "aa"})
+		So(err, ShouldBeNil)
+
+		err = d.AddException(context.TODO(), &model.Log{Mid: 2, Time: xtime.Time(1311), IP: 222, LocationID: 3, Location: "aa"})
+		So(err, ShouldBeNil)
+
+		err = d.AddException(context.TODO(), &model.Log{Mid: 2333, Time: xtime.Time(1111), IP: 222, LocationID: 3, Location: "aa"})
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestAddFeedBack(t *testing.T) {
+	Convey("TestAddFeedBack", t, func() {
+		err := d.AddFeedBack(context.TODO(), &model.Log{Mid: 2, Time: xtime.Time(1111), IP: 222, Type: 2, LocationID: 3, Location: "aa"})
+		if err != nil {
+			t.Errorf("test hbase add  err %v", err)
+		}
+	})
+}
+
+func TestExcep(t *testing.T) {
+	Convey("TestExcep", t, func() {
+		locs, err := d.ExceptionLoc(context.TODO(), 2)
+		if err != nil {
+			t.Errorf("test hbase add  err %v", err)
+		} else {
+			for _, l := range locs {
+				t.Logf("locs %v", l)
+			}
+		}
+	})
+}

app/service/main/secure/dao/http.go

@@ -0,0 +1,29 @@
+package dao
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/library/log"
+)
+
+const (
+	_doubleCheckURL = "http://passport.bilibili.co/intranet/acc/security/mid"
+)
+
+// DoubleCheck notify passport to remove login.
+func (d *Dao) DoubleCheck(c context.Context, mid int64) (err error) {
+	params := url.Values{}
+	params.Set("mids", strconv.FormatInt(mid, 10))
+	params.Set("desc", "异地风险，系统导入")
+	params.Set("operator", "异地系统判断")
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.httpClient.Post(c, _doubleCheckURL, "", params, &res); err != nil {
+		log.Error("d.Doublecheck err(%v)", err)
+	}
+	log.Info("d.DoubleCheck mid %d ", mid)
+	return
+}

app/service/main/secure/dao/http_test.go

@@ -0,0 +1,17 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDoubleCheck(t *testing.T) {
+	Convey("TestDoubleCheck", t, func() {
+		err := d.DoubleCheck(context.TODO(), 1)
+		if err != nil {
+			t.Errorf("test DoubleCheck err %v", err)
+		}
+	})
+}

app/service/main/secure/dao/memcache.go

@@ -0,0 +1,56 @@
+package dao
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/service/main/secure/model"
+	gmc "go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_prefixLocs = "locs_"
+)
+
+func locsKey(mid int64) string {
+	return _prefixLocs + strconv.FormatInt(mid, 10)
+}
+func (d *Dao) pingMC(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	if err = conn.Set(&gmc.Item{Key: "ping", Value: []byte{1}, Expiration: d.locsExpire}); err != nil {
+		log.Error("conn.Store(set, ping, 1) error(%v)", err)
+	}
+	conn.Close()
+	return
+}
+
+// AddLocsCache add login locs count to cache.
+func (d *Dao) AddLocsCache(c context.Context, mid int64, locs *model.Locs) (err error) {
+	item := &gmc.Item{Key: locsKey(mid), Object: locs, Expiration: d.locsExpire, Flags: gmc.FlagProtobuf}
+	conn := d.mc.Get(c)
+	if err = conn.Set(item); err != nil {
+		log.Error("AddLocs err(%v)", err)
+	}
+	conn.Close()
+	return
+}
+
+// LocsCache get login locs count.
+func (d *Dao) LocsCache(c context.Context, mid int64) (locs map[int64]int64, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	item, err := conn.Get(locsKey(mid))
+	if err != nil {
+		if err == gmc.ErrNotFound {
+			err = nil
+		}
+		return
+	}
+	loc := &model.Locs{}
+	if err = conn.Scan(item, loc); err != nil {
+		log.Error("Locs err(%v)", err)
+	}
+	locs = loc.LocsCount
+	return
+}

app/service/main/secure/dao/memcache_test.go

@@ -0,0 +1,72 @@
+package dao
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"go-common/app/service/main/secure/model"
+	"go-common/library/cache/memcache"
+
+	"github.com/bouk/monkey"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestAddLocsCache(t *testing.T) {
+	Convey("TestAddLocsCache", t, func() {
+		err := d.AddLocsCache(context.TODO(), 3, &model.Locs{LocsCount: map[int64]int64{3: 2, 4: 3}})
+		So(err, ShouldBeNil)
+	})
+	Convey("TestAddLocsCacheErr", t, func() {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrItemObject)
+		})
+		defer connGuard.Unpatch()
+		err := d.AddLocsCache(context.TODO(), 3, &model.Locs{LocsCount: map[int64]int64{3: 2, 4: 3}})
+		So(err, ShouldEqual, memcache.ErrItemObject)
+	})
+}
+
+func TestLocsCache(t *testing.T) {
+	Convey("TestGetLocsCache", t, func() {
+		locs, err := d.LocsCache(context.TODO(), 3)
+		So(err, ShouldBeNil)
+		So(locs, ShouldNotBeNil)
+	})
+	Convey("TestGetLocsCacheGetErr", t, func() {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrNotFound)
+		})
+		defer connGuard.Unpatch()
+		locs, err := d.LocsCache(context.TODO(), 3)
+		So(err, ShouldBeNil)
+		So(locs, ShouldBeNil)
+	})
+
+	Convey("TestGetLocsCacheScanErr", t, func() {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrItemObject)
+		})
+		defer connGuard.Unpatch()
+		locs, err := d.LocsCache(context.TODO(), 3)
+		So(err, ShouldEqual, memcache.ErrItemObject)
+		So(locs, ShouldBeNil)
+	})
+}
+
+func TestMcPing(t *testing.T) {
+	Convey("TestMcPing", t, func() {
+		err := d.pingMC(context.Background())
+		So(err, ShouldBeNil)
+	})
+
+	Convey("TestMcPingErr", t, func() {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrConnClosed)
+		})
+		defer connGuard.Unpatch()
+		err := d.pingMC(context.Background())
+		So(err, ShouldNotBeNil)
+		So(err, ShouldEqual, memcache.ErrConnClosed)
+	})
+}

app/service/main/secure/dao/redis.go

@@ -0,0 +1,225 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+
+	model "go-common/app/service/main/secure/model"
+	"go-common/library/cache/redis"
+	"go-common/library/log"
+)
+
+const (
+	_prefixMsg         = "m_"
+	_prefixUnNotify    = "d_%d%d_%d"
+	_prefixCount       = "c_%d%d_%d"
+	_prefixChangePWD   = "cpwd_%d"
+	_prefixDoublecheck = "dc_%d"
+
+	_expire    = 24 * 3600
+	_expirePWD = 30 * 24 * 3600
+)
+
+func doubleCheckKey(mid int64) string {
+	return fmt.Sprintf(_prefixDoublecheck, mid)
+}
+
+func changePWDKey(mid int64) string {
+	return fmt.Sprintf(_prefixChangePWD, mid)
+}
+func msgKey(mid int64) string {
+	return _prefixMsg + strconv.FormatInt(mid, 10)
+}
+
+func unnotifyKey(mid int64) string {
+	t := time.Now()
+	return fmt.Sprintf(_prefixUnNotify, t.Month(), t.Day(), mid)
+}
+
+func countKey(mid int64) string {
+	t := time.Now()
+	return fmt.Sprintf(_prefixCount, t.Month(), t.Day(), mid)
+}
+
+// AddExpectionMsg add user login expection msg.
+func (d *Dao) AddExpectionMsg(c context.Context, l *model.Log) (err error) {
+	var (
+		conn = d.redis.Get(c)
+		bs   []byte
+		key  = msgKey(l.Mid)
+	)
+	defer conn.Close()
+	if bs, err = json.Marshal(l); err != nil {
+		log.Error("json.Marshal(%v) err(%v)", l, err)
+		return
+	}
+	if _, err = conn.Do("SETEX", key, d.expire, bs); err != nil {
+		log.Error("conn.Set msg:%v err(%v)", l, err)
+	}
+	return
+}
+
+// ExpectionMsg get user expection msg.
+func (d *Dao) ExpectionMsg(c context.Context, mid int64) (msg *model.Log, err error) {
+	var (
+		conn = d.redis.Get(c)
+		bs   []byte
+	)
+	defer conn.Close()
+	if bs, err = redis.Bytes(conn.Do("GET", msgKey(mid))); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+			return
+		}
+		log.Error("conn.GET(mid %d) ,err(%v)", mid, err)
+		return
+	}
+	msg = &model.Log{}
+	if err = json.Unmarshal(bs, msg); err != nil {
+		log.Error("json.Unmarshal err(%v)", err)
+	}
+	return
+}
+
+// AddUnNotify user unnotiry uuid.
+func (d *Dao) AddUnNotify(c context.Context, mid int64, uuid string) (err error) {
+	var (
+		conn = d.redis.Get(c)
+		key  = unnotifyKey(mid)
+	)
+	defer conn.Close()
+	if err = conn.Send("SADD", key, uuid); err != nil {
+		log.Error("conn.SADD mid:%d err(%v)", mid, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", key, _expire); err != nil {
+		log.Error("EXPIRE key :%d err %d", key, err)
+		return
+	}
+	conn.Flush()
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("conn.Recive err %v", err)
+			return
+		}
+	}
+	return
+}
+
+// DelUnNotify del user unnotify record.
+func (d *Dao) DelUnNotify(c context.Context, mid int64) (err error) {
+	conn := d.redis.Get(c)
+	if _, err = conn.Do("DEL", unnotifyKey(mid)); err != nil {
+		log.Error("conn.DEL mid:%d err:%v", mid, err)
+	}
+	conn.Close()
+	return
+}
+
+// UnNotify check if not send notify to user of uuid deveice.
+func (d *Dao) UnNotify(c context.Context, mid int64, uuid string) (b bool, err error) {
+	conn := d.redis.Get(c)
+	if b, err = redis.Bool(conn.Do("SISMEMBER", unnotifyKey(mid), uuid)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+		}
+		log.Error("conn.SISMEMBER (mid:%d) ERR(%v)", mid, err)
+	}
+	conn.Close()
+	return
+}
+
+// Count get user close notify count.
+func (d *Dao) Count(c context.Context, mid int64, uuid string) (count int64, err error) {
+	conn := d.redis.Get(c)
+	if count, err = redis.Int64(conn.Do("HGET", countKey(mid), uuid)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+		}
+		log.Error("conn.GET mid:%d err(%v)", mid, err)
+	}
+	conn.Close()
+	return
+}
+
+// AddCount add user unnotify count daily.
+func (d *Dao) AddCount(c context.Context, mid int64, uuid string) (err error) {
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if err = conn.Send("HINCRBY", countKey(mid), uuid, 1); err != nil {
+		log.Error("conn.INCR mid:%d err:%v", mid, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", countKey(mid), _expire); err != nil {
+		log.Error("conn.EXPIRE mid:%d err:%v", mid, err)
+		return
+	}
+	conn.Flush()
+	for i := 0; i < 2; i++ {
+		if _, err1 := conn.Receive(); err1 != nil {
+			log.Error("conn.Receive err(%v)", err1)
+			return
+		}
+	}
+	return
+}
+
+// AddChangePWDRecord set user change passwd record to cache.
+func (d *Dao) AddChangePWDRecord(c context.Context, mid int64) (err error) {
+	conn := d.redis.Get(c)
+	if _, err = conn.Do("SETEX", changePWDKey(mid), _expirePWD, 1); err != nil {
+		log.Error("d.ChangePWDRecord(mid %d) err(%v)", mid, err)
+	}
+	conn.Close()
+	return
+}
+
+// ChangePWDRecord check if user had change pwd recently one month.
+func (d *Dao) ChangePWDRecord(c context.Context, mid int64) (b bool, err error) {
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if b, err = redis.Bool(conn.Do("GET", changePWDKey(mid))); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+			return
+		}
+		log.Error("d.ChangePWDRecord err(%v)", err)
+	}
+	return
+}
+
+// DelCount  del count
+// for testing clear data.
+func (d *Dao) DelCount(c context.Context, mid int64) (err error) {
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	_, err = conn.Do("DEL", countKey(mid))
+	return
+}
+
+// AddDCheckCache add double check cache.
+func (d *Dao) AddDCheckCache(c context.Context, mid int64) (err error) {
+	conn := d.redis.Get(c)
+	if _, err = conn.Do("SETEX", doubleCheckKey(mid), d.doubleCheckExpire, 1); err != nil {
+		log.Error("d.AddDCheckCache(mid %d) err(%v)", mid, err)
+	}
+	conn.Close()
+	return
+}
+
+// DCheckCache check if user had notify by double check.
+func (d *Dao) DCheckCache(c context.Context, mid int64) (b bool, err error) {
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if b, err = redis.Bool(conn.Do("GET", doubleCheckKey(mid))); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+			return
+		}
+		log.Error("d.DCheckCache err(%v)", err)
+	}
+	return
+}

app/service/main/secure/dao/redis_test.go

@@ -0,0 +1,168 @@
+package dao
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	model "go-common/app/service/main/secure/model"
+	xtime "go-common/library/time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestRedis(t *testing.T) {
+	convey.Convey("TestRedis", t, func() {
+		lput := &model.Log{
+			Mid:        2,
+			Location:   "上海",
+			LocationID: 11,
+			Time:       xtime.Time(time.Now().Unix()),
+		}
+		d.AddExpectionMsg(context.TODO(), lput)
+		lget, _ := d.ExpectionMsg(context.TODO(), 2)
+
+		convey.So(lget.LocationID, convey.ShouldEqual, lput.LocationID)
+
+		d.AddUnNotify(context.TODO(), 2, "1234")
+		b, _ := d.UnNotify(context.TODO(), 2, "1234")
+		convey.So(b, convey.ShouldBeTrue)
+
+		d.DelUnNotify(context.TODO(), 2)
+		b, _ = d.UnNotify(context.TODO(), 2, "1234")
+		convey.So(b, convey.ShouldBeFalse)
+
+		d.AddCount(context.TODO(), 2, "1234")
+		d.AddCount(context.TODO(), 2, "1234")
+		count, _ := d.Count(context.TODO(), 2, "1234")
+		convey.So(count, convey.ShouldEqual, 2)
+
+		d.DelCount(context.TODO(), 2)
+		count, _ = d.Count(context.TODO(), 2, "1234")
+		convey.So(count, convey.ShouldEqual, 0)
+
+	})
+}
+
+func TestDoubleCheckKey(t *testing.T) {
+	convey.Convey("doubleCheckKey", t, func() {
+		p1 := doubleCheckKey(0)
+		convey.So(p1, convey.ShouldNotBeNil)
+	})
+}
+
+func TestChangePWDKey(t *testing.T) {
+	convey.Convey("changePWDKey", t, func() {
+		p1 := changePWDKey(0)
+		convey.So(p1, convey.ShouldNotBeNil)
+	})
+}
+
+func TestMsgKey(t *testing.T) {
+	convey.Convey("msgKey", t, func() {
+		p1 := msgKey(0)
+		convey.So(p1, convey.ShouldNotBeNil)
+	})
+}
+
+func TestUnnotifyKey(t *testing.T) {
+	convey.Convey("unnotifyKey", t, func() {
+		p1 := unnotifyKey(0)
+		convey.So(p1, convey.ShouldNotBeNil)
+	})
+}
+
+func TestCountKey(t *testing.T) {
+	convey.Convey("countKey", t, func() {
+		p1 := countKey(0)
+		convey.So(p1, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoAddExpectionMsg(t *testing.T) {
+	var mid int64 = 7593623
+	convey.Convey("AddExpectionMsg", t, func() {
+		l := &model.Log{Mid: mid}
+		err := d.AddExpectionMsg(context.TODO(), l)
+		convey.So(err, convey.ShouldBeNil)
+	})
+	convey.Convey("ExpectionMsg", t, func() {
+		msg, err := d.ExpectionMsg(context.TODO(), mid)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(msg, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoAddUnNotify(t *testing.T) {
+	convey.Convey("AddUnNotify", t, func() {
+		err := d.AddUnNotify(context.TODO(), 0, "")
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoDelUnNotify(t *testing.T) {
+	convey.Convey("DelUnNotify", t, func() {
+		err := d.DelUnNotify(context.TODO(), 0)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoUnNotify(t *testing.T) {
+	convey.Convey("UnNotify", t, func() {
+		b, err := d.UnNotify(context.TODO(), 0, "")
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(b, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoCount(t *testing.T) {
+	convey.Convey("Count", t, func() {
+		count, err := d.Count(context.TODO(), 0, "")
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(count, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoAddCount(t *testing.T) {
+	convey.Convey("AddCount", t, func() {
+		err := d.AddCount(context.TODO(), 0, "")
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoAddChangePWDRecord(t *testing.T) {
+	convey.Convey("AddChangePWDRecord", t, func() {
+		err := d.AddChangePWDRecord(context.TODO(), 0)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoChangePWDRecord(t *testing.T) {
+	convey.Convey("ChangePWDRecord", t, func() {
+		b, err := d.ChangePWDRecord(context.TODO(), 0)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(b, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoDelCount(t *testing.T) {
+	convey.Convey("DelCount", t, func() {
+		err := d.DelCount(context.TODO(), 0)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoAddDCheckCache(t *testing.T) {
+	convey.Convey("AddDCheckCache", t, func() {
+		err := d.AddDCheckCache(context.TODO(), 0)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoDCheckCache(t *testing.T) {
+	convey.Convey("DCheckCache", t, func() {
+		b, err := d.DCheckCache(context.TODO(), 0)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(b, convey.ShouldNotBeNil)
+	})
+}