Create & Init Project...

app/service/main/up/server/gorpc/BUILD

@@ -0,0 +1,51 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["rpcserver_test.go"],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/up/model:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/davecgh/go-spew/spew:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["rpcserver.go"],
+    importpath = "go-common/app/service/main/up/server/gorpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/up/conf:go_default_library",
+        "//app/service/main/up/model:go_default_library",
+        "//app/service/main/up/service:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/net/rpc/context:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/up/server/gorpc/rpcserver.go

@@ -0,0 +1,104 @@
+package gorpc
+
+import (
+	"time"
+
+	"go-common/app/service/main/up/conf"
+	"go-common/app/service/main/up/model"
+	"go-common/app/service/main/up/service"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/rpc"
+	"go-common/library/net/rpc/context"
+)
+
+//RPC rpc server
+type RPC struct {
+	s *service.Service
+}
+
+//New create rpc
+func New(c *conf.Config, s *service.Service) (svr *rpc.Server) {
+	r := &RPC{s: s}
+	svr = rpc.NewServer(c.RPCServer)
+	if err := svr.Register(r); err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Ping check connection success.
+func (r *RPC) Ping(c context.Context, arg *struct{}, res *struct{}) (err error) {
+	return
+}
+
+// Special rpc call region
+func (r *RPC) Special(c context.Context, arg *model.ArgSpecial, res *[]*model.UpSpecial) (err error) {
+	*res = r.s.UpsByGroup(c, arg.GroupID)
+	log.Info("[rpc.Special] arg=%+v, res count=%d", arg, len(*res))
+	return
+}
+
+//Info get up info
+func (r *RPC) Info(c context.Context, arg *model.ArgInfo, res *model.UpInfo) (err error) {
+	if arg.Mid <= 0 {
+		err = ecode.RequestErr
+		log.Error("[rpc.Info] error, request mid <= 0, %d", arg.Mid)
+		return
+	}
+	isAuthor, err := r.s.Info(c, arg.Mid, uint8(arg.From))
+	if err != nil {
+		log.Error("[rpc.Info] error, mid=%d, from=%d, err=%s", arg.Mid, arg.From, err)
+		return
+	}
+	*res = model.UpInfo{IsAuthor: int32(isAuthor)}
+	//log.Info("[rpc.Info] mid=%d, from=%d, result=%+v", arg.Mid, arg.From, *res)
+	return
+}
+
+//UpStatBase get up stat
+func (r *RPC) UpStatBase(c context.Context, arg *model.ArgMidWithDate, res *model.UpBaseStat) (err error) {
+	if arg.Date.IsZero() {
+		// 如果没有填，则取最新的数据，如果有填，则取对应天数的数据，这里不需要做什么操作
+		arg.Date = time.Now()
+		// 12点更新数据，数据表为昨天日期，所以在12点以前，要读前天的表
+		arg.Date = arg.Date.Add(-12*time.Hour).AddDate(0, 0, -1)
+	}
+	var data, e = r.s.Data.BaseUpStat(c, arg.Mid, arg.Date.Format("20060102"))
+	err = e
+	if err == nil {
+		data.CopyTo(res)
+		log.Info("[rpc.UpStatBase] arg=%+v, res=%+v", arg, res)
+	} else {
+		log.Error("[rpc.UpStatBase] fail arg=%+v, err=%v", arg, err)
+	}
+	return
+}
+
+//SetUpSwitch set up switch
+func (r *RPC) SetUpSwitch(c context.Context, arg *model.ArgUpSwitch, res *model.PBSetUpSwitchRes) (err error) {
+	id, err := r.s.SetSwitch(c, arg.Mid, arg.State, uint8(arg.From))
+	if err == nil {
+		log.Info("[rpc.SetUpSwitch] arg=%+v, res=%+v", arg, res)
+	} else {
+		log.Error("[rpc.SetUpSwitch] fail arg=%+v, err=%v", arg, err)
+	}
+	*res = model.PBSetUpSwitchRes{Id: id}
+	return
+}
+
+//UpSwitch get up switch
+func (r *RPC) UpSwitch(c context.Context, arg *model.ArgUpSwitch, res *model.PBUpSwitch) (err error) {
+	if arg.Mid <= 0 {
+		err = ecode.RequestErr
+		log.Error("[rpc.UpSwitch] error, request mid <= 0, %d", arg.Mid)
+		return
+	}
+	state, err := r.s.UpSwitchs(c, arg.Mid, uint8(arg.From))
+	if err != nil {
+		log.Error("[rpc.UpSwitchs] error, mid=%d, from=%d, err=%s", arg.Mid, arg.From, err)
+		return
+	}
+	*res = model.PBUpSwitch{State: int32(state)}
+	return
+}

app/service/main/up/server/gorpc/rpcserver_test.go

@@ -0,0 +1,152 @@
+package gorpc
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/service/main/up/model"
+	"go-common/library/net/rpc"
+	xtime "go-common/library/time"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+const (
+	/*clientConfigStr = `
+		 proto = "tcp"
+	     timeout = "1s"
+	     timer = 1000
+	     token = "123456"
+	     addr = "127.0.0.1:6079"
+	     [breaker]
+	     window  = "3s"
+	     sleep   = "100ms"
+	     bucket  = 10
+	     ratio   = 0.5
+	     request = 100`*/
+
+	_Special     = "RPC.Special"
+	_Info        = "RPC.Info"
+	_SetUpSwitch = "RPC.SetUpSwitch"
+	_UpSwitch    = "RPC.UpSwitch"
+	_UpCards     = "RPC.UpCards"
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/up-service.toml")
+	flag.Set("conf", dir)
+}
+
+func initSvrAndClient(t *testing.T) (client *rpc.Client, err error) {
+	client = rpc.Dial("127.0.0.1:6079", xtime.Duration(time.Second), nil)
+	return
+}
+
+func TestInfo(t *testing.T) {
+	client, err := initSvrAndClient(t)
+	if err != nil {
+		t.Errorf("rpc.Dial error(%v)", err)
+		t.FailNow()
+	}
+	defer client.Close()
+	//time.Sleep(1 * time.Second)
+	info(client, t)
+}
+
+func info(client *rpc.Client, t *testing.T) {
+	var res *model.UpInfo
+	arg := &model.ArgInfo{
+		Mid:  2089809,
+		From: 1,
+	}
+	err := client.Call(context.TODO(), _Info, arg, &res)
+	if err != nil {
+		t.Logf("err:%v.", err)
+	}
+	spew.Dump(res)
+}
+
+func TestSpecial(t *testing.T) {
+	client, err := initSvrAndClient(t)
+	if err != nil {
+		t.Errorf("rpc.Dial error(%v)", err)
+		t.FailNow()
+	}
+	defer client.Close()
+	//time.Sleep(1 * time.Second)
+	special(client, t)
+}
+
+func special(client *rpc.Client, t *testing.T) {
+	var res []model.UpSpecial
+	arg := &model.ArgSpecial{
+		GroupID: 2,
+	}
+	err := client.Call(context.TODO(), _Special, arg, &res)
+	if err != nil {
+		t.Logf("err:%v.", err)
+	}
+	spew.Dump(res)
+}
+
+func Test_UpSwitch(t *testing.T) {
+	client, err := initSvrAndClient(t)
+	if err != nil {
+		t.Errorf("rpc.Dial error(%v)", err)
+		t.FailNow()
+	}
+	defer client.Close()
+	var res *model.PBUpSwitch
+	arg := &model.ArgUpSwitch{
+		Mid:  1,
+		From: 0,
+	}
+	err = client.Call(context.TODO(), _UpSwitch, arg, &res)
+	if err != nil {
+		t.Logf("err:%v.", err)
+	}
+	spew.Dump(11111, res)
+}
+
+func Test_SetUpSwitch(t *testing.T) {
+	client, err := initSvrAndClient(t)
+	if err != nil {
+		t.Errorf("rpc.Dial error(%v)", err)
+		t.FailNow()
+	}
+	defer client.Close()
+	var res *model.PBSetUpSwitchRes
+	arg := &model.ArgUpSwitch{
+		Mid:   1,
+		From:  0,
+		State: 1,
+	}
+	err = client.Call(context.TODO(), _SetUpSwitch, arg, &res)
+	if err != nil {
+		t.Logf("err:%v.", err)
+	}
+	spew.Dump(11111, res)
+}
+
+func Test_UpCards(t *testing.T) {
+	client, err := initSvrAndClient(t)
+	if err != nil {
+		t.Errorf("rpc.Dial error(%v)", err)
+		t.FailNow()
+	}
+	defer client.Close()
+
+	arg := &model.ListUpCardInfoArg{
+		Pn: 1,
+		Ps: 1,
+	}
+	var res *model.UpCardInfoPage
+	err = client.Call(context.TODO(), _UpCards, arg, &res)
+	if err != nil {
+		t.Logf("err:%v.", err)
+	}
+	spew.Dump(11111, res)
+}

app/service/main/up/server/grpc/BUILD

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["server.go"],
+    importpath = "go-common/app/service/main/up/server/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/up/api/v1:go_default_library",
+        "//app/service/main/up/service:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/up/server/grpc/server.go

@@ -0,0 +1,18 @@
+package grpc
+
+import (
+	uprpc "go-common/app/service/main/up/api/v1"
+	"go-common/app/service/main/up/service"
+	"go-common/library/net/rpc/warden"
+)
+
+// New new a grpc server.
+func New(cfg *warden.ServerConfig, s *service.Service) *warden.Server {
+	grpc := warden.NewServer(cfg)
+	uprpc.RegisterUpServer(grpc.Server(), s)
+	grpc, err := grpc.Start()
+	if err != nil {
+		panic(err)
+	}
+	return grpc
+}

app/service/main/up/server/http/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "http.go",
+        "up.go",
+        "up_card.go",
+        "up_group.go",
+        "up_stat.go",
+        "up_switch.go",
+    ],
+    importpath = "go-common/app/service/main/up/server/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/up/api/v1:go_default_library",
+        "//app/service/main/up/conf:go_default_library",
+        "//app/service/main/up/model:go_default_library",
+        "//app/service/main/up/service: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/permit:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/go-sql-driver/mysql:go_default_library",
+        "//vendor/github.com/siddontang/go-mysql/mysql:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/up/server/http/http.go

@@ -0,0 +1,127 @@
+package http
+
+import (
+	uphttp "go-common/app/service/main/up/api/v1"
+	"go-common/app/service/main/up/conf"
+	"go-common/app/service/main/up/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	idfSvc *verify.Verify
+	//Svc service.
+	Svc     *service.Service
+	authSrc *permit.Permit
+)
+
+// Init init account service.
+func Init(c *conf.Config, s *service.Service) {
+	// service
+	initService(c, s)
+	// init internal router
+	innerEngine := bm.DefaultServer(c.BM.Inner)
+	setupInnerEngine(innerEngine)
+	registerUpEngine(innerEngine)
+	uphttp.RegisterUpBMServer(innerEngine, s)
+	// init internal server
+	if err := innerEngine.Start(); err != nil {
+		log.Error("innerEngine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func initService(c *conf.Config, s *service.Service) {
+	idfSvc = verify.New(nil)
+	Svc = s
+	authSrc = permit.New(c.Auth)
+	Svc.SetAuthServer(authSrc)
+}
+
+// registerUpEngine .
+func registerUpEngine(e *bm.Engine) {
+	e.Inject("^/x/internal/uper/archive", idfSvc.Verify)
+}
+
+// innerRouter
+func setupInnerEngine(e *bm.Engine) {
+	// monitor ping
+	e.Ping(ping)
+	e.Register(disRegister)
+	// base
+	var base, admin *bm.RouterGroup
+	if conf.Conf.IsTest {
+		base = e.Group("/x/internal/uper")
+		admin = e.Group("/x/admin/uper")
+	} else {
+		base = e.Group("/x/internal/uper", idfSvc.Verify)
+		// 现在只要登录，默认放过
+		admin = e.Group("/x/admin/uper", authSrc.Verify(), authSrc.Permit("PRIORITY_UP"))
+	}
+	{
+		base.POST("/register", register)
+		base.GET("/info", info)
+		base.GET("/all", all)
+		base.GET("/special", specialUps)
+		base.GET("/stat/base", baseStat)
+		base.GET("/info/active", active)
+		base.GET("/info/actives", actives)
+		//播放器关注按钮开关
+		base.POST("/switch/set", switchSet)
+		base.GET("/switch", upSwitch)
+		//人物卡片
+		base.GET("/card/all", listCardBase)
+		base.GET("/card/info", getCardInfo)
+		base.GET("/card/info/list", listCardDetail)
+		base.GET("/card/info/list_by_mids", listCardByMids)
+
+		// 下面接口在admin中也有
+		base.GET("/special/get", specialGet)
+		base.GET("/group/get", getGroup)
+		base.GET("/special/get_by_mid", specialGetByMid)
+
+		// list_up
+		base.GET("/list_up", listUp)
+	}
+
+	admin.GET("/special/get", specialGet)
+	admin.GET("/special/get_by_mid", specialGetByMid)
+	admin.POST("/special/delete", specialDel)
+	admin.POST("/special/add", specialAdd)
+	admin.POST("/special/edit", specialEdit)
+	admin.GET("/group/get", getGroup)
+	admin.POST("/group/add", authSrc.Permit("UPGROUP_ADD"), addGroup)
+	admin.POST("/group/update", updateGroup)
+	admin.POST("/group/delete", authSrc.Permit("UPGROUP_ADD"), removeGroup)
+}
+
+// ping check server ok.
+func ping(ctx *bm.Context) {
+	if err := Svc.Ping(ctx); err != nil {
+		ctx.Error = err
+		ctx.AbortWithStatus(503)
+	}
+}
+
+// disRegister check server ok.
+func disRegister(ctx *bm.Context) {
+	ctx.JSON(map[string]interface{}{}, nil)
+}
+
+//bmGetStringOrDefault get string
+func bmGetStringOrDefault(c *bm.Context, key string, defaul string) (value string, exist bool) {
+	i, exist := c.Get(key)
+
+	if !exist {
+		value = defaul
+		return
+	}
+
+	value, exist = i.(string)
+	if !exist {
+		value = defaul
+	}
+	return
+}

app/service/main/up/server/http/up.go

@@ -0,0 +1,531 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"encoding/csv"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/service/main/up/model"
+	"go-common/app/service/main/up/service"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/siddontang/go-mysql/mysql"
+)
+
+func register(ctx *bm.Context) {
+	param := ctx.Request.Form
+	midStr := param.Get("mid")
+	fromStr := param.Get("from")
+	isAuthorStr := param.Get("is_author")
+	// check params
+	mid, err := strconv.ParseInt(midStr, 10, 64)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", midStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if mid <= 0 {
+		log.Error("register error mid (%d)", mid)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	from, err := strconv.Atoi(fromStr)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", fromStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	isAuthor, err := strconv.Atoi(isAuthorStr)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", isAuthorStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	result := 0
+	row, err := Svc.Edit(ctx, mid, isAuthor, uint8(from))
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	if row > 0 {
+		result = 1
+	}
+	ctx.JSON(map[string]interface{}{
+		"result": result,
+	}, nil)
+}
+
+func info(ctx *bm.Context) {
+	param := ctx.Request.Form
+	midStr := param.Get("mid")
+	fromStr := param.Get("from")
+	// check params
+	mid, err := strconv.ParseInt(midStr, 10, 64)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", midStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if mid <= 0 {
+		log.Error("info error mid (%d)", mid)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	from, err := strconv.Atoi(fromStr)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", fromStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	isAuthor, err := Svc.Info(ctx, mid, uint8(from))
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	ctx.JSON(map[string]interface{}{
+		"is_author": isAuthor,
+	}, nil)
+}
+
+func all(ctx *bm.Context) {
+	param := ctx.Request.Form
+	midStr := param.Get("mid")
+	ip := metadata.String(ctx, metadata.RemoteIP)
+	// check params
+	mid, err := strconv.ParseInt(midStr, 10, 64)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", midStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if mid <= 0 {
+		log.Error("up all error mid (%d)", mid)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	identifyAll, err := Svc.IdentifyAll(ctx, mid, ip)
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	ctx.JSON(map[string]interface{}{
+		"identify": identifyAll,
+	}, nil)
+}
+
+// flows get specialUps list
+func specialUps(c *bm.Context) {
+	var res interface{}
+	params := c.Request.Form
+	groupStr := params.Get("group_id")
+	var err error
+	// check params
+	//default all groups
+	groupID := int64(0)
+	if groupStr != "" {
+		groupID, err = strconv.ParseInt(groupStr, 10, 64)
+		if err != nil {
+			log.Error("strconv.ParseInt(groupStr(%s)) error(%v)", groupStr, err)
+			err = ecode.RequestErr
+			c.JSON(res, err)
+			return
+		}
+	}
+	res = Svc.UpsByGroup(c, groupID)
+	c.JSON(res, err)
+}
+
+func specialDel(c *bm.Context) {
+	var res interface{}
+	var err error
+	var r = new(struct {
+		Ids string `form:"ids" validate:"required"`
+	})
+	if err = c.Bind(r); err != nil {
+		log.Error("params error, err=%v", err)
+		err = ecode.RequestErr
+		c.JSON(res, err)
+		return
+	}
+	var idstr = strings.Split(r.Ids, ",")
+	for _, s := range idstr {
+		var affectedRow int64
+		var id, e = strconv.ParseInt(s, 10, 64)
+		err = e
+		if err != nil {
+			log.Error("id is not integer, id=%s", s)
+			continue
+		}
+		affectedRow, err = Svc.SpecialDel(c, id)
+		log.Info("delete special up, id=%d, affected=%d, err=%v", id, affectedRow, err)
+	}
+	c.JSON(res, err)
+}
+
+func specialAdd(c *bm.Context) {
+	var res interface{}
+	var err error
+	var errMsg string
+	var r = new(struct {
+		GroupIds string `form:"group_ids" validate:"required"` // 支持多个group id，用,分隔
+		MidStr   string `form:"mids" validate:"required"`      // 支持多个mid，用,分隔
+		Note     string `form:"note" default:""`
+	})
+	switch {
+	default:
+		if err = c.Bind(r); err != nil {
+			log.Error("params error, err=%v", err)
+			err = ecode.RequestErr
+			errMsg = "params error"
+			break
+		}
+		var groupIds = strings.Split(r.GroupIds, ",")
+		// 检查是否有特殊权限
+		for _, groupIDStr := range groupIds {
+			var groupID, _ = strconv.ParseInt(groupIDStr, 10, 64)
+			var e = Svc.SpecialGroupPermit(c, groupID)
+			if e != nil {
+				err = e
+				break
+			}
+		}
+		var midStrArray = strings.Split(r.MidStr, ",")
+		if len(midStrArray) == 0 {
+			log.Error("params error, no mid got, mid=%s", r.MidStr)
+			err = ecode.RequestErr
+			errMsg = "params error, no mid got"
+			break
+		}
+		var mids []int64
+		for _, v := range midStrArray {
+			mid, e := strconv.ParseInt(v, 10, 64)
+			if e != nil {
+				continue
+			}
+			mids = append(mids, int64(mid))
+		}
+		if len(mids) == 0 {
+			log.Error("params error, wrong mid got, mid=%s", r.MidStr)
+			err = ecode.RequestErr
+			errMsg = "params error, wrong mid got"
+			break
+		}
+
+		uidtemp, ok := c.Get("uid")
+		var uid int64
+		if ok {
+			uid = uidtemp.(int64)
+		}
+
+		if len(groupIds) == 0 {
+			log.Error("params error, no group id got, groupid=%s", r.GroupIds)
+			err = ecode.RequestErr
+			errMsg = "params error, wrong mid got"
+			break
+		}
+		var uname, _ = bmGetStringOrDefault(c, "username", "unkown")
+		for _, groupIDStr := range groupIds {
+			var groupID, err2 = strconv.ParseInt(groupIDStr, 10, 64)
+			if err2 != nil {
+				log.Warn("group id convert fail, group id=%s", groupIDStr)
+				continue
+			}
+			var data = &model.UpSpecial{
+				GroupID: groupID,
+				Note:    r.Note,
+				UID:     uid,
+			}
+			go func() {
+				const step = 100
+				for start := 0; start < len(mids); start += step {
+					var end = start + step
+					if end > len(mids) {
+						end = len(mids)
+					}
+					_, err = Svc.SpecialAdd(context.Background(), uname, data, mids[start:end]...)
+					if err != nil {
+						log.Error("add special fail, mid=%s, err=%v", r.MidStr, err)
+						errMsg = "server error"
+						return
+					}
+					log.Info("add special, id=%v, group id=%d", mids, groupID)
+				}
+
+			}()
+
+		}
+
+	}
+
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+		c.JSON(res, err)
+	}
+}
+
+func specialEdit(c *bm.Context) {
+	var res interface{}
+	var err error
+	var errMsg string
+	var r = new(struct {
+		GroupID int64  `form:"group_id" validate:"required"`
+		Mid     int64  `form:"mid"`
+		ID      int64  `form:"id" validate:"required"`
+		Note    string `form:"note" default:""`
+	})
+	switch {
+	default:
+		if err = c.Bind(r); err != nil {
+			log.Error("request argument bind fail, err=%v", err)
+			errMsg = fmt.Sprintf("wrong argument, %s", err.Error())
+			err = ecode.RequestErr
+			break
+		}
+		// 检查是否有特殊权限
+		err = Svc.SpecialGroupPermit(c, r.GroupID)
+		if err != nil {
+			break
+		}
+
+		uidtemp, ok := c.Get("uid")
+		var uid int64
+		if ok {
+			uid = uidtemp.(int64)
+		}
+		var data = &model.UpSpecial{
+			GroupID: r.GroupID,
+			Note:    r.Note,
+			UID:     uid,
+			ID:      r.ID,
+		}
+
+		_, err = Svc.SpecialEdit(c, data, r.ID)
+		if err != nil {
+			log.Error("fail edit ups, err=%v, info=%v", err, data)
+			errMsg = err.Error()
+			break
+		}
+		log.Info("edit ups successful, info=%v", data)
+	}
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+		c.JSON(res, err)
+	}
+}
+
+// 支持更多的条件类型
+func specialGet(c *bm.Context) {
+	var data interface{}
+	var err error
+	var errMsg string
+	var r = new(model.GetSpecialArg)
+	var ups []*model.UpSpecialWithName
+	switch {
+	default:
+		if err = c.Bind(r); err != nil {
+			log.Error("request argument bind fail, err=%v", err)
+			errMsg = fmt.Sprintf("wrong argument, %s", err.Error())
+			err = ecode.RequestErr
+			break
+		}
+
+		if r.Pn == 0 {
+			r.Pn = 1
+		}
+		if r.Ps == 0 {
+			r.Ps = 20
+		}
+		if r.Ps > 100 {
+			r.Ps = 100
+		}
+		if r.Ps < 5 {
+			r.Ps = 5
+		}
+		uidtemp, ok := c.Get("uid")
+		var uid int64
+		if ok {
+			uid, _ = uidtemp.(int64)
+		}
+
+		var total int
+		ups, total, err = Svc.SpecialGet(c, r)
+		if err != nil {
+			log.Error("fail to get special, err=%v, arg=%+v", err, r)
+			errMsg = err.Error()
+			err = ecode.ServerErr
+			break
+		}
+		log.Info("get special successful, arg=%+v, result count=%d", len(ups), uid)
+		data = model.UpsPage{
+			Items: ups,
+			Pager: &model.Pager{Num: r.Pn, Size: r.Ps, Total: total},
+		}
+	}
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+
+		if r.Export == "csv" {
+			c.Writer.Header().Set("Content-Type", "application/csv")
+			c.Writer.Header().Set("Content-Disposition", fmt.Sprintf("attachment;filename=\"up_special_%s.csv\"", time.Now().Format(mysql.TimeFormat)))
+
+			var buf = &bytes.Buffer{}
+			var csvWriter = csv.NewWriter(buf)
+			csvWriter.Write((&model.UpSpecialWithName{}).GetTitleFields())
+			for _, v := range ups {
+				csvWriter.Write(v.ToStringFields())
+			}
+			csvWriter.Flush()
+			c.Writer.Write(buf.Bytes())
+		} else {
+			c.JSON(data, err)
+		}
+	}
+}
+
+func specialGetByMid(c *bm.Context) {
+	var data interface{}
+	var err error
+	var errMsg string
+	var r = new(model.GetSpecialByMidArg)
+	switch {
+	default:
+		if err = c.Bind(r); err != nil {
+			log.Error("request argument bind fail, err=%v", err)
+			errMsg = fmt.Sprintf("wrong argument, %s", err.Error())
+			err = ecode.RequestErr
+			break
+		}
+
+		uidtemp, ok := c.Get("uid")
+		var uid int64
+		if ok {
+			uid = uidtemp.(int64)
+		}
+		var ups []*model.UpSpecial
+		ups, err = Svc.SpecialGetByMid(c, r)
+		if err != nil {
+			log.Error("fail to get special, err=%v, arg=%+v", err, r)
+			errMsg = err.Error()
+			err = ecode.ServerErr
+			break
+		}
+		log.Info("get special successful, arg=%+v, result count=%d", len(ups), uid)
+		data = ups
+	}
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+		c.JSON(data, err)
+	}
+}
+
+func listUp(c *bm.Context) {
+	var (
+		mids      []int64
+		newLastID int64
+		err       error
+		errMsg    string
+		arg       = new(model.ListUpBaseArg)
+	)
+	switch {
+	default:
+		if err = c.Bind(arg); err != nil {
+			log.Error("request argument bind fail, err=%v", err)
+			errMsg = err.Error()
+			err = ecode.RequestErr
+			break
+		}
+		if !arg.Validate() {
+			errMsg, err = "illegal argument", ecode.RequestErr
+			break
+		}
+		if arg.Size == 0 {
+			arg.Size = 100
+		}
+
+		mids, newLastID, err = Svc.ListUpBase(c, arg.Size, arg.LastID, arg.Activity)
+
+		if err != nil {
+			log.Error("fail to get special, err=%v, arg=%v", err, arg)
+			errMsg = err.Error()
+			err = ecode.ServerErr
+			break
+		}
+	}
+
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+		return
+	}
+
+	c.JSON(map[string]interface{}{
+		"result":  mids,
+		"last_id": newLastID,
+	}, nil)
+}
+
+func active(ctx *bm.Context) {
+	var (
+		err    error
+		errMsg string
+		req    = new(model.UpInfoActiveReq)
+	)
+
+	if err = ctx.Bind(req); err != nil {
+		log.Error("request param error: req: %+v, err: %+v", req, err)
+		return
+	}
+	if req.Mid <= 0 {
+		log.Error("param error mid: %d", req.Mid)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	log.Info("req: %+v", req)
+	res, err := Svc.GetUpInfoActive(ctx, req)
+	if err != nil {
+		log.Error("Svc.GetUpInfoActive error: %+v", err)
+		service.BmHTTPErrorWithMsg(ctx, err, errMsg)
+		return
+	}
+
+	ctx.JSON(res, nil)
+}
+
+func actives(ctx *bm.Context) {
+	var (
+		err    error
+		errMsg string
+		req    = new(model.UpsInfoActiveReq)
+	)
+
+	if err = ctx.Bind(req); err != nil {
+		log.Error("request param error: req: %+v, err: %+v", req, err)
+		return
+	}
+	if len(req.Mids) <= 0 {
+		log.Error("param error mids: %+v", req.Mids)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	log.Info("req: %+v", req)
+	res, err := Svc.GetUpsInfoActive(ctx, req)
+	if err != nil {
+		log.Error("Svc.GetUpsInfoActive error: %+v", err)
+		service.BmHTTPErrorWithMsg(ctx, err, errMsg)
+		return
+	}
+
+	ctx.JSON(res, nil)
+}

app/service/main/up/server/http/up_card.go

@@ -0,0 +1,99 @@
+package http
+
+import (
+	"strconv"
+	"strings"
+
+	"go-common/app/service/main/up/model"
+	"go-common/app/service/main/up/service"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/http/blademaster"
+)
+
+func getCardInfo(ctx *blademaster.Context) {
+
+	var r = new(model.GetCardByMidArg)
+	if err := ctx.Bind(r); err != nil {
+		log.Error("request argument bind fail, err=%v", err)
+		err = ecode.RequestErr
+		return
+	}
+
+	// check params
+	mid := r.Mid
+	if mid <= 0 {
+		log.Error("getCardInfo error mid (%d)", mid)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	card, err := Svc.GetCardInfo(ctx, mid)
+	if err != nil {
+		service.BmHTTPErrorWithMsg(ctx, ecode.ServerErr, err.Error())
+		return
+	}
+	ctx.JSON(card, err)
+}
+
+func listCardBase(ctx *blademaster.Context) {
+	mids, err := Svc.ListCardBase(ctx)
+
+	if err != nil {
+		service.BmHTTPErrorWithMsg(ctx, ecode.ServerErr, err.Error())
+		return
+	}
+
+	ctx.JSON(map[string]interface{}{
+		"mids": mids,
+	}, nil)
+}
+
+func listCardDetail(ctx *blademaster.Context) {
+	arg := new(model.ListUpCardInfoArg)
+	if err := ctx.Bind(arg); err != nil {
+		log.Error("request argument bind fail, err=%v", err)
+		err = ecode.RequestErr
+		return
+	}
+
+	offset := (arg.Pn - 1) * arg.Ps
+	cards, total, err := Svc.ListCardDetail(ctx, offset, arg.Ps)
+	if err != nil {
+		service.BmHTTPErrorWithMsg(ctx, ecode.ServerErr, err.Error())
+		return
+	}
+
+	var data = &model.UpCardInfoPage{
+		Cards: cards,
+		Page:  &model.Pager{Num: arg.Pn, Size: uint(len(cards)), Total: total},
+	}
+
+	ctx.JSON(data, nil)
+}
+
+func listCardByMids(ctx *blademaster.Context) {
+	arg := new(model.ListCardByMidsArg)
+	if err := ctx.Bind(arg); err != nil {
+		log.Error("request argument bind fail, err=%v", err)
+		err = ecode.RequestErr
+		return
+	}
+
+	var mids []int64
+	midStrs := strings.Split(arg.Mids, ",")
+	for _, midStr := range midStrs {
+		mid, e := strconv.ParseInt(strings.Trim(midStr, " \n"), 10, 64)
+		if e != nil {
+			continue
+		}
+		mids = append(mids, mid)
+	}
+
+	cards, err := Svc.GetCardInfoByMids(ctx, mids)
+	if err != nil {
+		service.BmHTTPErrorWithMsg(ctx, ecode.ServerErr, err.Error())
+		return
+	}
+	ctx.JSON(cards, nil)
+}

app/service/main/up/server/http/up_group.go

@@ -0,0 +1,155 @@
+package http
+
+import (
+	"go-common/app/service/main/up/model"
+	"go-common/app/service/main/up/service"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/http/blademaster"
+
+	"github.com/go-sql-driver/mysql"
+)
+
+func addGroup(c *blademaster.Context) {
+	var res interface{}
+	var err error
+	var errMsg string
+	var r = new(model.AddGroupArg)
+	switch {
+	default:
+		if err = c.Bind(r); err != nil {
+			errMsg = err.Error()
+			err = ecode.RequestErr
+			log.Error("request error, err=%v, req=%v", err, r)
+			break
+		}
+
+		dbresult, err2 := Svc.AddGroup(c, r)
+		if err2 != nil {
+			log.Error("add group error, err=%v, req=%v", err2, r)
+			if _, ok := err2.(*mysql.MySQLError); ok {
+				errMsg = "db error"
+			} else {
+				errMsg = err2.Error()
+			}
+			err = ecode.ServerErr
+			break
+		}
+		var lastID, _ = dbresult.LastInsertId()
+		log.Info("add group ok, req=%+v, last id=%d", r, lastID)
+	}
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+		c.JSON(res, err)
+	}
+}
+
+func updateGroup(c *blademaster.Context) {
+	var res interface{}
+	var err error
+	var errMsg string
+	var r = new(model.EditGroupArg)
+	switch {
+	default:
+		r.AddArg = new(model.AddGroupArg)
+		if err = c.Bind(r.AddArg); err != nil {
+			errMsg = err.Error()
+			err = ecode.RequestErr
+			log.Error("request error, err=%v, req=%v", err, r)
+			break
+		}
+
+		if err = c.Bind(r); err != nil {
+			errMsg = err.Error()
+			err = ecode.RequestErr
+			log.Error("request error, err=%v, req=%v", err, r)
+			break
+		}
+
+		dbresult, err2 := Svc.UpdateGroup(c, r)
+		if err2 != nil {
+			log.Error("update group error, err=%v, req=%v", err, r)
+			if me, ok := err2.(*mysql.MySQLError); ok {
+				switch me.Number {
+				case 1062:
+					errMsg = "重复数据已存在"
+				default:
+					errMsg = "db error"
+				}
+			} else {
+				errMsg = err2.Error()
+			}
+			err = ecode.ServerErr
+			break
+		}
+		var affected, _ = dbresult.RowsAffected()
+		log.Info("update group ok, req=%+v, affected count=%d", r, affected)
+	}
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+		c.JSON(res, err)
+	}
+}
+
+func removeGroup(c *blademaster.Context) {
+	var res interface{}
+	var err error
+	var errMsg string
+	var r = new(model.RemoveGroupArg)
+	switch {
+	default:
+		if err = c.Bind(r); err != nil {
+			errMsg = err.Error()
+			err = ecode.RequestErr
+			log.Error("request error, err=%v, req=%v", err, r)
+			break
+		}
+
+		dbresult, err2 := Svc.RemoveGroup(c, r)
+		if err2 != nil {
+			log.Error("remove group error, err=%v, req=%v", err, r)
+			errMsg = err2.Error()
+			err = ecode.ServerErr
+			break
+		}
+		var affected, _ = dbresult.RowsAffected()
+		log.Info("remove group ok, req=%+v, affected count=%d", r, affected)
+	}
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+		c.JSON(res, err)
+	}
+}
+
+func getGroup(c *blademaster.Context) {
+	var res interface{}
+	var err error
+	var errMsg string
+	var r = &model.GetGroupArg{State: 1}
+	switch {
+	default:
+		if err = c.Bind(r); err != nil {
+			errMsg = err.Error()
+			err = ecode.RequestErr
+			log.Error("request error, err=%v, req=%v", err, r)
+			break
+		}
+		groups, e := Svc.GetGroup(c, r)
+		if e != nil {
+			log.Error("get group error, err=%v", e)
+			errMsg = e.Error()
+			err = ecode.ServerErr
+			break
+		}
+		res = groups
+		log.Info("get group ok, count=%d", len(groups))
+	}
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+		c.JSON(res, err)
+	}
+}

app/service/main/up/server/http/up_stat.go

@@ -0,0 +1,48 @@
+package http
+
+import (
+	"fmt"
+
+	"go-common/app/service/main/up/service"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func baseStat(c *bm.Context) {
+	var arg = new(struct {
+		Mid  int64  `form:"mid" validate:"required"`
+		Date string `form:"date" validate:"required"`
+	})
+	var res interface{}
+	var err error
+	var errMsg string
+	switch {
+	default:
+		if err = c.Bind(arg); err != nil {
+			log.Error("request argument bind fail, err=%v", err)
+			errMsg = fmt.Sprintf("wrong argument, %s", err.Error())
+			err = ecode.RequestErr
+			break
+		}
+
+		var date = arg.Date
+		var mid = arg.Mid
+		var d, e = Svc.Data.BaseUpStat(c, mid, date)
+		err = e
+		if err != nil {
+			log.Error("get hbase fail, mid=%d, err=%v", mid, err)
+			return
+		}
+		log.Info("get from hbase ok, mid=%d, stat=%+v", mid, d)
+		res = map[string]interface{}{
+			"stat": d,
+		}
+	}
+
+	if err != nil {
+		service.BmHTTPErrorWithMsg(c, err, errMsg)
+	} else {
+		c.JSON(res, err)
+	}
+}

app/service/main/up/server/http/up_switch.go

@@ -0,0 +1,78 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func switchSet(ctx *bm.Context) {
+	param := ctx.Request.Form
+	midStr := param.Get("mid")
+	fromStr := param.Get("from")
+	stateStr := param.Get("state")
+	// check params
+	mid, err := strconv.ParseInt(midStr, 10, 64)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", midStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if mid <= 0 {
+		log.Error("switchSet error mid (%d)", mid)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	from, err := strconv.ParseUint(fromStr, 10, 64)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", fromStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	state, err := strconv.Atoi(stateStr)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", stateStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	row, err := Svc.SetSwitch(ctx, mid, state, uint8(from))
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	ctx.JSON(row, nil)
+}
+
+func upSwitch(ctx *bm.Context) {
+	param := ctx.Request.Form
+	midStr := param.Get("mid")
+	fromStr := param.Get("from")
+	// check params
+	mid, err := strconv.ParseInt(midStr, 10, 64)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", midStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if mid <= 0 {
+		log.Error("upSwitch error mid(%d)", mid)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	from, err := strconv.Atoi(fromStr)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", fromStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	state, err := Svc.UpSwitchs(ctx, mid, uint8(from))
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	ctx.JSON(map[string]interface{}{
+		"state": state,
+	}, nil)
+}