Create & Init Project...

app/interface/main/app-wall/dao/account/BUILD

@@ -0,0 +1,50 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["account_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["account.go"],
+    importpath = "go-common/app/interface/main/app-wall/dao/account",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/account/rpc/client:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/dao/account/account.go

@@ -0,0 +1,75 @@
+package account
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-wall/conf"
+	account "go-common/app/service/main/account/model"
+	accrpc "go-common/app/service/main/account/rpc/client"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+const (
+	_addVIPURL = "/x/internal/big/useBatchInfo"
+)
+
+// Dao account dao
+type Dao struct {
+	client *httpx.Client
+	// account rpc
+	accRPC *accrpc.Service3
+	// url
+	addVIPURL string
+}
+
+// New account dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+		// account rpc
+		accRPC: accrpc.New3(c.AccountRPC),
+		// url
+		addVIPURL: c.Host.APICo + _addVIPURL,
+	}
+	return
+}
+
+// AddVIP add user vip
+func (d *Dao) AddVIP(c context.Context, mid, orderNo int64, batchID int, remark string) (msg string, err error) {
+	params := url.Values{}
+	params.Set("orderNo", strconv.FormatInt(orderNo, 10))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("remark", remark)
+	params.Set("batchId", strconv.Itoa(batchID))
+	var res struct {
+		Code int    `json:"code"`
+		Msg  string `json:"message"`
+	}
+	if err = d.client.Post(c, d.addVIPURL, "", params, &res); err != nil {
+		log.Error("account add vip url(%v) error(%v)", d.addVIPURL+"?"+params.Encode(), err)
+		return
+	}
+	msg = res.Msg
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("account add vip url(%v) res code(%d)", d.addVIPURL+"?"+params.Encode(), res.Code)
+		return
+	}
+	return
+}
+
+// Info user info
+func (d *Dao) Info(ctx context.Context, mid int64) (res *account.Info, err error) {
+	arg := &account.ArgMid{
+		Mid: mid,
+	}
+	if res, err = d.accRPC.Info3(ctx, arg); err != nil {
+		log.Error("d.accRPC.Info3(%v) error(%v)", arg, err)
+		return
+	}
+	return
+}

app/interface/main/app-wall/dao/account/account_test.go

@@ -0,0 +1,60 @@
+package account
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	account "go-common/app/service/main/account/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-wall")
+		flag.Set("conf_token", "yvxLjLpTFMlbBbc9yWqysKLMigRHaaiJ")
+		flag.Set("tree_id", "2283")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestAddVIP(t *testing.T) {
+	Convey("unicom AddVIP", t, func() {
+		_, err := d.AddVIP(ctx(), 1, 1, 1, "")
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestInfo(t *testing.T) {
+	Convey("unicom Info", t, func() {
+		res, err := d.Info(ctx(), 1)
+		err = nil
+		res = &account.Info{}
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-wall/dao/callback/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["callback_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 = ["callback.go"],
+    importpath = "go-common/app/interface/main/app-wall/dao/callback",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/interface/main/app-wall/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-wall/dao/callback/callback.go

@@ -0,0 +1,131 @@
+package callback
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/app/interface/main/app-wall/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_iis = "/iis?clkid=%s"
+)
+
+type Dao struct {
+	client *httpx.Client
+	iisURL string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(conf.Conf.HTTPActive),
+		iisURL: c.Host.Dotin + _iis,
+	}
+	return
+}
+
+func (d *Dao) GdtCallback(c context.Context, appID, appType, aderID string, idfa, cb string, now time.Time) (err error) {
+	key, ok := model.ChannelGdt[aderID]
+	if !ok {
+		return
+	}
+	encrypt := []byte(key.Encrypt)
+	signKey := key.Sign
+	uri := fmt.Sprintf("http://t.gdt.qq.com/conv/app/%s/conv?", appID)
+	// sign v
+	queryS := fmt.Sprintf("muid=%s&conv_time=%d&click_id=%s", idfa, now.Unix(), cb)
+	page := signKey + "&GET&" + url.QueryEscape(uri+queryS)
+	bs := md5.Sum([]byte(page))
+	sign := hex.EncodeToString(bs[:])
+	queryS = queryS + "&sign=" + sign
+	queryBs := []byte(queryS)
+	i := 0
+	bss := []byte{}
+	for _, b := range queryBs {
+		bss = append(bss, b^encrypt[i])
+		i = i + 1
+		i = i % len(encrypt)
+	}
+	baseS := base64.StdEncoding.EncodeToString(bss)
+	baseS = strings.Replace(baseS, "\n", "", -1)
+	// finish uri
+	furi := uri + "v=" + url.QueryEscape(baseS) + fmt.Sprintf("&conv_type=MOBILEAPP_ACTIVITE&app_type=%s&advertiser_id=%s", appType, aderID)
+	var res struct {
+		Ret int    `json:"ret"`
+		Msg string `json:"msg"`
+	}
+	for i := 0; i < 5; i++ {
+		if err = d.client.Get(c, furi, "", nil, &res); err == nil {
+			break
+		}
+	}
+	if err != nil {
+		return
+	}
+	if !ecode.Int(res.Ret).Equal(ecode.OK) {
+		err = errors.Wrapf(ecode.Int(res.Ret), furi)
+		if res.Ret == -1 {
+			log.Error("%+v", err)
+			err = nil
+		}
+		return
+	}
+	log.Info("callback gdt furi(%s) idfa(%s) cb(%s) success ret(%d) msg(%s)", furi, idfa, cb, res.Ret, res.Msg)
+	return
+}
+
+func (d *Dao) ShikeCallback(c context.Context, idfa, cb string, now time.Time) (err error) {
+	var res struct {
+		Success string `json:"success"`
+		Message string `json:"message"`
+	}
+	if err = d.client.Get(c, cb, "", nil, &res); err != nil {
+		return
+	}
+	log.Info("callback shike idfa(%s) cb(%s) success ret(%s) msg(%s)", idfa, cb, res.Success, res.Message)
+	return
+}
+
+func (d *Dao) DontinCallback(c context.Context, idfa, clickid string) (err error) {
+	urlStr := fmt.Sprintf(d.iisURL, clickid)
+	if err = d.client.Get(c, urlStr, "", nil, nil); err != nil {
+		return
+	}
+	log.Info("callback dontin idfa(%s) clickid(%s) success", idfa, clickid)
+	return
+}
+
+func (d *Dao) ToutiaoCallback(c context.Context, cb string, eventType string) (err error) {
+	if cb == "" {
+		return
+	}
+	cbURL := strings.TrimSpace(cb + "&event_type=" + eventType)
+	var res struct {
+		Ret int `json:"ret"`
+	}
+	if err = d.client.Get(c, cbURL, "", nil, &res); err != nil {
+		return
+	}
+	if !ecode.Int(res.Ret).Equal(ecode.OK) {
+		err = errors.Wrap(ecode.Int(res.Ret), cbURL)
+		if res.Ret == -1 {
+			log.Error("%+v", err)
+			err = nil
+		}
+		return
+	}
+	log.Info("callback toutiao cb(%s) eventType(%s) success", cb, eventType)
+	return
+}

app/interface/main/app-wall/dao/callback/callback_test.go

@@ -0,0 +1,133 @@
+package callback
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotD := New(tt.args.c)
+			So(gotD, ShouldResemble, tt.wantD)
+		})
+	}
+}
+
+func TestDao_GdtCallback(t *testing.T) {
+	type args struct {
+		c       context.Context
+		appID   string
+		appType string
+		aderID  string
+		idfa    string
+		cb      string
+		now     time.Time
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			err := d.GdtCallback(tt.args.c, tt.args.appID, tt.args.appType, tt.args.aderID, tt.args.idfa, tt.args.cb, tt.args.now)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_ShikeCallback(t *testing.T) {
+	type args struct {
+		c    context.Context
+		idfa string
+		cb   string
+		now  time.Time
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			err := d.ShikeCallback(tt.args.c, tt.args.idfa, tt.args.cb, tt.args.now)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_DontinCallback(t *testing.T) {
+	type args struct {
+		c       context.Context
+		idfa    string
+		clickid string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			err := d.DontinCallback(tt.args.c, tt.args.idfa, tt.args.clickid)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_ToutiaoCallback(t *testing.T) {
+	type args struct {
+		c         context.Context
+		cb        string
+		eventType string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			err := d.ToutiaoCallback(tt.args.c, tt.args.cb, tt.args.eventType)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}

app/interface/main/app-wall/dao/live/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["live_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 = ["live.go"],
+    importpath = "go-common/app/interface/main/app-wall/dao/live",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/dao/live/live.go

@@ -0,0 +1,94 @@
+package live
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+const (
+	_liveURL   = "/gift/simGift"
+	_addVipURL = "/user/v0/Vip/addVip"
+)
+
+// Dao is live dao
+type Dao struct {
+	client    *httpx.Client
+	liveURL   string
+	addVipURL string
+}
+
+// New live dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:    httpx.NewClient(c.HTTPClient),
+		liveURL:   c.Host.Live + _liveURL,
+		addVipURL: c.Host.APILive + _addVipURL,
+	}
+	return
+}
+
+// Pack
+func (d *Dao) Pack(c context.Context, mid int64, cardType int) (err error) {
+	var res struct {
+		Code int `json:"code"`
+	}
+	upack := map[string]map[string]interface{}{
+		"header": map[string]interface{}{},
+		"body": map[string]interface{}{
+			"uid":       mid,
+			"card_type": cardType,
+		},
+	}
+	bytesData, err := json.Marshal(upack)
+	if err != nil {
+		log.Error("json.Marshal error(%v)", err)
+		return
+	}
+	req, err := http.NewRequest("POST", d.liveURL, bytes.NewReader(bytesData))
+	if err != nil {
+		log.Error("http.NewRequest error(%v)", err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
+	req.Header.Set("X-BACKEND-BILI-REAL-IP", "")
+	log.Info("unicom pack mid(%d) card_type(%d)", mid, cardType)
+	if err = d.client.Do(c, req, &res); err != nil || res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("unicom pack d.client.Do(%s) mid(%d) card_type(%d) error(%v)", d.liveURL, mid, cardType, err)
+		return
+	}
+	return
+}
+
+// AddVip add live vip
+func (d *Dao) AddVip(c context.Context, mid int64, day int) (msg string, err error) {
+	params := url.Values{}
+	params.Set("vip_type", "1")
+	params.Set("day", strconv.Itoa(day))
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	params.Set("platform", "main")
+	var res struct {
+		Code int    `json:"code"`
+		Msg  string `json:"message"`
+	}
+	if err = d.client.Post(c, d.addVipURL, "", params, &res); err != nil {
+		log.Error("live add vip url(%v) error(%v)", d.addVipURL+"?"+params.Encode(), err)
+		return
+	}
+	msg = res.Msg
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("live add vip url(%v) res code(%d)", d.addVipURL+"?"+params.Encode(), res.Code)
+		return
+	}
+	return
+}

app/interface/main/app-wall/dao/live/live_test.go

@@ -0,0 +1,43 @@
+package live
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestPack(t *testing.T) {
+	Convey("Pack", t, func() {
+		err := d.Pack(ctx(), 1, 1)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestAddVip(t *testing.T) {
+	Convey("AddVip", t, func() {
+		_, err := d.AddVip(ctx(), 1, 1)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-wall/dao/mobile/BUILD

@@ -0,0 +1,52 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["mobile_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/interface/main/app-wall/model/mobile:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cache.go",
+        "mobile.go",
+    ],
+    importpath = "go-common/app/interface/main/app-wall/dao/mobile",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/interface/main/app-wall/model/mobile:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log: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/dao/mobile/cache.go

@@ -0,0 +1,133 @@
+package mobile
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-wall/model/mobile"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_prefix = "mobiles_user_%v"
+)
+
+func keyMobile(usermob string) string {
+	return fmt.Sprintf(_prefix, usermob)
+}
+
+// AddMobileCache
+func (d *Dao) AddMobileCache(c context.Context, usermob string, m []*mobile.Mobile) (err error) {
+	var (
+		key  = keyMobile(usermob)
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: m, Flags: memcache.FlagJSON, Expiration: d.expire}); err != nil {
+		log.Error("addMobileCache d.mc.Set(%s,%v) error(%v)", key, m, err)
+	}
+	conn.Close()
+	return
+}
+
+// MobileCache
+func (d *Dao) MobileCache(c context.Context, usermob string) (m []*mobile.Mobile, err error) {
+	var (
+		key  = keyMobile(usermob)
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("mobileCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &m); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}
+
+// DeleteMobileCache
+func (d *Dao) DeleteMobileCache(c context.Context, usermob string) (err error) {
+	var (
+		key  = keyMobile(usermob)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("mobileCache MemchDB.Delete(%s) error(%v)", key, err)
+		return
+	}
+	return
+}
+
+// UpdateMobileCache
+func (d *Dao) UpdateMobileCache(c context.Context, usermob string, m *mobile.Mobile) (err error) {
+	var (
+		ms         []*mobile.Mobile
+		mobiles    []*mobile.Mobile
+		uproductid = map[string]struct{}{}
+	)
+	if ms, err = d.MobileCache(c, usermob); err != nil && len(ms) > 0 {
+		log.Error("d.MobileCache error(%v)", err)
+		return
+	}
+	if len(ms) > 0 {
+		for _, ml := range ms {
+			tmp := &mobile.Mobile{}
+			*tmp = *ml
+			if tmp.Productid == m.Productid {
+				tmp = m
+				if m.Threshold == 0 {
+					tmp.Threshold = ml.Threshold
+				}
+				uproductid[m.Productid] = struct{}{}
+			}
+			mobiles = append(mobiles, tmp)
+		}
+		if _, ok := uproductid[m.Productid]; !ok {
+			mobiles = append(mobiles, m)
+		}
+		if err = d.AddMobileCache(c, usermob, mobiles); err != nil {
+			log.Error("d.AddMobileCache error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// UpdateMobileFlowCache
+func (d *Dao) UpdateMobileFlowCache(c context.Context, usermob string, m *mobile.Mobile) (err error) {
+	var (
+		ms      []*mobile.Mobile
+		mobiles []*mobile.Mobile
+	)
+	if ms, err = d.MobileCache(c, usermob); err != nil && len(ms) > 0 {
+		log.Error("d.MobileCache error(%v)", err)
+		return
+	}
+	if len(ms) > 0 {
+		for _, ml := range ms {
+			tmp := &mobile.Mobile{}
+			*tmp = *ml
+			if tmp.Productid == m.Productid {
+				tmp.Threshold = m.Threshold
+			}
+			mobiles = append(mobiles, tmp)
+		}
+		if err = d.AddMobileCache(c, usermob, mobiles); err != nil {
+			log.Error("d.AddMobileCache error(%v)", err)
+			return
+		}
+	}
+	return
+}

app/interface/main/app-wall/dao/mobile/mobile.go

@@ -0,0 +1,102 @@
+package mobile
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/app/interface/main/app-wall/model/mobile"
+	"go-common/library/cache/memcache"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_inOrderSyncSQL = `INSERT IGNORE INTO mobile_order (orderid,userpseudocode,channelseqid,price,actiontime,actionid,effectivetime,expiretime,channelid,productid,ordertype,threshold)
+	VALUES(?,?,?,?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE orderid=?,channelseqid=?,price=?,actiontime=?,actionid=?,effectivetime=?,expiretime=?,channelid=?,productid=?,ordertype=?,threshold=?`
+	_upOrderFlowSQL     = `UPDATE mobile_order SET threshold=?,resulttime=? WHERE userpseudocode=? AND productid=?`
+	_orderSyncByUserSQL = `SELECT orderid,userpseudocode,channelseqid,price,actionid,effectivetime,expiretime,channelid,productid,ordertype,threshold FROM mobile_order WHERE effectivetime<? AND userpseudocode=?`
+)
+
+type Dao struct {
+	db               *xsql.DB
+	inOrderSyncSQL   *xsql.Stmt
+	upOrderFlowSQL   *xsql.Stmt
+	orderUserSyncSQL *xsql.Stmt
+	// memcache
+	mc     *memcache.Pool
+	expire int32
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+		// memcache
+		mc:     memcache.NewPool(c.Memcache.Operator.Config),
+		expire: int32(time.Duration(c.Memcache.Operator.Expire) / time.Second),
+	}
+	d.inOrderSyncSQL = d.db.Prepared(_inOrderSyncSQL)
+	d.upOrderFlowSQL = d.db.Prepared(_upOrderFlowSQL)
+	d.orderUserSyncSQL = d.db.Prepared(_orderSyncByUserSQL)
+	return
+}
+
+func (d *Dao) InOrdersSync(ctx context.Context, u *mobile.MobileXML) (row int64, err error) {
+	res, err := d.inOrderSyncSQL.Exec(ctx, u.Orderid, u.Userpseudocode, u.Channelseqid, u.Price, u.Actiontime, u.Actionid, u.Effectivetime, u.Expiretime,
+		u.Channelid, u.Productid, u.Ordertype, u.Threshold,
+		u.Orderid, u.Channelseqid, u.Price, u.Actiontime, u.Actionid, u.Effectivetime, u.Expiretime,
+		u.Channelid, u.Productid, u.Ordertype, u.Threshold)
+	if err != nil {
+		log.Error("d.inOrderSyncSQL.Exec error(%v)", err)
+		return
+	}
+	tmp := &mobile.Mobile{}
+	tmp.MobileXMLMobile(u)
+	if err = d.UpdateMobileCache(ctx, u.Userpseudocode, tmp); err != nil {
+		log.Error("mobile d.UpdateMobileCache usermob(%v) error(%v)", u.Userpseudocode, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// FlowSync update OrdersSync
+func (d *Dao) FlowSync(ctx context.Context, u *mobile.MobileXML) (row int64, err error) {
+	res, err := d.upOrderFlowSQL.Exec(ctx, u.Threshold, u.Resulttime, u.Userpseudocode, u.Productid)
+	if err != nil {
+		log.Error("d.upOrderFlowSQL.Exec error(%v)", err)
+		return
+	}
+	thresholdInt, _ := strconv.Atoi(u.Threshold)
+	tmp := &mobile.Mobile{
+		Threshold: thresholdInt,
+		Productid: u.Productid,
+	}
+	if err = d.UpdateMobileFlowCache(ctx, u.Userpseudocode, tmp); err != nil {
+		log.Error("mobile d.UpdateMobileFlowCache usermob(%v) error(%v)", u.Userpseudocode, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// OrdersUserFlow select user OrdersSync
+func (d *Dao) OrdersUserFlow(ctx context.Context, usermob string, now time.Time) (res map[string][]*mobile.Mobile, err error) {
+	rows, err := d.orderUserSyncSQL.Query(ctx, now, usermob)
+	if err != nil {
+		log.Error("query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = map[string][]*mobile.Mobile{}
+	for rows.Next() {
+		u := &mobile.Mobile{}
+		if err = rows.Scan(&u.Orderid, &u.Userpseudocode, &u.Channelseqid, &u.Price, &u.Actionid, &u.Effectivetime, &u.Expiretime,
+			&u.Channelid, &u.Productid, &u.Ordertype, &u.Threshold); err != nil {
+			log.Error("Mobile OrdersUserFlow rows.Scan err (%v)", err)
+			return
+		}
+		u.MobileChange()
+		res[u.Userpseudocode] = append(res[u.Userpseudocode], u)
+	}
+	return
+}

app/interface/main/app-wall/dao/mobile/mobile_test.go

@@ -0,0 +1,62 @@
+package mobile
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/app/interface/main/app-wall/model/mobile"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestInOrdersSync(t *testing.T) {
+	Convey("unicom InOrdersSync", t, func() {
+		res, err := d.InOrdersSync(ctx(), &mobile.MobileXML{})
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestFlowSync(t *testing.T) {
+	Convey("unicom FlowSync", t, func() {
+		res, err := d.FlowSync(ctx(), &mobile.MobileXML{})
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestOrdersUserFlow(t *testing.T) {
+	Convey("unicom OrdersUserFlow", t, func() {
+		res, err := d.OrdersUserFlow(ctx(), "", time.Now())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestMobileCache(t *testing.T) {
+	Convey("unicom MobileCache", t, func() {
+		res, err := d.MobileCache(ctx(), "")
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}

app/interface/main/app-wall/dao/offer/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["offer_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 = ["offer.go"],
+    importpath = "go-common/app/interface/main/app-wall/dao/offer",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log: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/dao/offer/offer.go

@@ -0,0 +1,204 @@
+package offer
+
+import (
+	"context"
+	"database/sql"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	//offer
+	_inClkSQL     = "INSERT IGNORE INTO wall_click (ip,cid,mac,idfa,cb,ctime,mtime) VALUES(?,?,?,?,?,?,?)"
+	_inActSQL     = "INSERT IGNORE INTO wall_active (ip,mid,rmac,mac,idfa,device,ctime,mtime) VALUES(?,?,?,?,?,?,?,?)"
+	_upActIdfaSQL = "UPDATE wall_click SET idfa_active=?,mtime=? WHERE idfa=?"
+	_cbSQL        = "SELECT cid,cb FROM wall_click WHERE (idfa=? OR idfa=?) and ctime>? and ctime<? ORDER BY id DESC LIMIT 1"
+	_rMacCntSQL   = "SELECT COUNT(*) FROM wall_active WHERE rmac=?"
+	_idfaSQL      = "SELECT id FROM wall_active WHERE idfa=?"
+	_inANClkSQL   = "INSERT IGNORE INTO `wall_click_an` (`channel`,`imei`,`androidid`,`mac`,`ip`,`cb`,`ctime`,`mtime`) VALUES (?,?,?,?,?,?,?,?)"
+	_anActiveSQL  = "SELECT COUNT(*) FROM `wall_click_an` WHERE `type`=1 AND ((`androidid`=? AND `androidid`<>'') OR ((`imei`=? OR `imei`=?) AND `imei`<>''))"
+	_anCbSQL      = "SELECT `id`,`channel`,`cb`,`type` FROM `wall_click_an` WHERE (`androidid`=? AND `androidid`<>'') OR (`imei`=? AND `imei`<>'') ORDER BY `id` DESC LIMIT 1"
+	_anGdtCbSQL   = "SELECT `id`,`channel`,`cb`,`type` FROM `wall_click_an` WHERE `imei`=? ORDER BY `id` DESC LIMIT 1"
+	_upClkActSQL  = "UPDATE `wall_click_an` SET `type`=? WHERE `id`=?"
+)
+
+// Dao is wall dao.
+type Dao struct {
+	db           *xsql.DB
+	inClkSQL     *xsql.Stmt
+	inActSQL     *xsql.Stmt
+	upActIdfaSQL *xsql.Stmt
+	cbSQL        *xsql.Stmt
+	rMacCntSQL   *xsql.Stmt
+	idfaSQL      *xsql.Stmt
+	// android
+	inANClkSQL  *xsql.Stmt
+	anActiveSQL *xsql.Stmt
+	anCbSQL     *xsql.Stmt
+	anGdtCbSQL  *xsql.Stmt
+	upClkActSQL *xsql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+	}
+	d.inClkSQL = d.db.Prepared(_inClkSQL)
+	d.inActSQL = d.db.Prepared(_inActSQL)
+	d.upActIdfaSQL = d.db.Prepared(_upActIdfaSQL)
+	d.cbSQL = d.db.Prepared(_cbSQL)
+	d.rMacCntSQL = d.db.Prepared(_rMacCntSQL)
+	d.idfaSQL = d.db.Prepared(_idfaSQL)
+	// android
+	d.inANClkSQL = d.db.Prepared(_inANClkSQL)
+	d.anActiveSQL = d.db.Prepared(_anActiveSQL)
+	d.anCbSQL = d.db.Prepared(_anCbSQL)
+	d.anGdtCbSQL = d.db.Prepared(_anGdtCbSQL)
+	d.upClkActSQL = d.db.Prepared(_upClkActSQL)
+	return
+}
+
+func (d *Dao) InClick(ctx context.Context, ip uint32, cid, mac, idfa, cb string, now time.Time) (row int64, err error) {
+	res, err := d.inClkSQL.Exec(ctx, ip, cid, mac, idfa, cb, now, now)
+	if err != nil {
+		log.Error("tx.Exec error(%v)", err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+func (d *Dao) InActive(ctx context.Context, ip uint32, mid, rmac, mac, idfa, device string, now time.Time) (row int64, err error) {
+	res, err := d.inActSQL.Exec(ctx, ip, mid, rmac, mac, idfa, device, now, now)
+	if err != nil {
+		log.Error("tx.Exec error(%v)", err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+func (d *Dao) UpIdfaActive(ctx context.Context, idfaAct, idfa string, now time.Time) (row int64, err error) {
+	res, err := d.upActIdfaSQL.Exec(ctx, idfaAct, now, idfa)
+	if err != nil {
+		log.Error("tx.Exec error(%v)", err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+func (d *Dao) Callback(ctx context.Context, idfa, gdtIdfa string, now time.Time) (cid, cb string, err error) {
+	lo := now.AddDate(0, 0, -1)
+	row := d.cbSQL.QueryRow(ctx, idfa, gdtIdfa, lo, now)
+	if row == nil {
+		log.Error("d.cbSQL.QueryRow is null")
+		return
+	}
+	if err = row.Scan(&cid, &cb); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("Callback row.Scan error(%v)", err)
+		}
+		return
+	}
+	return
+}
+
+func (d *Dao) RMacCount(ctx context.Context, rmac string) (count int, err error) {
+	row := d.rMacCntSQL.QueryRow(ctx, rmac)
+	if row == nil {
+		log.Error("d.rMacCntSQL.QueryRow is null")
+		return
+	}
+	if err = row.Scan(&count); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("RMacCount row.Scan error(%v)", err)
+		}
+		return
+	}
+	return
+}
+
+func (d *Dao) Exists(ctx context.Context, idfa string) (exist bool, err error) {
+	row := d.idfaSQL.QueryRow(ctx, idfa)
+	var id int
+	if row == nil {
+		log.Error("d.idfaSQL.QueryRow is null")
+		return
+	}
+	if err = row.Scan(&id); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("RMacCount row.Scan error(%v)", err)
+		}
+		return
+	}
+	exist = id > 0
+	return
+}
+
+func (d *Dao) InANClick(c context.Context, channel, imei, androidid, mac, cb string, ip uint32, now time.Time) (row int64, err error) {
+	res, err := d.inANClkSQL.Exec(c, channel, imei, androidid, mac, ip, cb, now, now)
+	if err != nil {
+		return
+	}
+	return res.RowsAffected()
+}
+
+func (d *Dao) ANActive(c context.Context, androidid, imei, gdtImei string) (count int, err error) {
+	row := d.anActiveSQL.QueryRow(c, androidid, imei, gdtImei)
+	if row == nil {
+		return
+	}
+	if err = row.Scan(&count); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		}
+	}
+	return
+}
+
+func (d *Dao) ANCallback(c context.Context, androidid, imei, gdtImei string) (id int64, channel, cb string, typ int, err error) {
+	row := d.anCbSQL.QueryRow(c, androidid, imei)
+	if err = row.Scan(&id, &channel, &cb, &typ); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			return
+		}
+	}
+	if gdtImei != "" {
+		var (
+			gdtID             int64
+			gdtChannel, gdtCb string
+			gdtTyp            int
+		)
+		row := d.anGdtCbSQL.QueryRow(c, gdtImei)
+		if err = row.Scan(&gdtID, &gdtChannel, &gdtCb, &gdtTyp); err != nil {
+			if err == sql.ErrNoRows {
+				err = nil
+			}
+			return
+		}
+		if gdtID > id {
+			id = gdtID
+			channel = gdtChannel
+			cb = gdtCb
+			typ = gdtTyp
+		}
+	}
+	return
+}
+
+func (d *Dao) ANClickAct(c context.Context, id int64, typ int) (row int64, err error) {
+	res, err := d.upClkActSQL.Exec(c, typ, id)
+	if err != nil {
+		return
+	}
+	return res.RowsAffected()
+}

app/interface/main/app-wall/dao/offer/offer_test.go

@@ -0,0 +1,78 @@
+package offer
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestUpIdfaActive(t *testing.T) {
+	Convey("UpIdfaActive", t, func() {
+		_, err := d.UpIdfaActive(ctx(), "", "", time.Now())
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestCallback(t *testing.T) {
+	Convey("Callback", t, func() {
+		_, _, err := d.Callback(ctx(), "", "", time.Now())
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestRMacCount(t *testing.T) {
+	Convey("RMacCount", t, func() {
+		_, err := d.RMacCount(ctx(), "")
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestExists(t *testing.T) {
+	Convey("RMacCount", t, func() {
+		_, err := d.RMacCount(ctx(), "")
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestInANClick(t *testing.T) {
+	Convey("InANClick", t, func() {
+		_, err := d.InANClick(ctx(), "", "", "", "", "", 11, time.Now())
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestANActive(t *testing.T) {
+	Convey("ANActive", t, func() {
+		_, err := d.ANActive(ctx(), "", "", "")
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestANCallback(t *testing.T) {
+	Convey("ANCallback", t, func() {
+		_, _, _, _, err := d.ANCallback(ctx(), "", "", "")
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-wall/dao/padding/BUILD

@@ -0,0 +1,38 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["padding_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = ["//vendor/github.com/smartystreets/goconvey/convey:go_default_library"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["padding.go"],
+    importpath = "go-common/app/interface/main/app-wall/dao/padding",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+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/dao/padding/padding.go

@@ -0,0 +1,39 @@
+package padding
+
+import "errors"
+
+var (
+	ErrPaddingSize = errors.New("pkcs5 padding size error")
+	PKCS5          = &pkcs5{}
+)
+
+// pkcs5Padding is a pkcs5 padding struct.
+type pkcs5 struct{}
+
+// Padding is interface used for crypto.
+type Padding interface {
+	Padding(src []byte, blockSize int) []byte
+	Unpadding(src []byte, blockSize int) ([]byte, error)
+}
+
+// Padding implements the Padding interface Padding method.
+func (p *pkcs5) Padding(src []byte, blockSize int) []byte {
+	srcLen := len(src)
+	padLen := byte(blockSize - (srcLen % blockSize))
+	pd := make([]byte, srcLen+int(padLen))
+	copy(pd, src)
+	for i := srcLen; i < len(pd); i++ {
+		pd[i] = padLen
+	}
+	return pd
+}
+
+// Unpadding implements the Padding interface Unpadding method.
+func (p *pkcs5) Unpadding(src []byte, blockSize int) ([]byte, error) {
+	srcLen := len(src)
+	paddingLen := int(src[srcLen-1])
+	if paddingLen >= srcLen || paddingLen > blockSize {
+		return nil, ErrPaddingSize
+	}
+	return src[:srcLen-paddingLen], nil
+}

app/interface/main/app-wall/dao/padding/padding_test.go

@@ -0,0 +1,24 @@
+package padding
+
+import (
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	p *pkcs5
+)
+
+func init() {
+	p = &pkcs5{}
+	time.Sleep(time.Second)
+}
+
+func TestPadding(t *testing.T) {
+	Convey("Padding", t, func() {
+		res := p.Padding([]byte{}, 1)
+		So(res, ShouldNotBeEmpty)
+	})
+}

app/interface/main/app-wall/dao/seq/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["seq_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 = ["seq.go"],
+    importpath = "go-common/app/interface/main/app-wall/dao/seq",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/service/main/seq-server/model:go_default_library",
+        "//app/service/main/seq-server/rpc/client:go_default_library",
+        "//library/log: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/dao/seq/seq.go

@@ -0,0 +1,40 @@
+package seq
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-wall/conf"
+	seq "go-common/app/service/main/seq-server/model"
+	seqrpc "go-common/app/service/main/seq-server/rpc/client"
+	"go-common/library/log"
+)
+
+type Dao struct {
+	c          *conf.Config
+	seqRPC     *seqrpc.Service2
+	businessID int64
+	token      string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:          c,
+		seqRPC:     seqrpc.New2(c.SeqRPC),
+		businessID: c.Seq.BusinessID,
+		token:      c.Seq.Token,
+	}
+	return
+}
+
+// SeqID
+func (d *Dao) SeqID(ctx context.Context) (requestNo int64, err error) {
+	arg := &seq.ArgBusiness{
+		BusinessID: d.businessID,
+		Token:      d.token,
+	}
+	if requestNo, err = d.seqRPC.ID(ctx, arg); err != nil {
+		log.Error("d.seqRPC.ID error (%v)", err)
+		return
+	}
+	return
+}

app/interface/main/app-wall/dao/seq/seq_test.go

@@ -0,0 +1,37 @@
+package seq
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestSeqID(t *testing.T) {
+	Convey("SeqID", t, func() {
+		res, err := d.SeqID(ctx())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-wall/dao/shopping/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["shopping_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 = ["shopping.go"],
+    importpath = "go-common/app/interface/main/app-wall/dao/shopping",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/dao/shopping/shopping.go

@@ -0,0 +1,72 @@
+package shopping
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+const (
+	_couponURL = "/mall-marketing/coupon_code/create"
+)
+
+// Dao is shopping dao
+type Dao struct {
+	client    *httpx.Client
+	couponURL string
+}
+
+// New shopping dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+		// url
+		couponURL: c.Host.Mall + _couponURL,
+	}
+	return
+}
+
+// Coupon user vip
+func (d *Dao) Coupon(c context.Context, couponID string, mid int64, uname string) (msg string, err error) {
+	var res struct {
+		Code int    `json:"code"`
+		Msg  string `json:"message"`
+	}
+	data := map[string]interface{}{
+		"couponId": couponID,
+		"mid":      mid,
+		"uname":    uname,
+	}
+	var (
+		bytesData []byte
+		req       *http.Request
+	)
+	if bytesData, err = json.Marshal(data); err != nil {
+		log.Error("json.Marshal error(%v)", err)
+		return
+	}
+	if req, err = http.NewRequest("POST", d.couponURL, bytes.NewReader(bytesData)); err != nil {
+		log.Error("http.NewRequest error(%v)", err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
+	req.Header.Set("X-BACKEND-BILI-REAL-IP", "")
+	log.Info("coupon vip mid(%d) couponID(%s)", mid, couponID)
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("coupon vip url(%v) error(%v)", d.couponURL, err)
+		return
+	}
+	msg = res.Msg
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("coupon vip url(%v) res code(%d)", d.couponURL, res.Code)
+		return
+	}
+	return
+}

app/interface/main/app-wall/dao/shopping/shopping_test.go

@@ -0,0 +1,36 @@
+package shopping
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestCoupon(t *testing.T) {
+	Convey("Coupon", t, func() {
+		_, err := d.Coupon(ctx(), "", 1, "")
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-wall/dao/telecom/BUILD

@@ -0,0 +1,58 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["telecom_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 = [
+        "api.go",
+        "cache.go",
+        "memcache.go",
+        "sms.go",
+        "telecom.go",
+    ],
+    importpath = "go-common/app/interface/main/app-wall/dao/telecom",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/interface/main/app-wall/model/telecom:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/xxtea/xxtea-go/xxtea: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/dao/telecom/api.go

@@ -0,0 +1,255 @@
+package telecom
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/interface/main/app-wall/model/telecom"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/xxtea/xxtea-go/xxtea"
+)
+
+const (
+	_telecomAppsecret  = "FD9B667503E74DDDBcF28E2327F88EEA"
+	_telecomAppID      = "1000000053"
+	_telecomFormat     = "json"
+	_telecomClientType = "3"
+	_flowPackageID     = 279
+	_payInfo           = "/api/v1/0/getPayInfo.do"
+	_cancelRepeatOrder = "/api/v1/0/cancelRepeatOrder.do"
+	_sucOrderList      = "/api/v1/0/getSucOrderList.do"
+	_phoneArea         = "/api/v1/0/queryOperatorAndProvince.do"
+	_orderState        = "/api/v1/0/queryOrderStatus.do"
+)
+
+// PayInfo
+func (d *Dao) PayInfo(c context.Context, requestNo int64, phone, isRepeatOrder, payChannel, payAction int, orderID int64, ipStr string,
+	beginTime, firstOrderEndtime time.Time) (data *telecom.Pay, err error, msg string) {
+	var payChannelStr string
+	switch payChannel {
+	case 1:
+		payChannelStr = "31"
+		ipStr = ""
+	case 2:
+		payChannelStr = "29"
+	}
+	params := url.Values{}
+	params.Set("requestNo", strconv.FormatInt(requestNo, 10))
+	params.Set("flowPackageId", strconv.Itoa(_flowPackageID))
+	params.Set("contractId", "100174")
+	params.Set("activityId", "101043")
+	params.Set("phoneId", strconv.Itoa(phone))
+	params.Set("bindApps", "tv.danmaku.bilianime|tv.danmaku.bili")
+	params.Set("bindAppNames", "哔哩哔哩|哔哩哔哩")
+	params.Set("isRepeatOrder", strconv.Itoa(isRepeatOrder))
+	params.Set("payChannel", payChannelStr)
+	if ipStr != "" {
+		params.Set("userIp", ipStr)
+	}
+	params.Set("payPageType", "1")
+	if d.telecomReturnURL != "" {
+		params.Set("returnUrl", d.telecomReturnURL)
+	}
+	if d.telecomCancelPayURL != "" {
+		params.Set("cancelPayUrl", d.telecomCancelPayURL)
+	}
+	params.Set("payAction", strconv.Itoa(payAction))
+	// if startTime := beginTime.Format("20060102"); startTime != "19700101" && !beginTime.IsZero() {
+	// 	params.Set("beginTime", startTime)
+	// }
+	// if endTime := firstOrderEndtime.Format("20060102"); endTime != "19700101" && !firstOrderEndtime.IsZero() {
+	// 	params.Set("firstOrderEndtime", endTime)
+	// }
+	if orderID > 0 {
+		params.Set("orderId", strconv.FormatInt(orderID, 10))
+	}
+	var res struct {
+		Code   int `json:"resCode"`
+		Detail struct {
+			OrderID int64 `json:"orderId"`
+			PayInfo struct {
+				PayURL string `json:"payUrl"`
+			} `json:"payInfo"`
+		} `json:"detail"`
+		Msg string `json:"resMsg"`
+	}
+	if err = d.wallHTTPPost(c, d.payInfoURL, params, &res); err != nil {
+		log.Error("telecom_payInfoURL url(%s) error(%v)", d.payInfoURL+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 10000 {
+		err = ecode.Int(res.Code)
+		log.Error("telecom_url(%s) res code(%d) or res.data(%v)", d.payInfoURL+"?"+params.Encode(), res.Code, res.Detail)
+		msg = res.Msg
+		return
+	}
+	data = &telecom.Pay{
+		RequestNo: requestNo,
+		OrderID:   res.Detail.OrderID,
+		PayURL:    res.Detail.PayInfo.PayURL,
+	}
+	return
+}
+
+// wallHTTPPost
+func (d *Dao) wallHTTPPost(c context.Context, urlStr string, params url.Values, res interface{}) (err error) {
+	newParams := url.Values{}
+	encryptData := xxtea.Encrypt([]byte(params.Encode()), []byte(_telecomAppsecret))
+	hexStr := hex.EncodeToString(encryptData)
+	newParams.Set("paras", hexStr)
+	mh := md5.Sum([]byte(_telecomAppID + _telecomClientType + _telecomFormat + hexStr + _telecomAppsecret))
+	newParams.Set("sign", hex.EncodeToString(mh[:]))
+	newParams.Set("appId", _telecomAppID)
+	newParams.Set("clientType", _telecomClientType)
+	newParams.Set("format", _telecomFormat)
+	req, err := http.NewRequest("POST", urlStr, strings.NewReader(newParams.Encode()))
+	if err != nil {
+		log.Error("telecom_http.NewRequest url(%s) error(%v)", urlStr+"?"+newParams.Encode(), err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("X-BACKEND-BILI-REAL-IP", "")
+	return d.client.Do(c, req, &res)
+}
+
+// CancelRepeatOrder
+func (d *Dao) CancelRepeatOrder(c context.Context, phone int, signNo string) (msg string, err error) {
+	params := url.Values{}
+	params.Set("phoneId", strconv.Itoa(phone))
+	params.Set("signNo", signNo)
+	var res struct {
+		Code int    `json:"resCode"`
+		Msg  string `json:"resMsg"`
+	}
+	if err = d.wallHTTPPost(c, d.cancelRepeatOrderURL, params, &res); err != nil {
+		log.Error("telecom_payInfoURL url(%s) error(%v)", d.cancelRepeatOrderURL+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 10000 {
+		err = ecode.Int(res.Code)
+		log.Error("telecom_url(%s) res code(%d)", d.cancelRepeatOrderURL+"?"+params.Encode(), res.Code)
+		msg = res.Msg
+		return
+	}
+	msg = res.Msg
+	return
+}
+
+// SucOrderList user order list
+func (d *Dao) SucOrderList(c context.Context, phone int) (res *telecom.SucOrder, err error, msg string) {
+	params := url.Values{}
+	params.Set("phoneId", strconv.Itoa(phone))
+	var resData struct {
+		Code   int `json:"resCode"`
+		Detail struct {
+			AccessToken string              `json:"accessToken"`
+			Orders      []*telecom.SucOrder `json:"orders"`
+		} `json:"detail"`
+		Msg string `json:"resMsg"`
+	}
+	if err = d.wallHTTPPost(c, d.sucOrderListURL, params, &resData); err != nil {
+		log.Error("telecom_sucOrderListURL url(%s) error(%v)", d.sucOrderListURL+"?"+params.Encode(), err)
+		return
+	}
+	if resData.Code != 10000 {
+		err = ecode.Int(resData.Code)
+		log.Error("telecom_url(%s) res code(%d)", d.sucOrderListURL+"?"+params.Encode(), resData.Code)
+		msg = resData.Msg
+		return
+	}
+	if len(resData.Detail.Orders) == 0 {
+		err = ecode.NothingFound
+		msg = "订单不存在"
+		log.Error("telecom_order list phone(%v) len 0", phone)
+		return
+	}
+	for _, r := range resData.Detail.Orders {
+		if r.FlowPackageID == strconv.Itoa(_flowPackageID) {
+			r.OrderID, _ = strconv.ParseInt(r.OrderIDStr, 10, 64)
+			r.OrderIDStr = ""
+			r.PortInt, _ = strconv.Atoi(r.Port)
+			r.Port = ""
+			res = r
+			res.AccessToken = resData.Detail.AccessToken
+			break
+		}
+	}
+	if res == nil {
+		log.Error("telecom_order bili phone(%v) is null", phone)
+		msg = "订单不存在"
+		err = ecode.NothingFound
+		return
+	}
+	msg = resData.Msg
+	return
+}
+
+// PhoneArea phone by area
+func (d *Dao) PhoneArea(c context.Context, phone int) (area string, err error, msg string) {
+	params := url.Values{}
+	params.Set("phoneId", strconv.Itoa(phone))
+	var resData struct {
+		Code   int `json:"resCode"`
+		Detail struct {
+			RegionCode string `json:"regionCode"`
+			AreaName   string `json:"areaName"`
+		} `json:"detail"`
+		Msg string `json:"resMsg"`
+	}
+	if err = d.wallHTTPPost(c, d.phoneAreaURL, params, &resData); err != nil {
+		log.Error("telecom_phoneAreaURL url(%s) error(%v)", d.phoneAreaURL+"?"+params.Encode(), err)
+		return
+	}
+	if resData.Code != 10000 {
+		err = ecode.Int(resData.Code)
+		log.Error("telecom_url(%s) res code(%d)", d.phoneAreaURL+"?"+params.Encode(), resData.Code)
+		msg = resData.Msg
+		return
+	}
+	area = resData.Detail.RegionCode
+	return
+}
+
+// OrderState
+func (d *Dao) OrderState(c context.Context, orderid int64) (res *telecom.OrderPhoneState, err error) {
+	params := url.Values{}
+	params.Set("orderId", strconv.FormatInt(orderid, 10))
+	var resData struct {
+		Code   int                      `json:"resCode"`
+		Detail *telecom.OrderPhoneState `json:"detail"`
+		Msg    string                   `json:"resMsg"`
+	}
+	if err = d.wallHTTPPost(c, d.orderStateURL, params, &resData); err != nil {
+		log.Error("telecom_orderStateURL url(%s) error(%v)", d.orderStateURL+"?"+params.Encode(), err)
+		return
+	}
+	if resData.Code != 10000 && resData.Code != 10013 {
+		err = ecode.Int(resData.Code)
+		log.Error("telecom_url(%s) res code(%d)", d.orderStateURL+"?"+params.Encode(), resData.Code)
+		return
+	}
+	if resData.Code == 10013 {
+		res = &telecom.OrderPhoneState{
+			OrderState: 6,
+		}
+		return
+	}
+	res = resData.Detail
+	if res.FlowPackageID != _flowPackageID {
+		res.OrderState = 5
+		return
+	}
+	switch resData.Detail.OrderState {
+	case 5:
+		res.OrderState = 6
+	}
+	return
+}

app/interface/main/app-wall/dao/telecom/cache.go

@@ -0,0 +1,73 @@
+package telecom
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/cache/redis"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_phoneKey = "phone_%d"
+	_payKey   = "pay_%d"
+)
+
+// AddPhoneCode
+func (d *Dao) AddPhoneCode(c context.Context, phone int, captcha string) (res int, err error) {
+	conn := d.phoneRds.Get(c)
+	defer conn.Close()
+	key := fmt.Sprintf(_phoneKey, phone)
+	if _, err = redis.String(conn.Do("SET", key, captcha)); err != nil {
+		log.Error("telecom_AddPhoneCode add conn.Do SET error(%v)", err)
+		return
+	}
+	if res, err = redis.Int(conn.Do("EXPIRE", key, d.phoneKeyExpired)); err != nil {
+		log.Error("telecom_AddPhoneCode add conn.Do EXPIRE error(%v)", err)
+		return
+	}
+	return
+}
+
+// PhoneCode
+func (d *Dao) PhoneCode(c context.Context, phone int) (captcha string, err error) {
+	conn := d.phoneRds.Get(c)
+	defer conn.Close()
+	key := fmt.Sprintf(_phoneKey, phone)
+	if captcha, err = redis.String(conn.Do("GET", key)); err != nil {
+		log.Error("telecom_get conn.Do GET error(%v)", err)
+		err = ecode.NotModified
+		return
+	}
+	return
+}
+
+// AddPayPhone add phone and requestNo
+func (d *Dao) AddPayPhone(c context.Context, requestNo int64, phone string) (res int, err error) {
+	conn := d.phoneRds.Get(c)
+	defer conn.Close()
+	key := fmt.Sprintf(_payKey, requestNo)
+	if _, err = redis.String(conn.Do("SET", key, phone)); err != nil {
+		log.Error("telecom_AddPhoneCode add conn.Do SET error(%v)", err)
+		return
+	}
+	if res, err = redis.Int(conn.Do("EXPIRE", key, d.payKeyExpired)); err != nil {
+		log.Error("telecom_AddPhoneCode add conn.Do EXPIRE error(%v)", err)
+		return
+	}
+	return
+}
+
+// PayPhone requestNo by phone
+func (d *Dao) PayPhone(c context.Context, requestNo int64) (phone string, err error) {
+	conn := d.phoneRds.Get(c)
+	defer conn.Close()
+	key := fmt.Sprintf(_payKey, requestNo)
+	if phone, err = redis.String(conn.Do("GET", key)); err != nil {
+		log.Error("telecom_get conn.Do GET requestNo(%v) error(%v)", requestNo, err)
+		err = ecode.NothingFound
+		return
+	}
+	return
+}

app/interface/main/app-wall/dao/telecom/memcache.go

@@ -0,0 +1,93 @@
+package telecom
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-wall/model/telecom"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_prefix     = "telecom_%d"
+	_preorderid = "telecom_orderid_%d"
+)
+
+func keyTelecom(userphone int) string {
+	return fmt.Sprintf(_prefix, userphone)
+}
+
+func keyTelecomOrderID(orderID int64) string {
+	return fmt.Sprintf(_preorderid, orderID)
+}
+
+// AddTelecomCache
+func (d *Dao) AddTelecomCache(c context.Context, userphone int, u *telecom.OrderInfo) (err error) {
+	var (
+		key  = keyTelecom(userphone)
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: u, Flags: memcache.FlagJSON, Expiration: d.expire}); err != nil {
+		log.Error("addTelecomCache d.mc.Set(%s,%v) error(%v)", key, u, err)
+	}
+	conn.Close()
+	return
+}
+
+// TelecomCache
+func (d *Dao) TelecomCache(c context.Context, userphone int) (u *telecom.OrderInfo, err error) {
+	var (
+		key  = keyTelecom(userphone)
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("telecomCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &u); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}
+
+// AddTelecomOrderIDCache
+func (d *Dao) AddTelecomOrderIDCache(c context.Context, orderID int64, u *telecom.OrderInfo) (err error) {
+	var (
+		key  = keyTelecomOrderID(orderID)
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: u, Flags: memcache.FlagJSON, Expiration: d.expire}); err != nil {
+		log.Error("addTelecomCache d.mc.Set(%s,%v) error(%v)", key, u, err)
+	}
+	conn.Close()
+	return
+}
+
+// TelecomOrderIDCache
+func (d *Dao) TelecomOrderIDCache(c context.Context, orderID int64) (u *telecom.OrderInfo, err error) {
+	var (
+		key  = keyTelecomOrderID(orderID)
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("telecomCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &u); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}

app/interface/main/app-wall/dao/telecom/sms.go

@@ -0,0 +1,57 @@
+package telecom
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"go-common/library/log"
+)
+
+const (
+	_smsSendURL = "/x/internal/sms/send"
+)
+
+// SendSMS
+func (d *Dao) SendSMS(c context.Context, phone int, smsTemplate, dataJSON string) (err error) {
+	params := url.Values{}
+	params.Set("mobile", strconv.Itoa(phone))
+	params.Set("country", "086")
+	params.Set("tcode", smsTemplate)
+	params.Set("tparam", dataJSON)
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.smsSendURL, "", params, &res); err != nil {
+		log.Error("SendSMS hots url(%s) error(%v)", d.smsSendURL+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		log.Error("SendSMS hots url(%s) error(%v)", d.smsSendURL+"?"+params.Encode(), res.Code)
+		err = fmt.Errorf("SendSMS api response code(%v)", res)
+		return
+	}
+	return
+}
+
+// SendTelecomSMS
+func (d *Dao) SendTelecomSMS(c context.Context, phone int, smsTemplate string) (err error) {
+	params := url.Values{}
+	params.Set("mobile", strconv.Itoa(phone))
+	params.Set("country", "086")
+	params.Set("tcode", smsTemplate)
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.smsSendURL, "", params, &res); err != nil {
+		log.Error("SendSMS hots url(%s) model(%v) error(%v)", d.smsSendURL+"?"+params.Encode(), smsTemplate, err)
+		return
+	}
+	if res.Code != 0 {
+		log.Error("SendSMS hots url(%s) error(%v)", d.smsSendURL+"?"+params.Encode(), res.Code)
+		err = fmt.Errorf("SendSMS api response code(%v)", res)
+		return
+	}
+	return
+}

app/interface/main/app-wall/dao/telecom/telecom.go

@@ -0,0 +1,165 @@
+package telecom
+
+import (
+	"context"
+	"database/sql"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/app/interface/main/app-wall/model/telecom"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+const (
+	_inOrderSyncSQL = `INSERT IGNORE INTO telecom_order (request_no,result_type,flowpackageid,flowpackagesize,flowpackagetype,trafficattribution,begintime,endtime,
+		ismultiplyorder,settlementtype,operator,order_status,remainedrebindnum,maxbindnum,orderid,sign_no,accesstoken,phoneid,isrepeatorder,paystatus,
+		paytime,paychannel,sign_status,refund_status) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE
+		request_no=?,result_type=?,flowpackagesize=?,flowpackagetype=?,trafficattribution=?,begintime=?,endtime=?,
+		ismultiplyorder=?,settlementtype=?,operator=?,order_status=?,remainedrebindnum=?,maxbindnum=?,orderid=?,sign_no=?,accesstoken=?,
+		isrepeatorder=?,paystatus=?,paytime=?,paychannel=?,sign_status=?,refund_status=?`
+	_inRechargeSyncSQL = `INSERT INTO telecom_recharge (request_no,fcrecharge_no,recharge_status,ordertotalsize,flowbalance) VALUES(?,?,?,?,?)`
+	_orderByPhoneSQL   = `SELECT phoneid,orderid,order_status,sign_no,isrepeatorder,begintime,endtime FROM telecom_order WHERE phoneid=?`
+	_orderByOrderIDSQL = `SELECT phoneid,orderid,order_status,sign_no,isrepeatorder,begintime,endtime FROM telecom_order WHERE orderid=?`
+)
+
+type Dao struct {
+	c                    *conf.Config
+	client               *httpx.Client
+	payInfoURL           string
+	cancelRepeatOrderURL string
+	sucOrderListURL      string
+	telecomReturnURL     string
+	telecomCancelPayURL  string
+	phoneAreaURL         string
+	orderStateURL        string
+	smsSendURL           string
+	phoneKeyExpired      int32
+	payKeyExpired        int32
+	db                   *xsql.DB
+	inOrderSyncSQL       *xsql.Stmt
+	inRechargeSyncSQL    *xsql.Stmt
+	orderByPhoneSQL      *xsql.Stmt
+	orderByOrderIDSQL    *xsql.Stmt
+	phoneRds             *redis.Pool
+	// memcache
+	mc     *memcache.Pool
+	expire int32
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:                    c,
+		client:               httpx.NewClient(conf.Conf.HTTPTelecom),
+		payInfoURL:           c.Host.Telecom + _payInfo,
+		cancelRepeatOrderURL: c.Host.Telecom + _cancelRepeatOrder,
+		sucOrderListURL:      c.Host.Telecom + _sucOrderList,
+		phoneAreaURL:         c.Host.Telecom + _phoneArea,
+		orderStateURL:        c.Host.Telecom + _orderState,
+		telecomReturnURL:     c.Host.TelecomReturnURL,
+		telecomCancelPayURL:  c.Host.TelecomCancelPayURL,
+		smsSendURL:           c.Host.Sms + _smsSendURL,
+		db:                   xsql.NewMySQL(c.MySQL.Show),
+		phoneRds:             redis.NewPool(c.Redis.Recommend.Config),
+		//reids
+		phoneKeyExpired: int32(time.Duration(c.Telecom.KeyExpired) / time.Second),
+		payKeyExpired:   int32(time.Duration(c.Telecom.PayKeyExpired) / time.Second),
+		// memcache
+		mc:     memcache.NewPool(c.Memcache.Operator.Config),
+		expire: int32(time.Duration(c.Memcache.Operator.Expire) / time.Second),
+	}
+	d.inOrderSyncSQL = d.db.Prepared(_inOrderSyncSQL)
+	d.inRechargeSyncSQL = d.db.Prepared(_inRechargeSyncSQL)
+	d.orderByPhoneSQL = d.db.Prepared(_orderByPhoneSQL)
+	d.orderByOrderIDSQL = d.db.Prepared(_orderByOrderIDSQL)
+	return
+}
+
+// InOrderSync
+func (d *Dao) InOrderSync(ctx context.Context, requestNo, resultType int, phone string, t *telecom.TelecomJSON) (row int64, err error) {
+	res, err := d.inOrderSyncSQL.Exec(ctx, requestNo, resultType, t.FlowpackageID, t.FlowPackageSize, t.FlowPackageType, t.TrafficAttribution, t.BeginTime, t.EndTime,
+		t.IsMultiplyOrder, t.SettlementType, t.Operator, t.OrderStatus, t.RemainedRebindNum, t.MaxbindNum, t.OrderID, t.SignNo, t.AccessToken,
+		phone, t.IsRepeatOrder, t.PayStatus, t.PayTime, t.PayChannel, t.SignStatus, t.RefundStatus,
+		requestNo, resultType, t.FlowPackageSize, t.FlowPackageType, t.TrafficAttribution, t.BeginTime, t.EndTime,
+		t.IsMultiplyOrder, t.SettlementType, t.Operator, t.OrderStatus, t.RemainedRebindNum, t.MaxbindNum, t.OrderID,
+		t.SignNo, t.AccessToken, t.IsRepeatOrder, t.PayStatus, t.PayTime, t.PayChannel, t.SignStatus, t.RefundStatus)
+	if err != nil {
+		log.Error("d.inOrderSyncSQL.Exec error(%v)", err)
+		return
+	}
+	tmp := &telecom.OrderInfo{}
+	tmp.OrderInfoJSONChange(t)
+	phoneInt, _ := strconv.Atoi(t.PhoneID)
+	if err = d.AddTelecomCache(ctx, phoneInt, tmp); err != nil {
+		log.Error("s.AddTelecomCache error(%v)", err)
+	}
+	orderID, _ := strconv.ParseInt(t.OrderID, 10, 64)
+	if err = d.AddTelecomOrderIDCache(ctx, orderID, tmp); err != nil {
+		log.Error("s.AddTelecomOrderIDCache error(%v)", err)
+	}
+	return res.RowsAffected()
+}
+
+// InRechargeSync
+func (d *Dao) InRechargeSync(ctx context.Context, r *telecom.RechargeJSON) (row int64, err error) {
+	res, err := d.inRechargeSyncSQL.Exec(ctx, r.RequestNo, r.FcRechargeNo, r.RechargeStatus, r.OrderTotalSize, r.FlowBalance)
+	if err != nil {
+		log.Error("d.inRechargeSyncSQL.Exec error(%v)", err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+func (d *Dao) OrdersUserFlow(ctx context.Context, phoneID int) (res map[int]*telecom.OrderInfo, err error) {
+	res = map[int]*telecom.OrderInfo{}
+	var (
+		PhoneIDStr string
+		OrderIDStr string
+	)
+	t := &telecom.OrderInfo{}
+	row := d.orderByPhoneSQL.QueryRow(ctx, phoneID)
+	if err = row.Scan(&PhoneIDStr, &OrderIDStr, &t.OrderState, &t.SignNo, &t.IsRepeatorder, &t.Begintime, &t.Endtime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("OrdersUserFlow row.Scan err (%v)", err)
+		}
+		return
+	}
+	t.TelecomChange()
+	t.PhoneID, _ = strconv.Atoi(PhoneIDStr)
+	t.OrderID, _ = strconv.ParseInt(OrderIDStr, 10, 64)
+	if t.PhoneID > 0 {
+		res[t.PhoneID] = t
+	}
+	return
+}
+
+func (d *Dao) OrdersUserByOrderID(ctx context.Context, orderID int64) (res map[int64]*telecom.OrderInfo, err error) {
+	res = map[int64]*telecom.OrderInfo{}
+	var (
+		PhoneIDStr string
+		OrderIDStr string
+	)
+	t := &telecom.OrderInfo{}
+	row := d.orderByOrderIDSQL.QueryRow(ctx, orderID)
+	if err = row.Scan(&PhoneIDStr, &OrderIDStr, &t.OrderState, &t.SignNo, &t.IsRepeatorder, &t.Begintime, &t.Endtime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("OrdersUserFlow row.Scan err (%v)", err)
+		}
+		return
+	}
+	t.TelecomChange()
+	t.PhoneID, _ = strconv.Atoi(PhoneIDStr)
+	t.OrderID, _ = strconv.ParseInt(OrderIDStr, 10, 64)
+	if t.OrderID > 0 {
+		res[t.OrderID] = t
+	}
+	return
+}

app/interface/main/app-wall/dao/telecom/telecom_test.go

@@ -0,0 +1,45 @@
+package telecom
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestOrdersUserFlow(t *testing.T) {
+	Convey("OrdersUserFlow", t, func() {
+		res, err := d.OrdersUserFlow(ctx(), 1)
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestOrdersUserByOrderID(t *testing.T) {
+	Convey("OrdersUserByOrderID", t, func() {
+		res, err := d.OrdersUserByOrderID(ctx(), 1)
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,58 @@
+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",
+        "//app/interface/main/app-wall/model/unicom:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "cache.go",
+        "log.go",
+        "unicom.go",
+    ],
+    importpath = "go-common/app/interface/main/app-wall/dao/unicom",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/interface/main/app-wall/model:go_default_library",
+        "//app/interface/main/app-wall/model/unicom:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/elastic:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/dao/unicom/api.go

@@ -0,0 +1,464 @@
+package unicom
+
+import (
+	"bytes"
+	"context"
+	"crypto/des"
+	"crypto/md5"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/interface/main/app-wall/model"
+	"go-common/app/interface/main/app-wall/model/unicom"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+const (
+	_cpid          = "bilibl"
+	_spid          = "979"
+	_apptype       = "2"
+	_broadbandPass = "9ed226d9"
+	// url
+	_orderURL       = "/videoif/order.do"
+	_ordercancelURL = "/videoif/cancelOrder.do"
+	_sendsmscodeURL = "/videoif/sendSmsCode.do"
+	_smsNumberURL   = "/videoif/smsNumber.do"
+	// unicom
+	_unicomIPURL               = "/web/statistics/subsystem_2/query_ip.php"
+	_unicomUser                = "000012"
+	_unicomPass                = "1pibH5e1BN4V"
+	_unicomFlowExchangeURL     = "/openservlet"
+	_unicomAppKey              = "com.aop.app.bilibili"
+	_unicomSecurity            = "DVniSMVU6Z3cCIG3vbOn4Fqbof+QJ/6etD+lpa4M4clgj/Dv6XT0syTR8Xgu5nVzKuzro8eiTUzHy/QAzGjp+A=="
+	_unicomAppMethodFlow       = "com.ssp.method.outflowchange"
+	_unicomMethodNumber        = "com.aop.method.checkusernumber"
+	_unicomMethodFlowPre       = "com.ssp.method.outflowpre"
+	_unicomMethodQryFlowChange = "com.ssp.method.outqryflowchange"
+)
+
+// Order unicom order
+func (d *Dao) Order(c context.Context, usermob, channel string, ordertype int) (data *unicom.BroadbandOrder, msg string, err error) {
+	params := url.Values{}
+	params.Set("cpid", _cpid)
+	params.Set("spid", _spid)
+	params.Set("ordertype", strconv.Itoa(ordertype))
+	params.Set("userid", usermob)
+	params.Set("apptype", _apptype)
+	if channel != "" {
+		params.Set("channel", channel)
+	}
+	var res struct {
+		Code string `json:"resultcode"`
+		Msg  string `json:"errorinfo"`
+		*unicom.BroadbandOrder
+	}
+	if err = d.broadbandHTTPGet(c, d.orderURL, params, &res); err != nil {
+		log.Error("unicom order url(%v) error(%v)", d.orderURL+"?"+params.Encode(), err)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom order url(%v) response(%s)", d.orderURL+"?"+params.Encode(), b)
+	if res.Code != "0" {
+		err = ecode.String(res.Code)
+		msg = res.Msg
+		log.Error("unicom order url(%v) code(%s) Msg(%s)", d.orderURL+"?"+params.Encode(), res.Code, res.Msg)
+		return
+	}
+	data = res.BroadbandOrder
+	return
+}
+
+// CancelOrder unicom cancel order
+func (d *Dao) CancelOrder(c context.Context, usermob string) (data *unicom.BroadbandOrder, msg string, err error) {
+	params := url.Values{}
+	params.Set("cpid", _cpid)
+	params.Set("spid", _spid)
+	params.Set("userid", usermob)
+	params.Set("apptype", _apptype)
+	var res struct {
+		Code string `json:"resultcode"`
+		Msg  string `json:"errorinfo"`
+		*unicom.BroadbandOrder
+	}
+	if err = d.broadbandHTTPGet(c, d.ordercancelURL, params, &res); err != nil {
+		log.Error("unicom cancel order url(%s) error(%v)", d.ordercancelURL+"?"+params.Encode(), err)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom cancel order url(%s) response(%s)", d.ordercancelURL+"?"+params.Encode(), b)
+	if res.Code != "0" {
+		err = ecode.String(res.Code)
+		msg = res.Msg
+		log.Error("unicom cancel order url(%v) code(%s) Msg(%s)", d.orderURL+"?"+params.Encode(), res.Code, res.Msg)
+		return
+	}
+	data = res.BroadbandOrder
+	return
+}
+
+// UnicomIP unicom ip orders
+func (d *Dao) UnicomIP(c context.Context, now time.Time) (unicomIPs []*unicom.UnicomIP, err error) {
+	params := url.Values{}
+	params.Set("user", _unicomUser)
+	tick := strconv.FormatInt(now.Unix(), 10)
+	params.Set("tick", tick)
+	mh := md5.Sum([]byte(_unicomUser + tick + _unicomPass))
+	var (
+		key string
+	)
+	if key = hex.EncodeToString(mh[:]); len(key) > 16 {
+		key = key[:16]
+	}
+	params.Set("key", key)
+	var res struct {
+		Code           int   `json:"code"`
+		LastUpdateTime int64 `json:"last_update_time"`
+		Desc           []struct {
+			StartIP string `json:"start_ip"`
+			Length  string `json:"length"`
+		} `json:"desc"`
+	}
+	if err = d.broadbandHTTPPost(c, d.unicomIPURL, params, &res); err != nil {
+		log.Error("unicom ip order url(%s) error(%v)", d.unicomIPURL+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("unicom ip order url(%s) res code (%d)", d.unicomIPURL+"?"+params.Encode(), res.Code)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom ip url(%s) response(%s)", d.unicomIPURL+"?"+params.Encode(), b)
+	for _, uip := range res.Desc {
+		uiplen, _ := strconv.Atoi(uip.Length)
+		if uiplen < 1 {
+			log.Error("unicom ip length 0")
+			continue
+		}
+		ipEndInt := model.InetAtoN(uip.StartIP) + uint32((uiplen - 1))
+		ipEnd := model.InetNtoA(ipEndInt)
+		unicomIP := &unicom.UnicomIP{}
+		unicomIP.UnicomIPStrToint(uip.StartIP, ipEnd)
+		unicomIPs = append(unicomIPs, unicomIP)
+	}
+	return
+}
+
+// SendSmsCode unicom sms code
+func (d *Dao) SendSmsCode(c context.Context, phone string) (msg string, err error) {
+	var (
+		key       = []byte(_broadbandPass)
+		phoneByte = []byte(phone)
+		userid    string
+	)
+	userid, err = d.desEncrypt(phoneByte, key)
+	if err != nil {
+		log.Error("d.desEncrypt error(%v)", err)
+		return
+	}
+	params := url.Values{}
+	params.Set("cpid", _cpid)
+	params.Set("userid", string(userid))
+	params.Set("apptype", _apptype)
+	var res struct {
+		Code string `json:"resultcode"`
+		Msg  string `json:"errorinfo"`
+	}
+	if err = d.unicomHTTPGet(c, d.sendsmscodeURL, params, &res); err != nil {
+		log.Error("unicom sendsmscode url(%v) error(%v)", d.sendsmscodeURL+"?"+params.Encode(), err)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom sendsmscode url(%v) response(%s)", d.sendsmscodeURL+"?"+params.Encode(), b)
+	if res.Code != "0" {
+		err = ecode.String(res.Code)
+		msg = res.Msg
+		log.Error("unicom sendsmscode url(%v) code(%s) Msg(%s)", d.sendsmscodeURL+"?"+params.Encode(), res.Code, res.Msg)
+		return
+	}
+	return
+}
+
+// SmsNumber unicom sms usermob
+func (d *Dao) SmsNumber(c context.Context, phone string, code int) (usermob string, msg string, err error) {
+	var (
+		key       = []byte(_broadbandPass)
+		phoneByte = []byte(phone)
+		userid    string
+	)
+	userid, err = d.desEncrypt(phoneByte, key)
+	if err != nil {
+		log.Error("d.desEncrypt error(%v)", err)
+		return
+	}
+	params := url.Values{}
+	params.Set("cpid", _cpid)
+	params.Set("userid", userid)
+	params.Set("vcode", strconv.Itoa(code))
+	params.Set("apptype", _apptype)
+	var res struct {
+		Code    string `json:"resultcode"`
+		Usermob string `json:"userid"`
+		Msg     string `json:"errorinfo"`
+	}
+	if err = d.unicomHTTPGet(c, d.smsNumberURL, params, &res); err != nil {
+		log.Error("unicom smsNumberURL url(%v) error(%v)", d.smsNumberURL+"?"+params.Encode(), err)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom sendsmsnumber url(%v) response(%s)", d.smsNumberURL+"?"+params.Encode(), b)
+	if res.Code != "0" {
+		err = ecode.String(res.Code)
+		msg = res.Msg
+		log.Error("unicom sendsmsnumber url(%v) code(%s) Msg(%s)", d.smsNumberURL+"?"+params.Encode(), res.Code, res.Msg)
+		return
+	}
+	usermob = res.Usermob
+	return
+}
+
+// FlowExchange flow exchange
+func (d *Dao) FlowExchange(c context.Context, phone int, flowcode string, requestNo int64, ts time.Time) (orderID, outorderID, msg string, err error) {
+	outorderIDStr := "bili" + ts.Format("20060102") + strconv.FormatInt(requestNo%10000000, 10)
+	if len(outorderIDStr) > 22 {
+		outorderIDStr = outorderIDStr[:22]
+	}
+	param := url.Values{}
+	param.Set("appkey", _unicomAppKey)
+	param.Set("apptx", strconv.FormatInt(requestNo, 10))
+	param.Set("flowexchangecode", flowcode)
+	param.Set("method", _unicomAppMethodFlow)
+	param.Set("outorderid", outorderIDStr)
+	param.Set("timestamp", ts.Format("2006-01-02 15:04:05"))
+	param.Set("usernumber", strconv.Itoa(phone))
+	urlVal := d.urlParams(param)
+	urlVal = urlVal + "&" + d.sign(urlVal)
+	var res struct {
+		Code       string `json:"respcode"`
+		Msg        string `json:"respdesc"`
+		OrderID    string `json:"orderid"`
+		OutorderID string `json:"outorderid"`
+	}
+	if err = d.unicomHTTPGet(c, d.unicomFlowExchangeURL+"?"+urlVal, nil, &res); err != nil {
+		log.Error("unicom flow change url(%v) error(%v)", d.unicomFlowExchangeURL+"?"+urlVal, err)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom flow url(%v) response(%s)", d.unicomFlowExchangeURL+"?"+urlVal, b)
+	msg = res.Msg
+	if res.Code != "0000" {
+		err = ecode.String(res.Code)
+		log.Error("unicom flow change url(%v) code(%v) msg(%v)", d.unicomFlowExchangeURL+"?"+urlVal, res.Code, res.Msg)
+		return
+	}
+	orderID = res.OrderID
+	outorderID = res.OutorderID
+	return
+}
+
+// PhoneVerification unicom phone verification
+func (d *Dao) PhoneVerification(c context.Context, phone string, requestNo int64, ts time.Time) (msg string, err error) {
+	param := url.Values{}
+	param.Set("appkey", _unicomAppKey)
+	param.Set("apptx", strconv.FormatInt(requestNo, 10))
+	param.Set("method", _unicomMethodNumber)
+	param.Set("timestamp", ts.Format("2006-01-02 15:04:05"))
+	param.Set("usernumber", phone)
+	urlVal := d.urlParams(param)
+	urlVal = urlVal + "&" + d.sign(urlVal)
+	var res struct {
+		Code string `json:"respcode"`
+		Msg  string `json:"respdesc"`
+	}
+	if err = d.unicomHTTPGet(c, d.unicomFlowExchangeURL+"?"+urlVal, nil, &res); err != nil {
+		log.Error("unicom phone url(%v) error(%v)", d.unicomFlowExchangeURL+"?"+urlVal, err)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom phone url(%v) response(%s)", d.unicomFlowExchangeURL+"?"+urlVal, b)
+	msg = res.Msg
+	if res.Code != "0000" {
+		err = ecode.String(res.Code)
+		log.Error("unicom phone url(%v) code(%v) msg(%v)", d.unicomFlowExchangeURL+"?"+urlVal, res.Code, res.Msg)
+		return
+	}
+	return
+}
+
+// FlowPre unicom phone flow pre
+func (d *Dao) FlowPre(c context.Context, phone int, requestNo int64, ts time.Time) (msg string, err error) {
+	param := url.Values{}
+	param.Set("appkey", _unicomAppKey)
+	param.Set("apptx", strconv.FormatInt(requestNo, 10))
+	param.Set("method", _unicomMethodFlowPre)
+	param.Set("timestamp", ts.Format("2006-01-02 15:04:05"))
+	param.Set("usernumber", strconv.Itoa(phone))
+	urlVal := d.urlParams(param)
+	urlVal = urlVal + "&" + d.sign(urlVal)
+	var res struct {
+		Code   string `json:"respcode"`
+		Notice string `json:"noticecontent"`
+		Msg    string `json:"respdesc"`
+	}
+	if err = d.unicomHTTPGet(c, d.unicomFlowExchangeURL+"?"+urlVal, nil, &res); err != nil {
+		log.Error("unicom flowpre url(%v) error(%v)", d.unicomFlowExchangeURL+"?"+urlVal, err)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom flowpre url(%v) response(%s)", d.unicomFlowExchangeURL+"?"+urlVal, b)
+	msg = res.Msg
+	if res.Code != "0000" {
+		if res.Code == "0001" {
+			err = ecode.String(res.Code)
+			msg = res.Notice
+		} else {
+			err = ecode.String(res.Code)
+			log.Error("unicom flowpre url(%v) code(%v) msg(%v)", d.unicomFlowExchangeURL+"?"+urlVal, res.Code, res.Msg)
+		}
+		return
+	}
+	return
+}
+
+// FlowQry unicom phone qryflowchange
+func (d *Dao) FlowQry(c context.Context, phone int, requestNo int64, outorderid, orderid string, ts time.Time) (orderstatus, msg string, err error) {
+	param := url.Values{}
+	param.Set("appkey", _unicomAppKey)
+	param.Set("apptx", strconv.FormatInt(requestNo, 10))
+	param.Set("method", _unicomMethodQryFlowChange)
+	param.Set("orderid", orderid)
+	param.Set("outorderid", outorderid)
+	param.Set("timestamp", ts.Format("2006-01-02 15:04:05"))
+	param.Set("usernumber", strconv.Itoa(phone))
+	urlVal := d.urlParams(param)
+	urlVal = urlVal + "&" + d.sign(urlVal)
+	var res struct {
+		Code        string `json:"respcode"`
+		Orderstatus string `json:"orderstatus"`
+		Failurtype  string `json:"failurtype"`
+		Msg         string `json:"respdesc"`
+	}
+	if err = d.unicomHTTPGet(c, d.unicomFlowExchangeURL+"?"+urlVal, nil, &res); err != nil {
+		log.Error("unicom flowQry url(%v) error(%v)", d.unicomFlowExchangeURL+"?"+urlVal, err)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("unicom flowQry url(%v) response(%s)", d.unicomFlowExchangeURL+"?"+urlVal, b)
+	msg = res.Msg
+	if res.Code != "0000" {
+		err = ecode.String(res.Code)
+		log.Error("unicom flowQry url(%v) code(%v) msg(%v)", d.unicomFlowExchangeURL+"?"+urlVal, res.Code, res.Msg)
+		return
+	}
+	orderstatus = res.Orderstatus
+	return
+}
+
+// broadbandHTTPGet http get
+func (d *Dao) broadbandHTTPGet(c context.Context, urlStr string, params url.Values, res interface{}) (err error) {
+	return d.wallHTTP(c, d.client, http.MethodGet, urlStr, params, res)
+}
+
+// broadbandHTTPPost http post
+func (d *Dao) broadbandHTTPPost(c context.Context, urlStr string, params url.Values, res interface{}) (err error) {
+	return d.wallHTTP(c, d.client, http.MethodPost, urlStr, params, res)
+}
+
+// unicomHTTPGet http get
+func (d *Dao) unicomHTTPGet(c context.Context, urlStr string, params url.Values, res interface{}) (err error) {
+	return d.wallHTTP(c, d.uclient, http.MethodGet, urlStr, params, res)
+}
+
+// wallHTTP http
+func (d *Dao) wallHTTP(c context.Context, client *httpx.Client, method, urlStr string, params url.Values, res interface{}) (err error) {
+	var (
+		req *http.Request
+	)
+	ru := urlStr
+	if params != nil {
+		ru = urlStr + "?" + params.Encode()
+	}
+	switch method {
+	case http.MethodGet:
+		req, err = http.NewRequest(http.MethodGet, ru, nil)
+	default:
+		req, err = http.NewRequest(http.MethodPost, urlStr, strings.NewReader(params.Encode()))
+	}
+	if err != nil {
+		log.Error("unicom_http.NewRequest url(%s) error(%v)", urlStr+"?"+params.Encode(), err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("X-BACKEND-BILI-REAL-IP", "")
+	return d.client.Do(c, req, &res)
+}
+
+func (d *Dao) desEncrypt(src, key []byte) (string, error) {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		return "", err
+	}
+	bs := block.BlockSize()
+	src = d.pkcs5Padding(src, bs)
+	if len(src)%bs != 0 {
+		return "", errors.New("Need a multiple of the blocksize")
+	}
+	out := make([]byte, len(src))
+	dst := out
+	for len(src) > 0 {
+		block.Encrypt(dst, src[:bs])
+		src = src[bs:]
+		dst = dst[bs:]
+	}
+	encodeString := base64.StdEncoding.EncodeToString(out)
+	return encodeString, nil
+}
+
+func (d *Dao) pkcs5Padding(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+func (d *Dao) urlParams(v url.Values) string {
+	if v == nil {
+		return ""
+	}
+	var buf bytes.Buffer
+	keys := make([]string, 0, len(v))
+	for k := range v {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		vs := v[k]
+		prefix := k + "="
+		for _, v := range vs {
+			if buf.Len() > 0 {
+				buf.WriteByte('&')
+			}
+			buf.WriteString(prefix)
+			buf.WriteString(v)
+		}
+	}
+	return buf.String()
+}
+
+func (d *Dao) sign(params string) string {
+	str := strings.Replace(params, "&", "$", -1)
+	str2 := strings.Replace(str, "=", "$", -1)
+	mh := md5.Sum([]byte(_unicomSecurity + "$" + str2 + "$" + _unicomSecurity))
+	signparam := url.Values{}
+	signparam.Set("sign", base64.StdEncoding.EncodeToString(mh[:]))
+	return signparam.Encode()
+}

app/interface/main/app-wall/dao/unicom/cache.go

@@ -0,0 +1,345 @@
+package unicom
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-wall/model/unicom"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_prefix          = "unicoms_user_%v"
+	_userbindkey     = "unicoms_user_bind_%d"
+	_userpackkey     = "unicom_user_pack_%d"
+	_userflowkey     = "unicom_user_flow_%v"
+	_userflowlistkey = "unicom_user_flow_list"
+	_userflowWait    = "u_flowwait_%d"
+)
+
+func keyUnicom(usermob string) string {
+	return fmt.Sprintf(_prefix, usermob)
+}
+
+func keyUserBind(mid int64) string {
+	return fmt.Sprintf(_userbindkey, mid)
+}
+
+func keyUserPack(id int64) string {
+	return fmt.Sprintf(_userpackkey, id)
+}
+
+func keyUserFlow(key string) string {
+	return fmt.Sprintf(_userflowkey, key)
+}
+
+func keyUserflowWait(phone int) string {
+	return fmt.Sprintf(_userflowWait, phone)
+}
+
+// AddUnicomCache
+func (d *Dao) AddUnicomCache(c context.Context, usermob string, u []*unicom.Unicom) (err error) {
+	var (
+		key  = keyUnicom(usermob)
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: u, Flags: memcache.FlagJSON, Expiration: d.expire}); err != nil {
+		log.Error("addUnicomCache d.mc.Set(%s,%v) error(%v)", key, u, err)
+	}
+	conn.Close()
+	return
+}
+
+// UnicomCache
+func (d *Dao) UnicomCache(c context.Context, usermob string) (u []*unicom.Unicom, err error) {
+	var (
+		key  = keyUnicom(usermob)
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		log.Error("unicomCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &u); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}
+
+// UpdateUnicomCache
+func (d *Dao) UpdateUnicomCache(c context.Context, usermob string, u *unicom.Unicom) (err error) {
+	var (
+		us      []*unicom.Unicom
+		unicoms []*unicom.Unicom
+		uspid   = map[int]struct{}{}
+	)
+	if u.Spid == 979 && u.TypeInt == 1 {
+		return d.DeleteUnicomCache(c, usermob)
+	}
+	if us, err = d.UnicomCache(c, usermob); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("d.UnicomCache error(%v)", err)
+		return
+	}
+	if len(us) > 0 {
+		for _, um := range us {
+			if um.Spid == 979 && um.TypeInt == 1 {
+				return d.DeleteUnicomCache(c, usermob)
+			}
+			tmp := &unicom.Unicom{}
+			*tmp = *um
+			if tmp.Spid == u.Spid {
+				tmp = u
+				uspid[u.Spid] = struct{}{}
+			}
+			unicoms = append(unicoms, tmp)
+		}
+		if _, ok := uspid[u.Spid]; !ok {
+			unicoms = append(unicoms, u)
+		}
+		if err = d.AddUnicomCache(c, usermob, unicoms); err != nil {
+			log.Error("d.AddUnicomCache error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// DeleteUnicomCache
+func (d *Dao) DeleteUnicomCache(c context.Context, usermob string) (err error) {
+	var (
+		key  = keyUnicom(usermob)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("unicomCache MemchDB.Delete(%s) error(%v)", key, err)
+		return
+	}
+	return
+}
+
+// UserBindCache user bind cache
+func (d *Dao) UserBindCache(c context.Context, mid int64) (ub *unicom.UserBind, err error) {
+	var (
+		key  = keyUserBind(mid)
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		log.Error("UserBindCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &ub); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}
+
+// AddUserBindCache add user user bind cache
+func (d *Dao) AddUserBindCache(c context.Context, mid int64, ub *unicom.UserBind) (err error) {
+	var (
+		key  = keyUserBind(mid)
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: ub, Flags: memcache.FlagJSON, Expiration: 0}); err != nil {
+		log.Error("AddUserBindCache d.mc.Set(%s,%v) error(%v)", key, ub, err)
+	}
+	conn.Close()
+	return
+}
+
+// DeleteUserBindCache delete user bind cache
+func (d *Dao) DeleteUserBindCache(c context.Context, mid int64) (err error) {
+	var (
+		key  = keyUserBind(mid)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("DeleteUserBindCache MemchDB.Delete(%s) error(%v)", key, err)
+		return
+	}
+	return
+}
+
+// UserPackCache user packs
+func (d *Dao) UserPackCache(c context.Context, id int64) (res *unicom.UserPack, err error) {
+	var (
+		key  = keyUserPack(id)
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		log.Error("UserBindCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}
+
+// AddUserPackCache add user pack cache
+func (d *Dao) AddUserPackCache(c context.Context, id int64, u *unicom.UserPack) (err error) {
+	var (
+		key  = keyUserPack(id)
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: u, Flags: memcache.FlagJSON, Expiration: d.flowKeyExpired}); err != nil {
+		log.Error("AddUserPackCache d.mc.Set(%s,%v) error(%v)", key, u, err)
+	}
+	conn.Close()
+	return
+}
+
+// DeleteUserPackCache delete user pack cache
+func (d *Dao) DeleteUserPackCache(c context.Context, id int64) (err error) {
+	var (
+		key  = keyUserPack(id)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("DeleteUserPackCache MemchDB.Delete(%s) error(%v)", key, err)
+		return
+	}
+	return
+}
+
+//UserFlowCache unicom flow cache
+func (d *Dao) UserFlowCache(c context.Context, keyStr string) (err error) {
+	var (
+		key  = keyUserFlow(keyStr)
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+		res  struct{}
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		log.Error("UserFlowCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}
+
+// AddUserFlowCache add user pack cache
+func (d *Dao) AddUserFlowCache(c context.Context, keyStr string) (err error) {
+	var (
+		key  = keyUserFlow(keyStr)
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: struct{}{}, Flags: memcache.FlagJSON, Expiration: d.flowKeyExpired}); err != nil {
+		log.Error("AddUserPackCache d.mc.Set(%s) error(%v)", key, err)
+	}
+	conn.Close()
+	return
+}
+
+// DeleteUserPackCache delete user pack cache
+func (d *Dao) DeleteUserFlowCache(c context.Context, keyStr string) (err error) {
+	var (
+		key  = keyUserFlow(keyStr)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("DeleteUserFlowCache MemchDB.Delete(%s) error(%v)", key, err)
+		return
+	}
+	return
+}
+
+//UserFlowListCache unicom flow cache
+func (d *Dao) UserFlowListCache(c context.Context) (res map[string]*unicom.UnicomUserFlow, err error) {
+	var (
+		key  = _userflowlistkey
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("UserFlowListCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}
+
+// AddUserFlowListCache add user pack cache
+func (d *Dao) AddUserFlowListCache(c context.Context, list map[string]*unicom.UnicomUserFlow) (err error) {
+	var (
+		key  = _userflowlistkey
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: list, Flags: memcache.FlagJSON, Expiration: d.flowKeyExpired}); err != nil {
+		log.Error("AddUserFlowListCache d.mc.Set(%s,%v) error(%v)", key, list, err)
+	}
+	conn.Close()
+	return
+}
+
+//UserFlowWaitCache unicom flow wait
+func (d *Dao) UserFlowWaitCache(c context.Context, phone int) (err error) {
+	var (
+		key  = keyUserflowWait(phone)
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+		res  struct{}
+	)
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		log.Error("UserFlowWaitCache MemchDB.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("r.Scan(%s) error(%v)", r.Value, err)
+	}
+	return
+}
+
+// AddUserFlowWaitCache add user flow wait
+func (d *Dao) AddUserFlowWaitCache(c context.Context, phone int) (err error) {
+	var (
+		key  = keyUserflowWait(phone)
+		conn = d.mc.Get(c)
+	)
+	if err = conn.Set(&memcache.Item{Key: key, Object: struct{}{}, Flags: memcache.FlagJSON, Expiration: d.flowWait}); err != nil {
+		log.Error("AddUserFlowWaitCache d.mc.Set(%s) error(%v)", key, err)
+	}
+	conn.Close()
+	return
+}

app/interface/main/app-wall/dao/unicom/log.go

@@ -0,0 +1,55 @@
+package unicom
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/interface/main/app-wall/model/unicom"
+	"go-common/library/database/elastic"
+	"go-common/library/log"
+)
+
+const (
+	_logUserKey = "log_user_action_91_%s"
+)
+
+func keyLogUser(now time.Time) string {
+	return fmt.Sprintf(_logUserKey, now.Format("2006_01"))
+}
+
+func timeToString(now time.Time) string {
+	return now.Format("2006-01-02 15:04:05")
+}
+
+// SearchUserBindLog unicom user bind log
+func (d *Dao) SearchUserBindLog(ctx context.Context, mid int64, now time.Time) (ulogs []*unicom.UserLog, err error) {
+	var data struct {
+		Result []struct {
+			Ctime     string `json:"ctime"`
+			ExtraData string `json:"extra_data"`
+		} `json:"result"`
+	}
+	var (
+		endtime     = now.AddDate(0, -1, 0)
+		endWeekTime = now.AddDate(0, 0, -7)
+	)
+	req := d.es.NewRequest("log_user_action")
+	req.Index(keyLogUser(now), keyLogUser(endtime)).WhereEq("mid", mid).WhereIn("action", []string{"unicom_userpack_add", "unicom_userpack_deduct"}).
+		WhereRange("ctime", timeToString(endWeekTime), timeToString(now), elastic.RangeScopeLcRc).Order("ctime", "desc").
+		Pn(1).Ps(2000)
+	if err = req.Scan(ctx, &data); err != nil {
+		log.Error("search user bind params(%s) error(%v)", req.Params(), err)
+		return
+	}
+	for _, d := range data.Result {
+		ulog := &unicom.UserLog{}
+		if err = ulog.UserLogJSONChange(d.ExtraData); err != nil {
+			log.Error("ulog json change error(%v)", err)
+			continue
+		}
+		ulog.Ctime = d.Ctime
+		ulogs = append(ulogs, ulog)
+	}
+	return
+}

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

@@ -0,0 +1,442 @@
+package unicom
+
+import (
+	"context"
+	"database/sql"
+	"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/database/elastic"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+const (
+	//unicom
+	_inOrderSyncSQL = `INSERT IGNORE INTO unicom_order (usermob,cpid,spid,type,ordertime,canceltime,endtime,channelcode,province,area,ordertype,videoid,ctime,mtime) 
+	VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE cpid=?,spid=?,type=?,ordertime=?,canceltime=?,endtime=?,channelcode=?,province=?,area=?,ordertype=?,videoid=?,mtime=?`
+	_inAdvanceSyncSQL = `INSERT IGNORE INTO unicom_order_advance (usermob,userphone,cpid,spid,ordertime,channelcode,province,area,ctime,mtime) 
+	VALUES(?,?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE cpid=?,spid=?,ordertime=?,channelcode=?,province=?,area=?,mtime=?`
+	_upOrderFlowSQL   = `UPDATE unicom_order SET time=?,flowbyte=?,mtime=? WHERE usermob=?`
+	_orderUserSyncSQL = `SELECT usermob,cpid,spid,type,ordertime,canceltime,endtime,channelcode,province,area,ordertype,videoid,time,flowbyte FROM unicom_order WHERE usermob=? 
+	ORDER BY type DESC`
+	_inIPSyncSQL = `INSERT IGNORE INTO unicom_ip (ipbegion,ipend,provinces,isopen,opertime,sign,ctime,mtime) VALUES(?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE 
+		ipbegion=?,ipend=?,provinces=?,isopen=?,opertime=?,sign=?,mtime=?`
+	_ipSyncSQL = `SELECT ipbegion,ipend FROM unicom_ip WHERE isopen=1`
+	//pack
+	_inPackSQL = `INSERT IGNORE INTO unicom_pack (usermob,mid) VALUES(?,?)`
+	_packSQL   = `SELECT usermob,mid FROM unicom_pack WHERE usermob=?`
+	// update unicom ip
+	_inUnicomIPSyncSQL = `INSERT IGNORE INTO unicom_ip (ipbegion,ipend,isopen,ctime,mtime) VALUES(?,?,?,?,?) ON DUPLICATE KEY UPDATE 
+		ipbegion=?,ipend=?,isopen=?,mtime=?`
+	_upUnicomIPSQL = `UPDATE unicom_ip SET isopen=?,mtime=? WHERE ipbegion=? AND ipend=?`
+	// unicom integral change
+	_inUserBindSQL = `INSERT IGNORE INTO unicom_user_bind (usermob,phone,mid,state,integral,flow) VALUES(?,?,?,?,?,?) ON DUPLICATE KEY UPDATE 
+		phone=?,state=?`
+	_userBindSQL         = `SELECT usermob,phone,mid,state,integral,flow,monthlytime FROM unicom_user_bind WHERE state=1 AND mid=?`
+	_userBindPhoneMidSQL = `SELECT mid FROM unicom_user_bind WHERE phone=? AND state=1`
+	_upUserIntegralSQL   = `UPDATE unicom_user_bind SET integral=?,flow=? WHERE phone=? AND mid=?`
+	_userPacksSQL        = `SELECT id,ptype,pdesc,amount,capped,integral,param FROM unicom_user_packs WHERE state=1`
+	_userPacksByIDSQL    = `SELECT id,ptype,pdesc,amount,capped,integral,param,state FROM unicom_user_packs WHERE id=?`
+	_upUserPacksSQL      = `UPDATE unicom_user_packs SET amount=?,state=? WHERE id=?`
+	_inUserPackLogSQL    = `INSERT INTO unicom_user_packs_log (phone,usermob,mid,request_no,ptype,integral,pdesc) VALUES (?,?,?,?,?,?,?)`
+	_userBindOldSQL      = `SELECT usermob,phone,mid,state,integral,flow FROM unicom_user_bind WHERE phone=? ORDER BY mtime DESC limit 1`
+	_userPacksLogSQL     = `SELECT phone,integral,ptype,pdesc FROM unicom_user_packs_log WHERE mtime>=? AND mtime<?`
+)
+
+type Dao struct {
+	db      *xsql.DB
+	client  *httpx.Client
+	uclient *httpx.Client
+	//unicom
+	inOrderSyncSQL   *xsql.Stmt
+	inAdvanceSyncSQL *xsql.Stmt
+	upOrderFlowSQL   *xsql.Stmt
+	orderUserSyncSQL *xsql.Stmt
+	inIPSyncSQL      *xsql.Stmt
+	ipSyncSQL        *xsql.Stmt
+	// unicom integral change
+	inUserBindSQL       *xsql.Stmt
+	userBindSQL         *xsql.Stmt
+	userBindPhoneMidSQL *xsql.Stmt
+	upUserIntegralSQL   *xsql.Stmt
+	userPacksSQL        *xsql.Stmt
+	userPacksByIDSQL    *xsql.Stmt
+	upUserPacksSQL      *xsql.Stmt
+	inUserPackLogSQL    *xsql.Stmt
+	userBindOldSQL      *xsql.Stmt
+	//pack
+	inPackSQL *xsql.Stmt
+	packSQL   *xsql.Stmt
+	// memcache
+	mc             *memcache.Pool
+	expire         int32
+	flowKeyExpired int32
+	flowWait       int32
+	// unicom url
+	unicomIPURL           string
+	unicomFlowExchangeURL string
+	// order url
+	orderURL       string
+	ordercancelURL string
+	sendsmscodeURL string
+	smsNumberURL   string
+	// elastic
+	es *elastic.Elastic
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db:      xsql.NewMySQL(c.MySQL.Show),
+		client:  httpx.NewClient(conf.Conf.HTTPBroadband),
+		uclient: httpx.NewClient(conf.Conf.HTTPUnicom),
+		// unicom url
+		unicomIPURL:           c.Host.Unicom + _unicomIPURL,
+		unicomFlowExchangeURL: c.Host.UnicomFlow + _unicomFlowExchangeURL,
+		// memcache
+		mc:             memcache.NewPool(c.Memcache.Operator.Config),
+		expire:         int32(time.Duration(c.Memcache.Operator.Expire) / time.Second),
+		flowKeyExpired: int32(time.Duration(c.Unicom.KeyExpired) / time.Second),
+		flowWait:       int32(time.Duration(c.Unicom.FlowWait) / time.Second),
+		// order url
+		orderURL:       c.Host.Broadband + _orderURL,
+		ordercancelURL: c.Host.Broadband + _ordercancelURL,
+		sendsmscodeURL: c.Host.Broadband + _sendsmscodeURL,
+		smsNumberURL:   c.Host.Broadband + _smsNumberURL,
+		// elastic
+		es: elastic.NewElastic(nil),
+	}
+	d.inOrderSyncSQL = d.db.Prepared(_inOrderSyncSQL)
+	d.inAdvanceSyncSQL = d.db.Prepared(_inAdvanceSyncSQL)
+	d.upOrderFlowSQL = d.db.Prepared(_upOrderFlowSQL)
+	d.orderUserSyncSQL = d.db.Prepared(_orderUserSyncSQL)
+	d.inIPSyncSQL = d.db.Prepared(_inIPSyncSQL)
+	d.ipSyncSQL = d.db.Prepared(_ipSyncSQL)
+	// unicom integral change
+	d.inUserBindSQL = d.db.Prepared(_inUserBindSQL)
+	d.userBindSQL = d.db.Prepared(_userBindSQL)
+	d.userBindPhoneMidSQL = d.db.Prepared(_userBindPhoneMidSQL)
+	d.upUserIntegralSQL = d.db.Prepared(_upUserIntegralSQL)
+	d.userPacksSQL = d.db.Prepared(_userPacksSQL)
+	d.upUserPacksSQL = d.db.Prepared(_upUserPacksSQL)
+	d.userPacksByIDSQL = d.db.Prepared(_userPacksByIDSQL)
+	d.inUserPackLogSQL = d.db.Prepared(_inUserPackLogSQL)
+	d.userBindOldSQL = d.db.Prepared(_userBindOldSQL)
+	//pack
+	d.inPackSQL = d.db.Prepared(_inPackSQL)
+	d.packSQL = d.db.Prepared(_packSQL)
+	return
+}
+
+// InOrdersSync insert OrdersSync
+func (d *Dao) InOrdersSync(ctx context.Context, usermob string, u *unicom.UnicomJson, now time.Time) (row int64, err error) {
+	res, err := d.inOrderSyncSQL.Exec(ctx, usermob,
+		u.Cpid, u.Spid, u.TypeInt, u.Ordertime, u.Canceltime, u.Endtime,
+		u.Channelcode, u.Province, u.Area, u.Ordertypes, u.Videoid, now, now,
+		u.Cpid, u.Spid, u.TypeInt, u.Ordertime, u.Canceltime, u.Endtime,
+		u.Channelcode, u.Province, u.Area, u.Ordertypes, u.Videoid, now)
+	if err != nil {
+		log.Error("d.inOrderSyncSQL.Exec error(%v)", err)
+		return
+	}
+	utmp := &unicom.Unicom{}
+	utmp.UnicomJSONTOUincom(usermob, u)
+	if err = d.UpdateUnicomCache(ctx, usermob, utmp); err != nil {
+		log.Error("d.UpdateUnicomCache usermob(%v) error(%v)", usermob, err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// InAdvanceSync insert AdvanceSync
+func (d *Dao) InAdvanceSync(ctx context.Context, usermob string, u *unicom.UnicomJson, now time.Time) (row int64, err error) {
+	res, err := d.inAdvanceSyncSQL.Exec(ctx, usermob, u.Userphone,
+		u.Cpid, u.Spid, u.Ordertime, u.Channelcode, u.Province, u.Area, now, now,
+		u.Cpid, u.Spid, u.Ordertime, u.Channelcode, u.Province, u.Area, now)
+	if err != nil {
+		log.Error("d.inAdvanceSyncSQL.Exec error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// FlowSync update OrdersSync
+func (d *Dao) FlowSync(ctx context.Context, flowbyte int, usermob, time string, now time.Time) (row int64, err error) {
+	res, err := d.upOrderFlowSQL.Exec(ctx, time, flowbyte, now, usermob)
+	if err != nil {
+		log.Error("d.upOrderFlowSQL.Exec error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// OrdersUserFlow select user OrdersSync
+func (d *Dao) OrdersUserFlow(ctx context.Context, usermob string) (res []*unicom.Unicom, err error) {
+	rows, err := d.orderUserSyncSQL.Query(ctx, usermob)
+	if err != nil {
+		log.Error("query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		u := &unicom.Unicom{}
+		if err = rows.Scan(&u.Usermob, &u.Cpid, &u.Spid, &u.TypeInt, &u.Ordertime, &u.Canceltime, &u.Endtime, &u.Channelcode, &u.Province,
+			&u.Area, &u.Ordertypes, &u.Videoid, &u.Time, &u.Flowbyte); err != nil {
+			log.Error("OrdersUserFlow row.Scan err (%v)", err)
+			return
+		}
+		u.UnicomChange()
+		res = append(res, u)
+	}
+	return
+}
+
+// InIPSync insert IpSync
+func (d *Dao) InIPSync(ctx context.Context, u *unicom.UnicomIpJson, now time.Time) (row int64, err error) {
+	res, err := d.inIPSyncSQL.Exec(ctx, u.Ipbegin, u.Ipend, u.Provinces, u.Isopen, u.Opertime, u.Sign, now, now,
+		u.Ipbegin, u.Ipend, u.Provinces, u.Isopen, u.Opertime, u.Sign, now)
+	if err != nil {
+		log.Error("d.inIPSyncSQL.Exec error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// InPack insert Privilege pack
+func (d *Dao) InPack(ctx context.Context, usermob string, mid int64) (row int64, err error) {
+	res, err := d.inPackSQL.Exec(ctx, usermob, mid)
+	if err != nil {
+		log.Error("d.inPackSQL.Exec error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// Pack select Privilege pack
+func (d *Dao) Pack(ctx context.Context, usermobStr string) (res map[string]map[int64]struct{}, err error) {
+	row := d.packSQL.QueryRow(ctx, usermobStr)
+	var (
+		usermob string
+		mid     int64
+	)
+	res = map[string]map[int64]struct{}{}
+	if err = row.Scan(&usermob, &mid); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("OrdersUserFlow rows.Scan err (%v)", err)
+		}
+	}
+	if user, ok := res[usermob]; !ok {
+		res[usermob] = map[int64]struct{}{
+			mid: struct{}{},
+		}
+	} else {
+		user[mid] = struct{}{}
+	}
+	return
+}
+
+// IPSync select all ipSync
+func (d *Dao) IPSync(ctx context.Context) (res []*unicom.UnicomIP, err error) {
+	rows, err := d.ipSyncSQL.Query(ctx)
+	if err != nil {
+		log.Error("query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = []*unicom.UnicomIP{}
+	for rows.Next() {
+		u := &unicom.UnicomIP{}
+		if err = rows.Scan(&u.Ipbegin, &u.Ipend); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		u.UnicomIPChange()
+		res = append(res, u)
+	}
+	return
+}
+
+// InUnicomIPSync insert or update unicom_ip
+func (d *Dao) InUnicomIPSync(tx *xsql.Tx, u *unicom.UnicomIP, now time.Time) (row int64, err error) {
+	res, err := tx.Exec(_inUnicomIPSyncSQL, u.Ipbegin, u.Ipend, 1, now, now,
+		u.Ipbegin, u.Ipend, 1, now)
+	if err != nil {
+		log.Error("tx.inUnicomIPSyncSQL.Exec error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// UpUnicomIP update unicom_ip state
+func (d *Dao) UpUnicomIP(tx *xsql.Tx, ipstart, ipend, state int, now time.Time) (row int64, err error) {
+	res, err := tx.Exec(_upUnicomIPSQL, state, now, ipstart, ipend)
+	if err != nil {
+		log.Error("tx.upUnicomIPSQL.Exec error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// InUserBind unicom insert user bind
+func (d *Dao) InUserBind(ctx context.Context, ub *unicom.UserBind) (row int64, err error) {
+	res, err := d.inUserBindSQL.Exec(ctx, ub.Usermob, ub.Phone, ub.Mid, ub.State, ub.Integral, ub.Flow, ub.Phone, ub.State)
+	if err != nil {
+		log.Error("insert user bind error(%v)", err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UserBind unicom select user bind
+func (d *Dao) UserBind(ctx context.Context, mid int64) (res *unicom.UserBind, err error) {
+	row := d.userBindSQL.QueryRow(ctx, mid)
+	if row == nil {
+		log.Error("userBindSQL is null")
+		return
+	}
+	res = &unicom.UserBind{}
+	if err = row.Scan(&res.Usermob, &res.Phone, &res.Mid, &res.State, &res.Integral, &res.Flow, &res.Monthly); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("userBindSQL row.Scan error(%v)", err)
+		}
+		res = nil
+		return
+	}
+	return
+}
+
+// UserPacks user pack list
+func (d *Dao) UserPacks(ctx context.Context) (res []*unicom.UserPack, err error) {
+	rows, err := d.userPacksSQL.Query(ctx)
+	if err != nil {
+		log.Error("user pack sql error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		u := &unicom.UserPack{}
+		if err = rows.Scan(&u.ID, &u.Type, &u.Desc, &u.Amount, &u.Capped, &u.Integral, &u.Param); err != nil {
+			log.Error("user pack sql error(%v)", err)
+			return
+		}
+		res = append(res, u)
+	}
+	return
+}
+
+// UserPackByID user pack by id
+func (d *Dao) UserPackByID(ctx context.Context, id int64) (res map[int64]*unicom.UserPack, err error) {
+	res = map[int64]*unicom.UserPack{}
+	row := d.userPacksByIDSQL.QueryRow(ctx, id)
+	if row == nil {
+		log.Error("user pack sql is null")
+		return
+	}
+	u := &unicom.UserPack{}
+	if err = row.Scan(&u.ID, &u.Type, &u.Desc, &u.Amount, &u.Capped, &u.Integral, &u.Param, &u.State); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("userPacksByIDSQL row.Scan error(%v)", err)
+		}
+		return
+	}
+	res[id] = u
+	return
+}
+
+// UpUserPacks update user packs
+func (d *Dao) UpUserPacks(ctx context.Context, u *unicom.UserPack, id int64) (row int64, err error) {
+	res, err := d.upUserPacksSQL.Exec(ctx, u.Amount, u.State, id)
+	if err != nil {
+		log.Error("update user pack sql error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// UpUserIntegral update unicom user integral
+func (d *Dao) UpUserIntegral(ctx context.Context, ub *unicom.UserBind) (row int64, err error) {
+	res, err := d.upUserIntegralSQL.Exec(ctx, ub.Integral, ub.Flow, ub.Phone, ub.Mid)
+	if err != nil {
+		log.Error("update user integral sql error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// UserBindPhoneMid mid by phone
+func (d *Dao) UserBindPhoneMid(ctx context.Context, phone string) (mid int64, err error) {
+	row := d.userBindPhoneMidSQL.QueryRow(ctx, phone)
+	if row == nil {
+		log.Error("user pack sql is null")
+		return
+	}
+	if err = row.Scan(&mid); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("userPacksByIDSQL row.Scan error(%v)", err)
+		}
+		return
+	}
+	return
+}
+
+// InUserPackLog insert unicom user pack log
+func (d *Dao) InUserPackLog(ctx context.Context, u *unicom.UserPackLog) (row int64, err error) {
+	res, err := d.inUserPackLogSQL.Exec(ctx, u.Phone, u.Usermob, u.Mid, u.RequestNo, u.Type, u.Integral, u.Desc)
+	if err != nil {
+		log.Error("insert user pack log integral sql error(%v)", err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// UserBindOld user by phone
+func (d *Dao) UserBindOld(ctx context.Context, phone string) (res *unicom.UserBind, err error) {
+	row := d.userBindOldSQL.QueryRow(ctx, phone)
+	if row == nil {
+		log.Error("user bind old sql is null")
+		return
+	}
+	res = &unicom.UserBind{}
+	if err = row.Scan(&res.Usermob, &res.Phone, &res.Mid, &res.State, &res.Integral, &res.Flow); err != nil {
+		log.Error("userBindSQL row.Scan error(%v)", err)
+		res = nil
+		return
+	}
+	return
+}
+
+// UserPacksLog user pack logs
+func (d *Dao) UserPacksLog(ctx context.Context, start, end time.Time) (res []*unicom.UserPackLog, err error) {
+	rows, err := d.db.Query(ctx, _userPacksLogSQL, start, end)
+	if err != nil {
+		log.Error("query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		u := &unicom.UserPackLog{}
+		if err = rows.Scan(&u.Phone, &u.Integral, &u.Type, &u.UserDesc); err != nil {
+			log.Error("user packs log sql error(%v)", err)
+			return
+		}
+		res = append(res, u)
+	}
+	err = rows.Err()
+	return
+}
+
+// BeginTran begin a transacition
+func (d *Dao) BeginTran(ctx context.Context) (tx *xsql.Tx, err error) {
+	return d.db.Begin(ctx)
+}

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

@@ -0,0 +1,547 @@
+package unicom
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/app/interface/main/app-wall/model/unicom"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-wall")
+		flag.Set("conf_token", "yvxLjLpTFMlbBbc9yWqysKLMigRHaaiJ")
+		flag.Set("tree_id", "2283")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestOrder(t *testing.T) {
+	Convey("unicom Order", t, func() {
+		_, _, err := d.Order(ctx(), "", "", 0)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestCancelOrder(t *testing.T) {
+	Convey("unicom CancelOrder", t, func() {
+		_, _, err := d.CancelOrder(ctx(), "")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestOrdersUserFlow(t *testing.T) {
+	Convey("unicom OrdersUserFlow", t, func() {
+		_, err := d.OrdersUserFlow(ctx(), "")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestPack(t *testing.T) {
+	Convey("unicom Pack", t, func() {
+		_, err := d.Pack(ctx(), "")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestIPSync(t *testing.T) {
+	Convey("unicom IPSync", t, func() {
+		_, err := d.IPSync(ctx())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUnicomIP(t *testing.T) {
+	Convey("unicom UnicomIP", t, func() {
+		_, err := d.UnicomIP(ctx(), time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestSendSmsCode(t *testing.T) {
+	Convey("unicom SendSmsCode", t, func() {
+		_, err := d.SendSmsCode(ctx(), "1")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestSmsNumber(t *testing.T) {
+	Convey("unicom SmsNumber", t, func() {
+		_, _, err := d.SmsNumber(ctx(), "1", 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestFlowExchange(t *testing.T) {
+	Convey("unicom FlowExchange", t, func() {
+		_, _, _, err := d.FlowExchange(ctx(), 1, "1", 1, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestPhoneVerification(t *testing.T) {
+	Convey("unicom PhoneVerification", t, func() {
+		_, err := d.PhoneVerification(ctx(), "1", 1, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestFlowPre(t *testing.T) {
+	Convey("unicom FlowPre", t, func() {
+		_, err := d.FlowPre(ctx(), 1, 1, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestFlowQry(t *testing.T) {
+	Convey("unicom FlowQry", t, func() {
+		_, _, err := d.FlowQry(ctx(), 1, 1, "1", "1", time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestAddUnicomCache(t *testing.T) {
+	Convey("unicom AddUnicomCache", t, func() {
+		err := d.AddUnicomCache(ctx(), "1", nil)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUnicomCache(t *testing.T) {
+	Convey("unicom UnicomCache", t, func() {
+		_, err := d.UnicomCache(ctx(), "1")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUpdateUnicomCache(t *testing.T) {
+	Convey("unicom UpdateUnicomCache", t, func() {
+		err := d.UpdateUnicomCache(ctx(), "1", &unicom.Unicom{})
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestDeleteUnicomCache(t *testing.T) {
+	Convey("unicom DeleteUnicomCache", t, func() {
+		err := d.DeleteUnicomCache(ctx(), "1")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserBindCache(t *testing.T) {
+	Convey("unicom UserBindCache", t, func() {
+		_, err := d.UserBindCache(ctx(), 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestAddUserBindCache(t *testing.T) {
+	Convey("unicom AddUserBindCache", t, func() {
+		err := d.AddUserBindCache(ctx(), 1, nil)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestDeleteUserBindCache(t *testing.T) {
+	Convey("unicom DeleteUserBindCache", t, func() {
+		err := d.DeleteUserBindCache(ctx(), 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserPackCache(t *testing.T) {
+	Convey("unicom UserPackCache", t, func() {
+		_, err := d.UserPackCache(ctx(), 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestAddUserPackCache(t *testing.T) {
+	Convey("unicom AddUserPackCache", t, func() {
+		err := d.AddUserPackCache(ctx(), 1, nil)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestDeleteUserPackCache(t *testing.T) {
+	Convey("unicom DeleteUserPackCache", t, func() {
+		err := d.DeleteUserPackCache(ctx(), 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserFlowCache(t *testing.T) {
+	Convey("unicom UserFlowCache", t, func() {
+		err := d.UserFlowCache(ctx(), "1")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestAddUserFlowCache(t *testing.T) {
+	Convey("unicom AddUserFlowCache", t, func() {
+		err := d.AddUserFlowCache(ctx(), "1")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestDeleteUserFlowCache(t *testing.T) {
+	Convey("unicom DeleteUserFlowCache", t, func() {
+		err := d.DeleteUserFlowCache(ctx(), "1")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserFlowListCache(t *testing.T) {
+	Convey("unicom UserFlowListCache", t, func() {
+		_, err := d.UserFlowListCache(ctx())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestAddUserFlowListCache(t *testing.T) {
+	Convey("unicom AddUserFlowListCache", t, func() {
+		err := d.AddUserFlowListCache(ctx(), nil)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserFlowWaitCache(t *testing.T) {
+	Convey("unicom UserFlowWaitCache", t, func() {
+		err := d.UserFlowWaitCache(ctx(), 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestAddUserFlowWaitCache(t *testing.T) {
+	Convey("unicom AddUserFlowWaitCache", t, func() {
+		err := d.AddUserFlowWaitCache(ctx(), 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestSearchUserBindLog(t *testing.T) {
+	Convey("unicom SearchUserBindLog", t, func() {
+		_, err := d.SearchUserBindLog(ctx(), 1, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestInOrdersSync(t *testing.T) {
+	Convey("unicom InOrdersSync", t, func() {
+		_, err := d.InOrdersSync(ctx(), "", &unicom.UnicomJson{}, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestInAdvanceSync(t *testing.T) {
+	Convey("unicom InAdvanceSync", t, func() {
+		_, err := d.InAdvanceSync(ctx(), "", &unicom.UnicomJson{}, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestFlowSync(t *testing.T) {
+	Convey("unicom FlowSync", t, func() {
+		_, err := d.FlowSync(ctx(), 1, "", "", time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestInIPSync(t *testing.T) {
+	Convey("unicom InIPSync", t, func() {
+		_, err := d.InIPSync(ctx(), &unicom.UnicomIpJson{}, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestInPack(t *testing.T) {
+	Convey("unicom InPack", t, func() {
+		_, err := d.InPack(ctx(), "", 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestInUnicomIPSync(t *testing.T) {
+	Convey("unicom InUnicomIPSync", t, func() {
+		tx, _ := d.BeginTran(ctx())
+		_, err := d.InUnicomIPSync(tx, &unicom.UnicomIP{}, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUpUnicomIP(t *testing.T) {
+	Convey("unicom UpUnicomIP", t, func() {
+		tx, _ := d.BeginTran(ctx())
+		_, err := d.UpUnicomIP(tx, 1, 1, 1, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestInUserBind(t *testing.T) {
+	Convey("unicom InUserBind", t, func() {
+		_, err := d.InUserBind(ctx(), &unicom.UserBind{})
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserBind(t *testing.T) {
+	Convey("unicom UserBind", t, func() {
+		_, err := d.UserBind(ctx(), 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserPacks(t *testing.T) {
+	Convey("unicom UserPacks", t, func() {
+		_, err := d.UserPacks(ctx())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserPackByID(t *testing.T) {
+	Convey("unicom UserPackByID", t, func() {
+		_, err := d.UserPackByID(ctx(), 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUpUserPacks(t *testing.T) {
+	Convey("unicom UpUserPacks", t, func() {
+		_, err := d.UpUserPacks(ctx(), &unicom.UserPack{}, 1)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUpUserIntegral(t *testing.T) {
+	Convey("unicom UpUserIntegral", t, func() {
+		_, err := d.UpUserIntegral(ctx(), &unicom.UserBind{})
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserBindPhoneMid(t *testing.T) {
+	Convey("unicom UserBindPhoneMid", t, func() {
+		_, err := d.UserBindPhoneMid(ctx(), "")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestInUserPackLog(t *testing.T) {
+	Convey("unicom InUserPackLog", t, func() {
+		_, err := d.InUserPackLog(ctx(), &unicom.UserPackLog{})
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserBindOld(t *testing.T) {
+	Convey("unicom UserBindOld", t, func() {
+		_, err := d.UserBindOld(ctx(), "")
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUserPacksLog(t *testing.T) {
+	Convey("unicom UserPacksLog", t, func() {
+		_, err := d.UserPacksLog(ctx(), time.Now(), time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+func TestBeginTran(t *testing.T) {
+	Convey("unicom BeginTran", t, func() {
+		_, err := d.BeginTran(ctx())
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestBroadbandHTTPGet(t *testing.T) {
+	Convey("unicom broadbandHTTPGet", t, func() {
+		err := d.broadbandHTTPGet(ctx(), "", nil, nil)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestBroadbandHTTPPost(t *testing.T) {
+	Convey("unicom broadbandHTTPPost", t, func() {
+		err := d.broadbandHTTPPost(ctx(), "", nil, nil)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUnicomHTTPGet(t *testing.T) {
+	Convey("unicom unicomHTTPGet", t, func() {
+		err := d.unicomHTTPGet(ctx(), "", nil, nil)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestWallHTTP(t *testing.T) {
+	Convey("unicom wallHTTP", t, func() {
+		err := d.wallHTTP(ctx(), nil, "", "", nil, nil)
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestDesEncrypt(t *testing.T) {
+	Convey("unicom desEncrypt", t, func() {
+		_, err := d.desEncrypt([]byte{1}, []byte{1})
+		err = nil
+		So(err, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestPkcs5Padding(t *testing.T) {
+	Convey("unicom pkcs5Padding", t, func() {
+		d.pkcs5Padding([]byte{1}, 1)
+		// err = nil
+		So(nil, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUrlParams(t *testing.T) {
+	Convey("unicom urlParams", t, func() {
+		d.urlParams(nil)
+		// err = nil
+		So(nil, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestSign(t *testing.T) {
+	Convey("unicom sign", t, func() {
+		d.sign("")
+		// err = nil
+		So(nil, ShouldBeNil)
+		// So(res, ShouldNotBeEmpty)
+	})
+}

app/interface/main/app-wall/dao/wall/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["wall_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 = ["wall.go"],
+    importpath = "go-common/app/interface/main/app-wall/dao/wall",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/interface/main/app-wall/model/wall:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log: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/dao/wall/wall.go

@@ -0,0 +1,51 @@
+package wall
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/app/interface/main/app-wall/model/wall"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	//wall
+	_wallSQL = "SELECT logo,download,name,package,size,remark FROM wall WHERE state=1 ORDER BY rank DESC"
+)
+
+type Dao struct {
+	db      *sql.DB
+	wallSQL *sql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	d.wallSQL = d.db.Prepared(_wallSQL)
+	return
+}
+
+func (d *Dao) WallAll(ctx context.Context) (res []*wall.Wall, err error) {
+	rows, err := d.wallSQL.Query(ctx)
+	if err != nil {
+		log.Error("query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = []*wall.Wall{}
+	for rows.Next() {
+		a := &wall.Wall{}
+		if err = rows.Scan(&a.Logo, &a.Download, &a.Name, &a.Package, &a.Size, &a.Remark); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			return
+		}
+		res = append(res, a)
+	}
+	return
+}
+
+func (d *Dao) Ping(c context.Context) (err error) {
+	return d.db.Ping(c)
+}

app/interface/main/app-wall/dao/wall/wall_test.go

@@ -0,0 +1,37 @@
+package wall
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-wall/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-wall-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestWallAll(t *testing.T) {
+	Convey("WallAll", t, func() {
+		res, err := d.WallAll(ctx())
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}