Create & Init Project...

app/service/main/workflow/http/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "business.go",
+        "challenge.go",
+        "group.go",
+        "http.go",
+        "sign.go",
+        "sobot.go",
+        "tag.go",
+    ],
+    importpath = "go-common/app/service/main/workflow/http",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/workflow/conf:go_default_library",
+        "//app/service/main/workflow/model:go_default_library",
+        "//app/service/main/workflow/model/account:go_default_library",
+        "//app/service/main/workflow/model/sobot:go_default_library",
+        "//app/service/main/workflow/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/binding:go_default_library",
+        "//library/net/http/blademaster/middleware/verify: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/workflow/http/business.go

@@ -0,0 +1,34 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+// UpBusinessExtra update business extra
+func upBusinessExtra(c *bm.Context) {
+	ap := new(struct {
+		Cid      int32  `form:"cid" validate:"required"`
+		Mid      int64  `form:"mid" validate:"required"`
+		Business int8   `form:"business" validate:"required"`
+		Key      string `form:"key" validate:"required"`
+		Val      string `form:"val" validate:"required"`
+	})
+	if err := c.BindWith(ap, binding.FormPost); err != nil {
+		return
+	}
+	c.JSON(nil, wkfSvc.UpBusinessExtraV2(c, ap.Cid, ap.Mid, ap.Business, ap.Key, ap.Val))
+}
+
+// BusinessExtra get business extra
+func businessExtra(c *bm.Context) {
+	ap := new(struct {
+		Cid      int32 `form:"cid" validate:"required"`
+		Mid      int64 `form:"mid" validate:"required"`
+		Business int8  `form:"business" validate:"required"`
+	})
+	if err := c.Bind(ap); err != nil {
+		return
+	}
+	c.JSON(wkfSvc.BusinessExtraV2(c, ap.Cid, ap.Mid, ap.Business))
+}

app/service/main/workflow/http/challenge.go

@@ -0,0 +1,194 @@
+package http
+
+import (
+	"strconv"
+	"strings"
+
+	"go-common/app/service/main/workflow/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+// AddChallenge add challenge
+func addChallenge(c *bm.Context) {
+	ap := new(model.ChallengeParam)
+	if err := c.BindWith(ap, binding.FormPost); err != nil {
+		return
+	}
+	if ap.AttachmentsStr != "" {
+		ap.Attachments = strings.Split(ap.AttachmentsStr, ",")
+	}
+	if wkfSvc.TagMap(ap.Business, ap.Tid) == nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	for _, ctrl := range wkfSvc.TagMap(ap.Business, ap.Tid).Controls {
+		if ctrlValue := c.Request.PostForm.Get(ctrl.Name); ctrlValue != "" {
+			ap.MetaData += ctrl.Name + ": " + ctrlValue + "\n"
+		} else if ctrl.Required {
+			log.Error("http addChallenge() control parms error ctrl.Name(%s) is required!  ap(%+v)", ctrl.Name, ap)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		} else {
+			log.Info("http addChallenge() control parms missing ctrl.Name(%s) but not required ap(%+v)", ctrl.Name, ap)
+			continue
+		}
+	}
+	if !ap.CheckAdd() {
+		log.Error("s.AddChallenge() params(%+v) error", ap)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	challengeNo, err := wkfSvc.AddChallenge(c, ap)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	data := map[string]int64{
+		"challengeNo": challengeNo,
+	}
+	c.JSON(data, nil)
+}
+
+// ListChallenge get challenge list
+func listChallenge(c *bm.Context) {
+	ap := new(model.ChallengeParam)
+	if err := c.Bind(ap); err != nil {
+		return
+	}
+	if !ap.CheckList() {
+		log.Error("s.Challenges() params(%+v) error", ap)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(wkfSvc.Challenges(c, ap))
+}
+
+// ReplyAddChallenge add reply to challenge
+func replyAddChallenge(c *bm.Context) {
+	rp := new(struct {
+		Cid         int32  `form:"cid" validate:"required"`
+		Event       int8   `form:"event" validate:"required"`
+		Content     string `form:"content" validate:"required"`
+		Attachments string `form:"attachments"`
+	})
+	if err := c.BindWith(rp, binding.FormPost); err != nil {
+		return
+	}
+	_, err := wkfSvc.AddEvent(c, rp.Cid, rp.Content, rp.Attachments, rp.Event)
+	c.JSON(nil, err)
+}
+
+// ChallengeInfo get challenge info
+func challengeInfo(c *bm.Context) {
+	ap := new(model.ChallengeParam)
+	if err := c.Bind(ap); err != nil {
+		return
+	}
+	if !ap.CheckInfo() {
+		log.Error("s.Challenge() params(%+v) error", ap)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(wkfSvc.Challenge(c, ap))
+}
+
+// upChallengeState update challenge business state
+func upChallengeState(c *bm.Context) {
+	var role int8
+	ap := new(struct {
+		ID            int32 `form:"id" validate:"required"`
+		Mid           int64 `form:"mid" validate:"required"`
+		Business      int8  `form:"business" validate:"required"`
+		BusinessState int8  `form:"business_state"`
+	})
+	roleStr := c.Request.PostForm.Get("role")
+	if roleStr == "" {
+		role = model.CustomerServiceRole
+	} else {
+		result, err := strconv.ParseUint(roleStr, 10, 8)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			c.Abort()
+			return
+		}
+		role = int8(result)
+	}
+	if err := c.BindWith(ap, binding.FormPost); err != nil {
+		return
+	}
+	c.JSON(nil, wkfSvc.UpChallengeState(c, ap.ID, ap.Mid, ap.Business, role, ap.BusinessState))
+}
+
+// CloseChallenge make challenge business state closed
+func closeChallenge(c *bm.Context) {
+	ap := new(struct {
+		Cid           int32  `form:"cid" validate:"required"`
+		Business      int8   `form:"business" validate:"required"`
+		Role          int8   `form:"role" validate:"required"`
+		BusinessState int8   `form:"business_state"`
+		Note          string `form:"note" validate:"required"`
+	})
+	if err := c.Bind(ap); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, wkfSvc.CloseChallenge(c, ap.Cid, ap.Business, ap.Role, ap.BusinessState, ap.Note))
+}
+
+// untreatedChallenge get untreated challenge
+func untreatedChallenge(c *bm.Context) {
+	ap := new(struct {
+		Oid  int64 `form:"oid" validate:"required"`
+		Role int8  `form:"role" validate:"required"`
+	})
+	if err := c.Bind(ap); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(wkfSvc.UntreatedChallenge(c, ap.Oid, ap.Role))
+}
+
+// addChallenge3 add challange v3
+func addChallenge3(c *bm.Context) {
+	cp3 := &model.ChallengeParam3{}
+	if err := c.Bind(cp3); err != nil {
+		return
+	}
+	challengeNo, err := wkfSvc.AddChallenge3(c, cp3)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	data := map[string]int64{
+		"challengeNo": challengeNo,
+	}
+	c.JSON(data, nil)
+}
+
+// listChallenge3 .
+func listChallenge3(c *bm.Context) {
+	cp3 := &model.ChallengeParam3{}
+	if err := c.Bind(cp3); err != nil {
+		return
+	}
+	c.JSON(wkfSvc.Challenges3(c, cp3))
+}
+
+// groupState3 .
+func groupState3(c *bm.Context) {
+	cp3 := &model.ChallengeParam3{}
+	if err := c.Bind(cp3); err != nil {
+		return
+	}
+	state, err := wkfSvc.GroupState3(c, cp3)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{
+		"state": state,
+	}, err)
+}

app/service/main/workflow/http/group.go

@@ -0,0 +1,24 @@
+package http
+
+import (
+	"go-common/app/service/main/workflow/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// deleteGroup delete group .
+func deleteGroup(c *bm.Context) {
+	p := &model.DeleteGroupParams{}
+	if err := c.Bind(p); err != nil {
+		return
+	}
+	c.JSON(nil, wkfSvc.DeleteGroup(c, p))
+}
+
+// pubRefereeGroup delete group .
+func pubRefereeGroup(c *bm.Context) {
+	p := &model.PublicRefereeGroupParams{}
+	if err := c.Bind(p); err != nil {
+		return
+	}
+	c.JSON(nil, wkfSvc.PublicRefereeGroup(c, p))
+}

app/service/main/workflow/http/http.go

@@ -0,0 +1,88 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/service/main/workflow/conf"
+	"go-common/app/service/main/workflow/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	verifySrv *verify.Verify
+	wkfSvc    *service.Service
+)
+
+// Init http server
+func Init(c *conf.Config, svc *service.Service) {
+	wkfSvc = svc
+	verifySrv = verify.New(c.Verify)
+	engine := bm.DefaultServer(c.BM)
+	innerRouter(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start() error(%v)", err)
+		panic(err)
+	}
+}
+
+// innerRouter
+func innerRouter(e *bm.Engine) {
+	e.Ping(ping)
+	wkfG := e.Group("/x/internal/workflow")
+	{
+		wkfG.POST("/add", verifySrv.Verify, addChallenge)
+		wkfG.GET("/close", verifySrv.Verify, closeChallenge)
+		wkfG.GET("/info", verifySrv.Verify, challengeInfo)
+		wkfG.GET("/list", verifySrv.Verify, listChallenge)
+		wkfG.POST("/update/state", verifySrv.Verify, upChallengeState)
+		wkfG.GET("/extra/info", verifySrv.Verify, businessExtra)
+		wkfG.POST("/extra/up", verifySrv.Verify, upBusinessExtra)
+		wkfG.POST("/reply/add", verifySrv.Verify, replyAddChallenge)
+		wkfG.GET("/untreated", verifySrv.Verify, untreatedChallenge)
+		appealG := wkfG.Group("/appeal")
+		{
+			appealG.POST("/add", verifySrv.Verify, addChallenge)
+			appealG.GET("/close", verifySrv.Verify, closeChallenge)
+			appealG.GET("/info", verifySrv.Verify, challengeInfo)
+			appealG.GET("/list", verifySrv.Verify, listChallenge)
+			appealG.POST("/state", verifySrv.Verify, upChallengeState)
+			appealG.GET("/extra/info", verifySrv.Verify, businessExtra)
+			appealG.POST("/extra/up", verifySrv.Verify, upBusinessExtra)
+			appealG.POST("/reply/add", verifySrv.Verify, replyAddChallenge)
+		}
+		appealG3 := wkfG.Group("/appeal/v3")
+		{
+			appealG3.POST("/add", verifySrv.Verify, addChallenge3)
+			appealG3.GET("/list", verifySrv.Verify, listChallenge3)
+			appealG3.GET("/state", verifySrv.Verify, groupState3)
+			appealG3.POST("/delete", verifySrv.Verify, deleteGroup)
+			appealG3.POST("/public/referee", verifySrv.Verify, pubRefereeGroup)
+		}
+		tagG3 := wkfG.Group("/tag/v3", verifySrv.Verify)
+		{
+			tagG3.GET("/list", tagList3)
+		}
+		tagG := wkfG.Group("/tag", verifySrv.Verify)
+		{
+			tagG.GET("/list", tagList)
+		}
+		sobotG := wkfG.Group("/sobot")
+		{
+			sobotG.GET("/user", sobotSign(sobotFetchUser))
+			sobotG.GET("/ticket/info", verifySrv.Verify, sobotInfoTicket)
+			sobotG.POST("/ticket/add", verifySrv.Verify, sobotAddTicket)
+			sobotG.POST("/ticket/modify", verifySrv.Verify, sobotModifyTicket)
+			sobotG.POST("/reply/add", verifySrv.Verify, sobotAddReply)
+		}
+	}
+}
+
+// ping check server ok.
+func ping(c *bm.Context) {
+	if err := wkfSvc.Ping(c); err != nil {
+		log.Error("workflow-service ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/service/main/workflow/http/sign.go

@@ -0,0 +1,52 @@
+package http
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"strings"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+const (
+	_sobotAppKey    = "bcef69bb71499209"
+	_sobotAppSecret = "ace486f144f1467eefdce1fe5dfc7b14"
+	_sobotAPI       = "https://sso-api.bilibili.co/x/internal/workflow/sobot/user"
+)
+
+func sobotSign(handler func(*bm.Context)) func(*bm.Context) {
+	return func(c *bm.Context) {
+		req := c.Request
+		query := req.Form
+		if query.Get("ts") == "" {
+			log.Error("ts is empty")
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		sign := query.Get("sign")
+		query.Del("sign")
+		sappkey := query.Get("appkey")
+		if sappkey != _sobotAppKey {
+			log.Error("appkey not matched")
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		query.Set("appsecret", _sobotAppSecret)
+		tmp := query.Encode()
+		if strings.IndexByte(tmp, '+') > -1 {
+			tmp = strings.Replace(tmp, "+", "%20", -1)
+		}
+		mh := md5.Sum([]byte(_sobotAPI + "?" + strings.ToLower(tmp) + _sobotAppSecret))
+		if hex.EncodeToString(mh[:]) != sign {
+			mh1 := md5.Sum([]byte(_sobotAPI + "?" + tmp + _sobotAppSecret))
+			if hex.EncodeToString(mh1[:]) != sign {
+				log.Error("Get sign: %s, expect %x", sign, mh1)
+				c.JSON(nil, ecode.SignCheckErr)
+				return
+			}
+		}
+		handler(c)
+	}
+}

app/service/main/workflow/http/sobot.go

@@ -0,0 +1,106 @@
+package http
+
+import (
+	"encoding/json"
+
+	"go-common/app/service/main/workflow/model/account"
+	"go-common/app/service/main/workflow/model/sobot"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func sobotFetchUser(c *bm.Context) {
+	data := []byte(`
+    {
+      "mid": 1,
+      "uname": "biliuser",
+      "tel": "132****1234",
+      "email": "biliuser@qq.com",
+      "status": 0,
+      "formal": 0,
+      "moral": 70,
+      "level": 3,
+      "exp": "4000",
+      "coin": 300.12,
+      "bcoin": 10.12,
+      "medal": "青铜殿堂",
+      "up": {
+        "relation": {
+          "following": 1,
+          "whisper": 1,
+          "black": 0,
+          "follower": 1
+        },
+        "archive": 5,
+        "identify": 1,
+        "office": "bilibili认证",
+        "shell": 10.12,
+        "bank_card": "6227123412341234123"
+      },
+      "extra": {
+        "arc_pubed": 312,
+        "arc_not_pubed": 34,
+        "arc_is_pubing": 175
+      }
+    }
+    `)
+	user := &account.User{}
+	user.Extra = make(map[string]interface{})
+	if err := json.Unmarshal(data, user); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(user, nil)
+}
+
+func sobotInfoTicket(c *bm.Context) {
+	tp := new(struct {
+		TicketID int32 `form:"ticket_id" validate:"required"`
+	})
+	if err := c.Bind(tp); err != nil {
+		return
+	}
+	c.JSON(wkfSvc.SobotTicketInfo(c, tp.TicketID))
+}
+
+func sobotAddTicket(c *bm.Context) {
+	tp := new(sobot.TicketParam)
+	if err := c.BindWith(tp, binding.FormPost); err != nil {
+		return
+	}
+	c.JSON(nil, wkfSvc.SobotTicketAdd(c, tp))
+}
+
+func sobotModifyTicket(c *bm.Context) {
+	tp := new(sobot.TicketParam)
+	if err := c.BindWith(tp, binding.FormPost); err != nil {
+		return
+	}
+	c.JSON(nil, wkfSvc.SobotTicketModify(c, tp))
+}
+
+func sobotAddReply(c *bm.Context) {
+	rp := new(sobot.ReplyParam)
+	if err := c.BindWith(rp, binding.FormPost); err != nil {
+		return
+	}
+	c.JSON(nil, wkfSvc.SobotReplyAdd(c, rp))
+}
+
+// func sobotCallback(c *bm.Context) {
+// 	req := c.Request
+// 	bs, err := ioutil.ReadAll(req.Body)
+// 	if err != nil {
+// 		log.Error("ioutil.ReadAll() error(%v)", err)
+// 		c.JSON(nil, ecode.RequestErr)
+// 		return
+// 	}
+// 	req.Body.Close()
+// 	var jsbody map[string]interface{}
+// 	if err := json.Unmarshal(bs, &jsbody); err != nil {
+// 		c.JSON(nil, ecode.RequestErr)
+// 		return
+// 	}
+// 	log.Info("sobotCallback(%s)", string(bs))
+// 	c.JSON(jsbody, nil)
+// }

app/service/main/workflow/http/tag.go

@@ -0,0 +1,28 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+// tagList get enabled tag list by business
+func tagList(c *bm.Context) {
+	tp := new(struct {
+		Business int8 `form:"business" validate:"required"`
+	})
+	if err := c.Bind(tp); err != nil {
+		return
+	}
+	c.JSON(wkfSvc.TagSlice(tp.Business), nil)
+}
+
+// tagList3 .
+func tagList3(c *bm.Context) {
+	tp := new(struct {
+		BID int64 `form:"bid" validate:"required"`
+		RID int64 `form:"rid"`
+	})
+	if err := c.Bind(tp); err != nil {
+		return
+	}
+	c.JSON(wkfSvc.Tag3(tp.BID, tp.RID), nil)
+}