Create & Init Project...

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)
+	})
+}