Create & Init Project...

app/interface/main/app-wall/http/BUILD

@@ -0,0 +1,61 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "http.go",
+        "ip.go",
+        "local.go",
+        "mobile.go",
+        "offer.go",
+        "operator.go",
+        "telecom.go",
+        "unicom.go",
+        "wall.go",
+    ],
+    importpath = "go-common/app/interface/main/app-wall/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-wall/conf:go_default_library",
+        "//app/interface/main/app-wall/dao/padding:go_default_library",
+        "//app/interface/main/app-wall/model:go_default_library",
+        "//app/interface/main/app-wall/model/mobile:go_default_library",
+        "//app/interface/main/app-wall/model/telecom:go_default_library",
+        "//app/interface/main/app-wall/model/unicom:go_default_library",
+        "//app/interface/main/app-wall/service/mobile:go_default_library",
+        "//app/interface/main/app-wall/service/offer:go_default_library",
+        "//app/interface/main/app-wall/service/operator:go_default_library",
+        "//app/interface/main/app-wall/service/ping:go_default_library",
+        "//app/interface/main/app-wall/service/telecom:go_default_library",
+        "//app/interface/main/app-wall/service/unicom:go_default_library",
+        "//app/interface/main/app-wall/service/wall:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/auth:go_default_library",
+        "//library/net/http/blademaster/middleware/proxy:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+        "//library/net/http/blademaster/render:go_default_library",
+        "//library/net/metadata: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/http/http.go

@@ -0,0 +1,160 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/interface/main/app-wall/conf"
+	"go-common/app/interface/main/app-wall/service/mobile"
+	"go-common/app/interface/main/app-wall/service/offer"
+	"go-common/app/interface/main/app-wall/service/operator"
+	pingSvr "go-common/app/interface/main/app-wall/service/ping"
+	"go-common/app/interface/main/app-wall/service/telecom"
+	"go-common/app/interface/main/app-wall/service/unicom"
+	"go-common/app/interface/main/app-wall/service/wall"
+	"go-common/library/ecode"
+	log "go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/auth"
+	"go-common/library/net/http/blademaster/middleware/proxy"
+	"go-common/library/net/http/blademaster/middleware/verify"
+	"go-common/library/net/http/blademaster/render"
+)
+
+var (
+	// depend service
+	verifySvc *verify.Verify
+	authSvc   *auth.Auth
+	// self service
+	wallSvc     *wall.Service
+	offerSvc    *offer.Service
+	unicomSvc   *unicom.Service
+	mobileSvc   *mobile.Service
+	pingSvc     *pingSvr.Service
+	telecomSvc  *telecom.Service
+	operatorSvc *operator.Service
+)
+
+func Init(c *conf.Config) {
+	initService(c)
+	// init external router
+	engineOut := bm.DefaultServer(c.BM.Outer)
+	outerRouter(engineOut)
+	// init Outer server
+	if err := engineOut.Start(); err != nil {
+		log.Error("engineOut.Start() error(%v)", err)
+		panic(err)
+	}
+}
+
+// initService init services.
+func initService(c *conf.Config) {
+	verifySvc = verify.New(nil)
+	authSvc = auth.New(&auth.Config{DisableCSRF: true})
+	// init self service
+	wallSvc = wall.New(c)
+	offerSvc = offer.New(c)
+	unicomSvc = unicom.New(c)
+	mobileSvc = mobile.New(c)
+	pingSvc = pingSvr.New(c)
+	telecomSvc = telecom.New(c)
+	operatorSvc = operator.New(c)
+}
+
+func outerRouter(e *bm.Engine) {
+	e.Ping(ping)
+	// formal api
+	proxyHandler := proxy.NewZoneProxy("sh004", "http://sh001-app.bilibili.com")
+	w := e.Group("/x/wall")
+	{
+		w.GET("/get", walls)
+		op := w.Group("/operator", authSvc.Guest)
+		{
+			op.GET("/ip", userOperatorIP)
+			op.GET("/m/ip", mOperatorIP)
+			op.GET("/reddot", reddot)
+		}
+		of := w.Group("/offer")
+		{
+			of.GET("/exist", wallExist)
+			of.POST("/click/shike", proxyHandler, wallShikeClick)
+			of.GET("/click/dotinapp", wallDotinappClick)
+			of.GET("/click/gdt", wallGdtClick)
+			of.GET("/click/toutiao", wallToutiaoClick)
+			of.POST("/active", proxyHandler, verifySvc.Verify, wallActive)
+			of.GET("/active/test", wallTestActive)
+			of.POST("/active2", proxyHandler, verifySvc.Verify, wallActive2)
+		}
+		uc := w.Group("/unicom", proxyHandler)
+		{
+			// unicomSync
+			uc.POST("/orders", ordersSync)
+			uc.POST("/advance", advanceSync)
+			uc.POST("/flow", flowSync)
+			uc.POST("/ip", inIPSync)
+			// unicom
+			uc.GET("/userflow", verifySvc.Verify, userFlow)
+			uc.GET("/user/userflow", bm.CORS(), userFlowState)
+			uc.GET("/userstate", verifySvc.Verify, userState)
+			uc.GET("/state", verifySvc.Verify, unicomState)
+			uc.GET("/m/state", unicomStateM)
+			uc.POST("/pack", authSvc.User, bm.CORS(), pack)
+			uc.GET("/userip", bm.CORS(), isUnciomIP)
+			uc.GET("/user/ip", bm.CORS(), userUnciomIP)
+			uc.POST("/order/pay", bm.CORS(), orderPay)
+			uc.POST("/order/cancel", bm.CORS(), orderCancel)
+			uc.POST("/order/smscode", authSvc.Guest, bm.CORS(), smsCode)
+			uc.POST("/order/bind", authSvc.Guest, bm.CORS(), addUnicomBind)
+			uc.POST("/order/untie", authSvc.Guest, bm.CORS(), releaseUnicomBind)
+			uc.GET("/bind/info", authSvc.Guest, bm.CORS(), userBind)
+			uc.GET("/pack/list", authSvc.Guest, bm.CORS(), packList)
+			uc.POST("/order/pack/receive", authSvc.Guest, bm.CORS(), packReceive)
+			uc.POST("/order/pack/flow", authSvc.Guest, bm.CORS(), flowPack)
+			uc.GET("/order/userlog", authSvc.User, bm.CORS(), userBindLog)
+			uc.GET("/pack/log", userPacksLog)
+			uc.GET("/bind/state", verifySvc.Verify, welfareBindState)
+		}
+		mb := w.Group("/mobile", proxyHandler)
+		{
+			mb.POST("/orders.so", ordersMobileSync)
+			mb.GET("/activation", verifySvc.Verify, mobileActivation)
+			mb.GET("/status", verifySvc.Verify, mobileState)
+			mb.GET("/user/status", bm.CORS(), userMobileState)
+		}
+		tl := w.Group("/telecom", proxyHandler)
+		{
+			tl.POST("/orders.so", bm.CORS(), telecomOrdersSync)
+			tl.POST("/flow.so", bm.CORS(), telecomMsgSync)
+			tl.POST("/order/pay", bm.CORS(), telecomPay)
+			tl.POST("/order/pay/cancel", bm.CORS(), cancelRepeatOrder)
+			tl.GET("/order/consent", verifySvc.Verify, orderConsent)
+			tl.GET("/order/list", verifySvc.Verify, orderList)
+			tl.GET("/order/user/flow", bm.CORS(), phoneFlow)
+			tl.POST("/send/sms", verifySvc.Verify, phoneSendSMS)
+			tl.GET("/verification", verifySvc.Verify, phoneVerification)
+			tl.GET("/order/state", bm.CORS(), orderState)
+		}
+	}
+}
+
+//returnDataJSON return json no message
+func returnDataJSON(c *bm.Context, data map[string]interface{}, err error) {
+	code := http.StatusOK
+	if data == nil {
+		c.JSON(data, err)
+		return
+	}
+	if _, ok := data["message"]; !ok {
+		data["message"] = ""
+	}
+	if err != nil {
+		c.Error = err
+		bcode := ecode.Cause(err)
+		data["code"] = bcode.Code()
+	} else {
+		if _, ok := data["code"]; !ok {
+			data["code"] = ecode.OK
+		}
+		data["ttl"] = 1
+	}
+	c.Render(code, render.MapJSON(data))
+}

app/interface/main/app-wall/http/ip.go

@@ -0,0 +1,81 @@
+package http
+
+import (
+	"encoding/base64"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-wall/model"
+	"go-common/library/ecode"
+	log "go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+func userOperatorIP(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	operator := params.Get("operator")
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	if operator == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ipStr := metadata.String(c, metadata.RemoteIP)
+	ip := model.InetAtoN(ipStr)
+	switch operator {
+	case "unicom":
+		res["data"] = unicomSvc.UserUnciomIP(ip, ipStr, usermob, mobiApp, build, time.Now())
+	case "mobile":
+		res["data"] = mobileSvc.IsMobileIP(ip, ipStr, usermob)
+	default:
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	returnDataJSON(c, res, nil)
+}
+
+func mOperatorIP(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	operator := params.Get("operator")
+	ipStr := params.Get("ip")
+	ip := model.InetAtoN(ipStr)
+	switch operator {
+	case "unicom":
+		var usermobStr string
+		if usermob != "" {
+			var (
+				_aesKey = []byte("9ed226d9")
+			)
+			bs, err := base64.StdEncoding.DecodeString(usermob)
+			if err != nil {
+				log.Error("base64.StdEncoding.DecodeString(%s) error(%v)", usermob, err)
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+			bs, err = unicomSvc.DesDecrypt(bs, _aesKey)
+			if err != nil {
+				log.Error("unicomSvc.DesDecrypt error(%v)", err)
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+			if len(bs) > 32 {
+				usermobStr = string(bs[:32])
+			} else {
+				usermobStr = string(bs)
+			}
+		}
+		res["data"] = unicomSvc.UserUnciomIP(ip, ipStr, usermobStr, "missevan", 0, time.Now())
+	case "mobile":
+		res["data"] = mobileSvc.IsMobileIP(ip, ipStr, usermob)
+	default:
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	returnDataJSON(c, res, nil)
+}

app/interface/main/app-wall/http/local.go

@@ -0,0 +1,17 @@
+package http
+
+import (
+	"net/http"
+
+	log "go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// ping check server ok.
+func ping(c *bm.Context) {
+	var err error
+	if err = pingSvc.Ping(c); err != nil {
+		log.Error("app-wall service ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

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

@@ -0,0 +1,170 @@
+package http
+
+import (
+	"encoding/xml"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"go-common/app/interface/main/app-wall/model/mobile"
+	"go-common/library/ecode"
+	log "go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+const (
+	mobileOrders = 0
+	mobileFlow   = 1
+)
+
+var (
+	emptyByte = []byte{}
+)
+
+// ordersSync
+func ordersMobileSync(c *bm.Context) {
+	mobile, mtype, err := requestXMLToMap(c.Request)
+	if err != nil {
+		log.Error("requestXMLToMap error (%v)", err)
+		mobileMessage(c, err, mtype)
+		return
+	}
+	b, _ := xml.Marshal(&mobile)
+	ip := metadata.String(c, metadata.RemoteIP)
+	switch mtype {
+	case mobileOrders:
+		log.Info("mobile user orders xml response(%s)", b)
+		if mobile.Threshold == "" {
+			mobile.Threshold = "100"
+		}
+		if err := mobileSvc.InOrdersSync(c, ip, mobile, time.Now()); err != nil {
+			log.Error("mobileSvc.InOrdersSync error (%v)", err)
+			mobileMessage(c, err, mtype)
+			return
+		}
+	case mobileFlow:
+		log.Info("mobile user flow xml response(%s)", b)
+		if err := mobileSvc.FlowSync(c, mobile, ip); err != nil {
+			log.Error("mobileSvc.FlowSync error (%v)", err)
+			mobileMessage(c, err, mtype)
+			return
+		}
+	}
+	mobileMessage(c, ecode.OK, mtype)
+}
+
+// mobileActivation
+func mobileActivation(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	msg, err := mobileSvc.Activation(c, usermob, time.Now())
+	if err != nil {
+		if msg != "" {
+			returnDataJSON(c, res, err)
+			res["message"] = msg
+		}
+
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = ""
+	returnDataJSON(c, res, nil)
+}
+
+// mobileState
+func mobileState(c *bm.Context) {
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	data := mobileSvc.MobileState(c, usermob, time.Now())
+	res := map[string]interface{}{
+		"data": data,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+// userFlowState
+func userMobileState(c *bm.Context) {
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	data := mobileSvc.UserMobileState(c, usermob, time.Now())
+	res := map[string]interface{}{
+		"data": data,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+// RequestXmlToMap
+func requestXMLToMap(request *http.Request) (data *mobile.MobileXML, mobileType int, err error) {
+	body, err := ioutil.ReadAll(request.Body)
+	if err != nil {
+		log.Error("mobile_ioutil.ReadAll error (%v)", err)
+		return
+	}
+	defer request.Body.Close()
+	if len(body) == 0 {
+		err = ecode.RequestErr
+		return
+	}
+	var res interface{} = &mobile.OrderXML{}
+	mobileType = mobileOrders
+	log.Info("mobile orders xml body(%s)", body)
+	if err = xml.Unmarshal(body, &res); err != nil {
+		res = &mobile.FlowXML{}
+		mobileType = mobileFlow
+		if err = xml.Unmarshal(body, &res); err != nil {
+			log.Error("xml.Unmarshal OrderXML(%v) error (%v)", res, err)
+			err = ecode.RequestErr
+			return
+		}
+	}
+	if res == nil {
+		err = ecode.NothingFound
+		log.Error("xml.Unmarshal OrderXML is null")
+		return
+	}
+	switch v := res.(type) {
+	case *mobile.OrderXML:
+		data = v.MobileXML
+	case *mobile.FlowXML:
+		data = v.MobileXML
+	}
+	return
+}
+
+func mobileMessage(c *bm.Context, err error, mobileType int) {
+	// response header
+	c.Writer.Header().Set("Content-Type", "text/xml; charset=UTF-8")
+	c.Writer.Header().Set("Cache-Control", "no-cache")
+	c.Writer.Header().Set("Connection", "keep-alive")
+	var msg interface{}
+	switch mobileType {
+	case mobileOrders:
+		msg = &mobile.OrderMsgXML{
+			Msg: &mobile.Msg{
+				Xmlns:   "http://www.monternet.com/dsmp/schemas/",
+				MsgType: "SyncFlowPkgOrderResp",
+				Version: "1.0.0",
+				HRet:    err.Error(),
+			},
+		}
+	case mobileFlow:
+		msg = &mobile.FlowMsgXML{
+			Msg: &mobile.Msg{
+				Xmlns:   "http://www.monternet.com/dsmp/schemas/",
+				MsgType: "SyncFlowPkgLeftQuotaResp",
+				Version: "1.0.0",
+				HRet:    err.Error(),
+			},
+		}
+	}
+	output, err := xml.MarshalIndent(msg, "  ", "    ")
+	if err != nil {
+		log.Error("xml.MarshalIndent (%v)", err)
+		err = ecode.RequestErr
+		output = emptyByte
+	}
+	c.Writer.Write([]byte(xml.Header))
+	c.Writer.Write(output)
+}

app/interface/main/app-wall/http/offer.go

@@ -0,0 +1,316 @@
+package http
+
+import (
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/interface/main/app-wall/dao/padding"
+	"go-common/app/interface/main/app-wall/model"
+	"go-common/library/ecode"
+	log "go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+// wallShikeClick
+func wallShikeClick(c *bm.Context) {
+	params := c.Request.Form
+	// ip uint32, cid, mac, idfa, cb
+	appid := params.Get("appid")
+	mac := params.Get("mac")
+	idfa := params.Get("idfa")
+	cb := params.Get("cb")
+	cid := model.ChannelShike
+	if appid != model.GdtIOSAppID {
+		log.Error("gdt click wrong appid(%s)", appid)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if cid == "" || idfa == "" || cb == "" {
+		log.Error("arg cid(%s) mac(%s) idfa(%s) callback(%s) is empty", cid, idfa, cb)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ip := model.InetAtoN(metadata.String(c, metadata.RemoteIP))
+	if err := offerSvc.Click(c, ip, cid, mac, idfa, cb, time.Now()); err != nil {
+		log.Error("offerSvc.Click error(%v)", err)
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	res := map[string]interface{}{}
+	res["code"] = ecode.OK
+	returnDataJSON(c, res, nil)
+}
+
+// wallGdtClick
+func wallGdtClick(c *bm.Context) {
+	params := c.Request.Form
+	appID := params.Get("appid")
+	muid := params.Get("muid")
+	var now time.Time
+	ts, _ := strconv.ParseInt(params.Get("click_time"), 10, 64)
+	if ts != 0 {
+		now = time.Unix(ts, 0)
+	} else {
+		now = time.Now()
+	}
+	clickid := params.Get("click_id")
+	adid := params.Get("advertiser_id")
+	appType := params.Get("app_type")
+	if id, ok := model.AppIDGdt[appType]; !ok || appID != id {
+		log.Error("wallGdtClick app_type(%s) and appid(%s) is illegal", appType, appID)
+		res := map[string]interface{}{"ret": ecode.RequestErr}
+		returnDataJSON(c, res, nil)
+		return
+	}
+	if _, ok := model.ChannelGdt[adid]; !ok {
+		log.Error("wallGdtClick advertiser_id(%s) is illegal", adid)
+		res := map[string]interface{}{"ret": ecode.RequestErr}
+		returnDataJSON(c, res, nil)
+		return
+	}
+	ip := model.InetAtoN(metadata.String(c, metadata.RemoteIP))
+	if appType == model.TypeIOS {
+		if err := offerSvc.Click(c, ip, adid, "", muid, clickid, now); err != nil {
+			log.Error("wallGdtClick %+v", err)
+			res := map[string]interface{}{"ret": ecode.ServerErr}
+			returnDataJSON(c, res, nil)
+			return
+		}
+	} else if appType == model.TypeAndriod {
+		if err := offerSvc.ANClick(c, adid, muid, "", "", clickid, ip, now); err != nil {
+			log.Error("wallGdtClick %+v", err)
+			res := map[string]interface{}{"ret": ecode.ServerErr}
+			returnDataJSON(c, res, nil)
+			return
+		}
+	}
+	res := map[string]interface{}{"ret": ecode.OK}
+	returnDataJSON(c, res, nil)
+}
+
+// wallTestActive
+func wallTestActive(c *bm.Context) {
+	params := c.Request.Form
+	idfa := params.Get("idfa")
+	if idfa == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ip := model.InetAtoN(metadata.String(c, metadata.RemoteIP))
+	if err := offerSvc.Active(c, ip, "0", "", "", idfa, "test by haogw", time.Now()); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	res := map[string]interface{}{
+		"code": ecode.OK,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+// wallActive
+func wallActive(c *bm.Context) {
+	var (
+		_aesKey = []byte("iHiRzNVIy8mvc4HnKPKeiJEP90zycllH")
+		_aesIv  = []byte("w4gQHf5M7RQdBq2U")
+	)
+	body := c.Request.Form.Get("body")
+	if body == "" {
+		log.Error("body is empty")
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	log.Info("body before base64 (%v)", body)
+	paramBody := c.Request.Form
+	appkey := paramBody.Get("appkey")
+	appver := paramBody.Get("appver")
+	build := paramBody.Get("build")
+	device := paramBody.Get("device")
+	filtered := paramBody.Get("filtered")
+	mobiApp := paramBody.Get("mobi_app")
+	sign := paramBody.Get("sign")
+	log.Info("appkey: (%v)\n appver: (%v)\n build: (%v)\n device: (%v)\n filtered: (%v)\n mobi_app: (%v)\n sign: (%v)", appkey, appver, build, device, filtered, mobiApp, sign)
+	bs, err := base64.StdEncoding.DecodeString(body)
+	if err != nil {
+		log.Error("base64.StdEncoding.DecodeString(%s) error(%v)", body, err)
+		c.JSON(nil, ecode.SignCheckErr)
+		return
+	}
+	bs, err = offerSvc.CBCDecrypt(bs, _aesKey, _aesIv, padding.PKCS5)
+	if err != nil {
+		log.Error("aes.CBCDecrypt(%s) error(%v)", base64.StdEncoding.EncodeToString(bs), err)
+		c.JSON(nil, ecode.SignCheckErr)
+		return
+	}
+	params, err := url.ParseQuery(string(bs))
+	if err != nil {
+		log.Error("url.ParseQuery(%s) error(%v)", bs, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	rmac := params.Get("rmac")
+	mac := params.Get("mac")
+	idfa := params.Get("idfa")
+	name := params.Get("name")
+	log.Info("rmac: (%v)\n mac: (%v)\n idfa: (%v)\n name: (%v)\n", rmac, mac, idfa, name)
+	if idfa == "" || name == "" || strings.Contains(idfa, "-") || strings.Contains(rmac, ":") || strings.Contains(mac, ":") {
+		log.Error("mac(%s) rmac(%s) idfa(%s) format error, or idfa(%s) name(%s) is empty", mac, rmac, idfa, idfa, name)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ip := model.InetAtoN(metadata.String(c, metadata.RemoteIP))
+	var (
+		mid int64
+	)
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	log.Info("mid: (%d)", mid)
+	err = offerSvc.Active(c, ip, strconv.FormatInt(mid, 10), rmac, mac, idfa, name, time.Now())
+	if err != nil {
+		log.Error("offerSvc.Active(%d, %d, %s, %s, %s, %s) error(%v)", ip, mid, rmac, mac, idfa, name, err)
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	log.Info("wall offer active idfa(%s)", idfa)
+	res := map[string]interface{}{
+		"code": ecode.OK,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+func wallExist(c *bm.Context) {
+	params := c.Request.Form
+	// ip uint32, cid, mac, idfa, cb
+	appID := params.Get("appid")
+	idfa := params.Get("idfa")
+	if (appID != model.GdtIOSAppID && appID != model.GdtAndroidAppID) || idfa == "" {
+		log.Error("arg cid(%s) idfa(%s) is empty", appID, idfa)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	exist, _ := offerSvc.Exists(c, strings.Replace(idfa, "-", "", -1))
+	const (
+		ret = `{"%s":"%d"}`
+	)
+	e := 1
+	if !exist {
+		e = 0
+	}
+	bs := []byte(fmt.Sprintf(ret, idfa, e))
+	if _, err := c.Writer.Write(bs); err != nil {
+		log.Error("w.Write error(%v)", err)
+	}
+	res := map[string]interface{}{
+		"code": ecode.OK,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+func wallDotinappClick(c *bm.Context) {
+	params := c.Request.Form
+	appid := params.Get("appid")
+	// pid := params.Get("pid")
+	// subid := params.Get("subid")
+	// ua := params.Get("ua")
+	idfa := params.Get("idfa")
+	clickid := params.Get("clickid")
+	pid := model.ChannelDontin
+	if appid != model.GdtIOSAppID {
+		log.Error("dotinapp click wrong appid(%s)", appid)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if pid == "" || idfa == "" || clickid == "" {
+		log.Error("pid(%s) idfa(%s) clickid(%s) is empty", pid, idfa, clickid)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ip := model.InetAtoN(metadata.String(c, metadata.RemoteIP))
+	if err := offerSvc.Click(c, ip, pid, "", idfa, clickid, time.Now()); err != nil {
+		log.Error("offerSvc.Click error(%v)", err)
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	res := map[string]interface{}{
+		"code": ecode.OK,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+func wallToutiaoClick(c *bm.Context) {
+	const (
+		OSAndroid = "0"
+		// OSIOS     = "1"
+	)
+	params := c.Request.Form
+	os := params.Get("os")
+	if os != OSAndroid {
+		log.Error("wallToutiaoClick os(%s) is illegal", os)
+		c.AbortWithStatus(http.StatusBadRequest)
+		return
+	}
+	imei := params.Get("imei")
+	androidid := params.Get("androidid")
+	if imei == "" && androidid == "" {
+		log.Error("wallToutiaoClick imei(%s) and androidid(%s) is illegal", imei, androidid)
+		c.AbortWithStatus(http.StatusBadRequest)
+		return
+	}
+	cb := params.Get("callback_url")
+	if cb == "" {
+		log.Error("wallToutiaoClick callback_url(%s) is illegal", cb)
+		c.AbortWithStatus(http.StatusBadRequest)
+		return
+	}
+	mac := params.Get("mac")
+	ip := model.InetAtoN(params.Get("ip"))
+	var now time.Time
+	ts, _ := strconv.ParseInt(params.Get("timestamp"), 10, 64)
+	if ts != 0 {
+		now = time.Unix(0, ts*1e6)
+	} else {
+		now = time.Now()
+	}
+	if os == OSAndroid {
+		if err := offerSvc.ANClick(c, model.ChannelToutiao, imei, androidid, mac, cb, ip, now); err != nil {
+			log.Error("%+v", err)
+			c.AbortWithStatus(http.StatusInternalServerError)
+			return
+		}
+	}
+}
+
+func wallActive2(c *bm.Context) {
+	params := c.Request.Form
+	os := params.Get("os")
+	if _, ok := model.AppIDGdt[os]; !ok {
+		log.Error("wallActive2 os(%s) is illegal", os)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if os != model.TypeAndriod {
+		log.Error("wallActive2 os(%s) is illegal", os)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	imei := params.Get("imei")
+	androidid := params.Get("androidid")
+	if imei == "" && androidid == "" {
+		log.Error("wallActive2 imei(%s) and androidid(%s) is illegal", imei, androidid)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	mac := params.Get("mac")
+	err := offerSvc.ANActive(c, imei, androidid, mac, time.Now())
+	if err != nil {
+		log.Error("wallActive2 %+v", err)
+	}
+	c.JSON(nil, err)
+}

app/interface/main/app-wall/http/operator.go

@@ -0,0 +1,14 @@
+package http
+
+import (
+	"time"
+
+	bm "go-common/library/net/http/blademaster"
+)
+
+func reddot(c *bm.Context) {
+	res := map[string]interface{}{
+		"data": operatorSvc.Reddot(time.Now()),
+	}
+	returnDataJSON(c, res, nil)
+}

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

@@ -0,0 +1,362 @@
+package http
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-wall/model/telecom"
+	"go-common/library/ecode"
+	log "go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+// ordersSync
+func telecomOrdersSync(c *bm.Context) {
+	data, err := requestJSONTelecom(c.Request)
+	if err != nil {
+		telecomMessage(c, err.Error())
+		return
+	}
+	switch v := data.(type) {
+	case *telecom.TelecomOrderJson:
+		if err = telecomSvc.InOrdersSync(c, metadata.String(c, metadata.RemoteIP), v); err != nil {
+			log.Error("telecomSvc.InOrdersSync error (%v)", err)
+			telecomMessage(c, err.Error())
+			return
+		}
+		telecomMessage(c, "1")
+	case *telecom.TelecomRechargeJson:
+		if v == nil {
+			telecomMessage(c, ecode.NothingFound.Error())
+			return
+		}
+		if err = telecomSvc.InRechargeSync(c, metadata.String(c, metadata.RemoteIP), v.Detail); err != nil {
+			log.Error("telecomSvc.InOrdersSync error (%v)", err)
+			telecomMessage(c, err.Error())
+			return
+		}
+		telecomMessage(c, "1")
+	}
+}
+
+// telecomMsgSync
+func telecomMsgSync(c *bm.Context) {
+	data, err := requestJSONTelecomMsg(c.Request)
+	if err != nil {
+		telecomMessage(c, err.Error())
+		return
+	}
+	if err = telecomSvc.TelecomMessageSync(c, metadata.String(c, metadata.RemoteIP), data); err != nil {
+		log.Error("telecomSvc.TelecomMessageSync error (%v)", err)
+		telecomMessage(c, err.Error())
+		return
+	}
+	telecomMessage(c, "1")
+}
+
+func telecomPay(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phoneDES := params.Get("phone")
+	phone, err := phoneDesToInt(phoneDES)
+	if err != nil {
+		log.Error("phoneDesToInt error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	isRepeatOrderStr := params.Get("is_repeat_order")
+	isRepeatOrder, err := strconv.Atoi(isRepeatOrderStr)
+	if err != nil {
+		log.Error("isRepeatOrder strconv.Atoi error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	payChannelStr := params.Get("pay_channel")
+	payChannel, err := strconv.Atoi(payChannelStr)
+	if err != nil {
+		log.Error("payChannel strconv.Atoi error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	payActionStr := params.Get("pay_action")
+	payAction, err := strconv.Atoi(payActionStr)
+	if err != nil {
+		log.Error("payAction strconv.Atoi error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	orderIDStr := params.Get("orderid")
+	orderID, _ := strconv.ParseInt(orderIDStr, 10, 64)
+	data, msg, err := telecomSvc.TelecomPay(c, phone, isRepeatOrder, payChannel, payAction, orderID, metadata.String(c, metadata.RemoteIP))
+	if err != nil {
+		log.Error("telecomSvc.TelecomPay error(%v)", err)
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+func cancelRepeatOrder(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phoneDES := params.Get("phone")
+	phone, err := phoneDesToInt(phoneDES)
+	if err != nil {
+		log.Error("phoneDesToInt error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	msg, err := telecomSvc.CancelRepeatOrder(c, phone)
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+func orderList(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phoneDES := params.Get("phone")
+	phone, err := phoneDesToInt(phoneDES)
+	if err != nil {
+		log.Error("phoneDesToInt error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	orderIDStr := params.Get("orderid")
+	orderID, _ := strconv.ParseInt(orderIDStr, 10, 64)
+	data, msg, err := telecomSvc.OrderList(c, orderID, phone)
+	if err != nil {
+		log.Error("telecomSvc.OrderList error(%v)", err)
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+func phoneFlow(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phoneDES := params.Get("phone")
+	phone, err := phoneDesToInt(phoneDES)
+	if err != nil {
+		log.Error("phoneDesToInt error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	orderIDStr := params.Get("orderid")
+	orderID, _ := strconv.ParseInt(orderIDStr, 10, 64)
+	data, msg, err := telecomSvc.PhoneFlow(c, orderID, phone)
+	if err != nil {
+		log.Error("telecomSvc.PhoneFlow error(%v)", err)
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+func orderConsent(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phoneDES := params.Get("phone")
+	phone, err := phoneDesToInt(phoneDES)
+	if err != nil {
+		log.Error("phoneDesToInt error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	captcha := params.Get("captcha")
+	orderIDStr := params.Get("orderid")
+	orderID, _ := strconv.ParseInt(orderIDStr, 10, 64)
+	data, msg, err := telecomSvc.OrderConsent(c, phone, orderID, captcha)
+	if err != nil {
+		log.Error("telecomSvc.OrderConsent error(%v)", err)
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+func phoneSendSMS(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phoneDES := params.Get("phone")
+	phone, err := phoneDesToInt(phoneDES)
+	if err != nil {
+		log.Error("phoneDesToInt error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	err = telecomSvc.PhoneSendSMS(c, phone)
+	if err != nil {
+		log.Error("telecomSvc.PhoneSendSMS error(%v)", err)
+		res["code"] = err
+		res["message"] = ""
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = ""
+	returnDataJSON(c, res, nil)
+}
+
+func phoneVerification(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phoneDES := params.Get("phone")
+	phone, err := phoneDesToInt(phoneDES)
+	if err != nil {
+		log.Error("phoneDesToInt error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	captcha := params.Get("captcha")
+	data, err, msg := telecomSvc.PhoneCode(c, phone, captcha, time.Now())
+	if err != nil {
+		log.Error("telecomSvc.PhoneCode error(%v)", err)
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+func orderState(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	orderIDStr := params.Get("orderid")
+	orderID, err := strconv.ParseInt(orderIDStr, 10, 64)
+	if err != nil {
+		log.Error("orderID strconv.ParseInt error(%v)", err)
+		res["message"] = ""
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	data, msg, err := telecomSvc.OrderState(c, orderID)
+	if err != nil {
+		log.Error("telecomSvc.OrderState error(%v)", err)
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+// requestJSONTelecom
+func requestJSONTelecom(request *http.Request) (res interface{}, err error) {
+	var (
+		telecomOrder    *telecom.TelecomOrderJson
+		telecomRecharge *telecom.TelecomRechargeJson
+	)
+	body, err := ioutil.ReadAll(request.Body)
+	if err != nil {
+		log.Error("unicom_ioutil.ReadAll error (%v)", err)
+		return
+	}
+	defer request.Body.Close()
+	if len(body) == 0 {
+		err = ecode.RequestErr
+		return
+	}
+	log.Info("telecom orders json body(%s)", body)
+	if err = json.Unmarshal(body, &telecomOrder); err == nil && telecomOrder != nil {
+		if telecomOrder.ResultType != 2 {
+			res = telecomOrder
+			return
+		}
+	}
+	if err = json.Unmarshal(body, &telecomRecharge); err == nil {
+		res = telecomRecharge
+		return
+	}
+	log.Error("telecom json.Unmarshal error (%v)", err)
+	return
+}
+
+// requestJSONTelecomMsg
+func requestJSONTelecomMsg(request *http.Request) (res *telecom.TelecomMessageJSON, err error) {
+	body, err := ioutil.ReadAll(request.Body)
+	if err != nil {
+		log.Error("unicom_ioutil.ReadAll error (%v)", err)
+		return
+	}
+	defer request.Body.Close()
+	if len(body) == 0 {
+		err = ecode.RequestErr
+		return
+	}
+	log.Info("telecom json msg body(%s)", body)
+	if err = json.Unmarshal(body, &res); err != nil {
+		log.Error("telecom Message json.Unmarshal error (%v)", err)
+		return
+	}
+	return
+}
+
+// telecomMessage
+func telecomMessage(c *bm.Context, code string) {
+	// response header
+	c.Writer.Header().Set("Content-Type", "text; charset=UTF-8")
+	c.Writer.Header().Set("Cache-Control", "no-cache")
+	c.Writer.Header().Set("Connection", "keep-alive")
+	c.Writer.Write([]byte(code))
+}
+
+// phoneDesToInt des to int
+func phoneDesToInt(phoneDes string) (phoneInt int, err error) {
+	var (
+		_aesKey = []byte("6b7e8b8a")
+	)
+	bs, err := base64.StdEncoding.DecodeString(phoneDes)
+	if err != nil {
+		log.Error("base64.StdEncoding.DecodeString(%s) error(%v)", phoneDes, err)
+		err = ecode.RequestErr
+		return
+	}
+	if bs, err = telecomSvc.DesDecrypt(bs, _aesKey); err != nil {
+		log.Error("phone s.DesDecrypt error(%v)", err)
+		return
+	}
+	var phoneStr string
+	if len(bs) > 11 {
+		phoneStr = string(bs[:11])
+	} else {
+		phoneStr = string(bs)
+	}
+	phoneInt, err = strconv.Atoi(phoneStr)
+	if err != nil {
+		log.Error("phoneDesToInt phoneStr:%v error(%v)", phoneStr, err)
+		err = ecode.RequestErr
+		return
+	}
+	return
+}

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

@@ -0,0 +1,656 @@
+package http
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-wall/model"
+	"go-common/app/interface/main/app-wall/model/unicom"
+	"go-common/library/ecode"
+	log "go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+// ordersSync
+func ordersSync(c *bm.Context) {
+	res := map[string]interface{}{}
+	unicom, err := requestJSONToMap(c.Request)
+	if err != nil {
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		log.Error("unicom_ioutil.ReadAll error (%v)", err)
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	usermob, err := url.QueryUnescape(unicom.Usermob)
+	if err != nil {
+		log.Error("unicom_url.QueryUnescape (%v) error (%v)", unicom.Usermob, err)
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	var (
+		_aesKey = []byte("9ed226d9")
+	)
+	bs, err := base64.StdEncoding.DecodeString(usermob)
+	if err != nil {
+		log.Error("base64.StdEncoding.DecodeString(%s) error(%v)", usermob, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	bs, err = unicomSvc.DesDecrypt(bs, _aesKey)
+	if err != nil {
+		log.Error("unicomSvc.DesDecrypt error(%v)", err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var usermobStr string
+	if len(bs) > 32 {
+		usermobStr = string(bs[:32])
+	} else {
+		usermobStr = string(bs)
+	}
+	log.Info("unicomSvc.OrdersSync_usermob (%v) unicom (%v)", usermobStr, unicom)
+	if err := unicomSvc.InOrdersSync(c, usermobStr, metadata.String(c, metadata.RemoteIP), unicom, time.Now()); err != nil {
+		log.Error("unicomSvc.OrdersSync usermob (%v) unicom (%v) error (%v)", usermobStr, unicom, err)
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["result"] = "0"
+	res["message"] = ""
+	res["errorcode"] = ""
+	returnDataJSON(c, res, nil)
+}
+
+// advanceSync
+func advanceSync(c *bm.Context) {
+	res := map[string]interface{}{}
+	unicom, err := requestJSONToMap(c.Request)
+	if err != nil {
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		log.Error("unicom_ioutil.ReadAll error (%v)", err)
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	usermob, err := url.QueryUnescape(unicom.Usermob)
+	if err != nil {
+		log.Error("unicom_url.QueryUnescape (%v) error (%v)", unicom.Usermob, err)
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	var (
+		_aesKey = []byte("9ed226d9")
+	)
+	bs, err := base64.StdEncoding.DecodeString(usermob)
+	if err != nil {
+		log.Error("base64.StdEncoding.DecodeString(%s) error(%v)", usermob, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	bs, err = unicomSvc.DesDecrypt(bs, _aesKey)
+	if err != nil {
+		log.Error("unicomSvc.DesDecrypt error(%v)", err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var usermobStr string
+	if len(bs) > 32 {
+		usermobStr = string(bs[:32])
+	} else {
+		usermobStr = string(bs)
+	}
+	log.Info("unicomSvc.AdvanceSync_usermob (%v) unicom (%v)", usermobStr, unicom)
+	if err := unicomSvc.InAdvanceSync(c, usermobStr, metadata.String(c, metadata.RemoteIP), unicom, time.Now()); err != nil {
+		log.Error("unicomSvc.InAdvanceSync usermob (%v) unicom (%v) error (%v)", usermobStr, unicom, err)
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["result"] = "0"
+	res["message"] = ""
+	res["errorcode"] = ""
+	returnDataJSON(c, res, nil)
+}
+
+// flowSync
+func flowSync(c *bm.Context) {
+	res := map[string]interface{}{}
+	unicom, err := requestJSONToMap(c.Request)
+	if err != nil {
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		log.Error("unicom_ioutil.ReadAll error (%v)", err)
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	var flowbyte float64
+	if flowbyte, err = strconv.ParseFloat(unicom.FlowbyteStr, 64); err != nil {
+		log.Error("unicom_flowbyte strconv.ParseFloat(%s) error(%v)", unicom.FlowbyteStr, err)
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	usermob, err := url.QueryUnescape(unicom.Usermob)
+	if err != nil {
+		log.Error("unicom_url.QueryUnescape (%v) error (%v)", unicom.Usermob, err)
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	var (
+		_aesKey = []byte("9ed226d9")
+	)
+	bs, err := base64.StdEncoding.DecodeString(usermob)
+	if err != nil {
+		log.Error("unicom_base64.StdEncoding.DecodeString(%s) error(%v)", usermob, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	bs, err = unicomSvc.DesDecrypt(bs, _aesKey)
+	if err != nil {
+		log.Error("unicomSvc.DesDecrypt error(%v)", err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var usermobStr string
+	if len(bs) > 32 {
+		usermobStr = string(bs[:32])
+	} else {
+		usermobStr = string(bs)
+	}
+	if err := unicomSvc.FlowSync(c, int(flowbyte*1024), usermobStr, unicom.Time, metadata.String(c, metadata.RemoteIP), time.Now()); err != nil {
+		log.Error("unicomSvc.FlowSync error (%v)", err)
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["result"] = "0"
+	res["message"] = ""
+	res["errorcode"] = ""
+	returnDataJSON(c, res, nil)
+}
+
+// inIPSync
+func inIPSync(c *bm.Context) {
+	res := map[string]interface{}{}
+	unicom, err := requestIPJSONToMap(c.Request)
+	if err != nil {
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		log.Error("unicom_ioutil.ReadAll error (%v)", err)
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	log.Info("unicomSvc.InIpSync_unicom (%v)", unicom)
+	if err := unicomSvc.InIPSync(c, metadata.String(c, metadata.RemoteIP), unicom, time.Now()); err != nil {
+		log.Error("unicomSvc.InIpSync unicom (%v) error (%v)", unicom, err)
+		res["result"] = "1"
+		res["errorcode"] = "100"
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["result"] = "0"
+	res["message"] = ""
+	res["errorcode"] = ""
+	returnDataJSON(c, res, nil)
+}
+
+// userFlow
+func userFlow(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	ipStr := metadata.String(c, metadata.RemoteIP)
+	data, msg, err := unicomSvc.UserFlow(c, usermob, mobiApp, ipStr, build, time.Now())
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+// userFlowState
+func userFlowState(c *bm.Context) {
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	data, err := unicomSvc.UserFlowState(c, usermob, time.Now())
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	res := map[string]interface{}{
+		"data": data,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+// userState
+func userState(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	ipStr := metadata.String(c, metadata.RemoteIP)
+	data, msg, err := unicomSvc.UserState(c, usermob, mobiApp, ipStr, build, time.Now())
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+// unicomState
+func unicomState(c *bm.Context) {
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	ipStr := metadata.String(c, metadata.RemoteIP)
+	data, err := unicomSvc.UnicomState(c, usermob, mobiApp, ipStr, build, time.Now())
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	res := map[string]interface{}{
+		"data": data,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+// unicomStateM
+func unicomStateM(c *bm.Context) {
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	ipStr := metadata.String(c, metadata.RemoteIP)
+	var (
+		_aesKey = []byte("9ed226d9")
+	)
+	bs, err := base64.StdEncoding.DecodeString(usermob)
+	if err != nil {
+		log.Error("base64.StdEncoding.DecodeString(%s) error(%v)", usermob, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	bs, err = unicomSvc.DesDecrypt(bs, _aesKey)
+	if err != nil {
+		log.Error("unicomSvc.DesDecrypt error(%v)", err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var usermobStr string
+	if len(bs) > 32 {
+		usermobStr = string(bs[:32])
+	} else {
+		usermobStr = string(bs)
+	}
+	data, err := unicomSvc.UnicomState(c, usermobStr, mobiApp, ipStr, build, time.Now())
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	res := map[string]interface{}{
+		"data": data,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+// RequestJsonToMap
+func requestJSONToMap(request *http.Request) (unicom *unicom.UnicomJson, err error) {
+	body, err := ioutil.ReadAll(request.Body)
+	if err != nil {
+		log.Error("unicom_ioutil.ReadAll error (%v)", err)
+		return
+	}
+	defer request.Body.Close()
+	if len(body) == 0 {
+		err = ecode.RequestErr
+		return
+	}
+	log.Info("unicom orders json body(%s)", body)
+	if err = json.Unmarshal(body, &unicom); err != nil {
+		log.Error("json.Unmarshal UnicomJson(%v) error (%v)", unicom, err)
+		return
+	}
+	if err = unicom.UnicomJSONChange(); err != nil {
+		log.Error("unicom.UnicomJSONChange unicom (%v) error (%v)", unicom, err)
+	}
+	return
+}
+
+// RequestIpJsonToMap
+func requestIPJSONToMap(request *http.Request) (unicom *unicom.UnicomIpJson, err error) {
+	body, err := ioutil.ReadAll(request.Body)
+	if err != nil {
+		log.Error("unicom_ioutil.ReadAll error (%v)", err)
+		return
+	}
+	defer request.Body.Close()
+	if len(body) == 0 {
+		err = ecode.RequestErr
+		return
+	}
+	log.Info("unicom ip json body(%s)", body)
+	json.Unmarshal(body, &unicom)
+	return
+}
+
+func pack(c *bm.Context) {
+	var mid int64
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	msg, err := unicomSvc.Pack(c, usermob, mid, time.Now())
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+func isUnciomIP(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	ipStr := metadata.String(c, metadata.RemoteIP)
+	ip := model.InetAtoN(ipStr)
+	if err := unicomSvc.IsUnciomIP(ip, ipStr, mobiApp, build, time.Now()); err != nil {
+		log.Error("unicom_user_ip:%v", ipStr)
+		c.JSON(nil, err)
+	}
+	res := map[string]interface{}{
+		"code": ecode.OK,
+	}
+	returnDataJSON(c, res, nil)
+}
+
+func userUnciomIP(c *bm.Context) {
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	ipStr := metadata.String(c, metadata.RemoteIP)
+	ip := model.InetAtoN(ipStr)
+	res := map[string]interface{}{}
+	res["data"] = unicomSvc.UserUnciomIP(ip, ipStr, usermob, mobiApp, build, time.Now())
+	returnDataJSON(c, res, nil)
+}
+
+func orderPay(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	channel := params.Get("channel")
+	ordertypeStr := params.Get("ordertype")
+	ordertype, _ := strconv.Atoi(ordertypeStr)
+	data, msg, err := unicomSvc.Order(c, usermob, channel, ordertype, time.Now())
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+func orderCancel(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	usermob := params.Get("usermob")
+	data, msg, err := unicomSvc.CancelOrder(c, usermob)
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+func smsCode(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phone := params.Get("phone")
+	msg, err := unicomSvc.UnicomSMSCode(c, phone, time.Now())
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+func addUnicomBind(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phone := params.Get("phone")
+	codeStr := params.Get("code")
+	code, err := strconv.Atoi(codeStr)
+	if err != nil {
+		log.Error("code(%v) strconv.Atoi error(%v)", codeStr, err)
+		res["message"] = "参数错误"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	var mid int64
+	midInter, ok := c.Get("mid")
+	if ok {
+		mid = midInter.(int64)
+	} else {
+		res["message"] = "账号未登录"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	msg, err := unicomSvc.AddUnicomBind(c, phone, code, mid, time.Now())
+	if err != nil {
+		res["code"] = err
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+func releaseUnicomBind(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	phoneStr := params.Get("phone")
+	phone, err := strconv.Atoi(phoneStr)
+	if err != nil {
+		log.Error("phone(%v) strconv.Atoi error(%v)", phoneStr, err)
+		res["message"] = "参数错误"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	var mid int64
+	midInter, ok := c.Get("mid")
+	if ok {
+		mid = midInter.(int64)
+	} else {
+		res["message"] = "账号未登录"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	msg, err := unicomSvc.ReleaseUnicomBind(c, mid, phone)
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+func userBind(c *bm.Context) {
+	res := map[string]interface{}{}
+	var mid int64
+	midInter, ok := c.Get("mid")
+	if ok {
+		mid = midInter.(int64)
+	} else {
+		res["message"] = "账号未登录"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	data, msg, err := unicomSvc.UserBind(c, mid)
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["data"] = data
+	res["message"] = ""
+	returnDataJSON(c, res, nil)
+}
+
+func packList(c *bm.Context) {
+	res := map[string]interface{}{
+		"data": unicomSvc.UnicomPackList(),
+	}
+	returnDataJSON(c, res, nil)
+}
+
+func packReceive(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	idStr := params.Get("id")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		log.Error("id(%v) strconv.ParseInt error(%v)", idStr, err)
+		c.JSON(nil, err)
+		return
+	}
+	var mid int64
+	midInter, ok := c.Get("mid")
+	if ok {
+		mid = midInter.(int64)
+	} else {
+		res["message"] = "账号未登录"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	msg, err := unicomSvc.UnicomPackReceive(c, mid, id, time.Now())
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+func flowPack(c *bm.Context) {
+	res := map[string]interface{}{}
+	params := c.Request.Form
+	var mid int64
+	midInter, ok := c.Get("mid")
+	if ok {
+		mid = midInter.(int64)
+	} else {
+		res["message"] = "账号未登录"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	flowID := params.Get("flow_id")
+	msg, err := unicomSvc.UnicomFlowPack(c, mid, flowID, time.Now())
+	if err != nil {
+		res["message"] = msg
+		returnDataJSON(c, res, err)
+		return
+	}
+	res["message"] = msg
+	returnDataJSON(c, res, nil)
+}
+
+func userPacksLog(c *bm.Context) {
+	params := c.Request.Form
+	starttimeStr := params.Get("starttime")
+	pnStr := params.Get("pn")
+	pn, err := strconv.Atoi(pnStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if pn < 1 {
+		pn = 1
+	}
+	timeLayout := "2006-01"
+	loc, _ := time.LoadLocation("Local")
+	startTime, err := time.ParseInLocation(timeLayout, starttimeStr, loc)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(unicomSvc.UserPacksLog(c, startTime, time.Now(), pn, metadata.String(c, metadata.RemoteIP)))
+}
+
+func userBindLog(c *bm.Context) {
+	res := map[string]interface{}{}
+	var mid int64
+	midInter, ok := c.Get("mid")
+	if ok {
+		mid = midInter.(int64)
+	} else {
+		res["message"] = "账号未登录"
+		returnDataJSON(c, res, ecode.RequestErr)
+		return
+	}
+	data, err := unicomSvc.UserBindLog(c, mid, time.Now())
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	res["data"] = data
+	returnDataJSON(c, res, nil)
+}
+
+func welfareBindState(c *bm.Context) {
+	params := c.Request.Form
+	midStr := params.Get("mid")
+	mid, err := strconv.ParseInt(midStr, 10, 64)
+	if err != nil || mid < 1 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	data := unicomSvc.WelfareBindState(c, mid)
+	res := map[string]interface{}{
+		"state": data,
+	}
+	c.JSON(res, nil)
+}

app/interface/main/app-wall/http/wall.go

@@ -0,0 +1,11 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+// walls get GetWall
+func walls(c *bm.Context) {
+	res := map[string]interface{}{
+		"data": wallSvc.Wall(),
+	}
+	returnDataJSON(c, res, nil)
+}