Create & Init Project...

app/service/main/account-recovery/http/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "appeal.go",
+        "bfs.go",
+        "http.go",
+    ],
+    importpath = "go-common/app/service/main/account-recovery/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/account-recovery/conf:go_default_library",
+        "//app/service/main/account-recovery/model:go_default_library",
+        "//app/service/main/account-recovery/service:go_default_library",
+        "//library/database/bfs: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",
+        "//vendor/github.com/google/uuid:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/account-recovery/http/appeal.go

@@ -0,0 +1,201 @@
+package http
+
+import (
+	"strconv"
+	"strings"
+
+	"go-common/app/service/main/account-recovery/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+)
+
+// queryAccount is verify account is exist
+func queryAccount(c *bm.Context) {
+	params := new(model.QueryInfoReq)
+	if err := c.Bind(params); err != nil {
+		return
+	}
+	c.JSON(srv.QueryAccount(c, params))
+}
+
+// commitInfo is commit appeal info
+func commitInfo(c *bm.Context) {
+	uinfo := new(model.UserInfoReq)
+	if err := c.Bind(uinfo); err != nil {
+		return
+	}
+	uinfo.LoginAddrs = strings.TrimSpace(uinfo.LoginAddrs)
+	uinfo.RegAddr = strings.TrimSpace(uinfo.RegAddr)
+	uinfo.Unames = strings.TrimSpace(uinfo.Unames)
+	uinfo.Pwds = strings.TrimSpace(uinfo.Pwds)
+	uinfo.Phones = strings.TrimSpace(uinfo.Phones)
+	uinfo.Emails = strings.TrimSpace(uinfo.Emails)
+	uinfo.SafeAnswer = strings.TrimSpace(uinfo.SafeAnswer)
+	uinfo.LinkMail = strings.TrimSpace(uinfo.LinkMail)
+	uinfo.Captcha = strings.TrimSpace(uinfo.Captcha)
+	uinfo.CardID = strings.TrimSpace(uinfo.CardID)
+
+	uinfo.Business = strings.TrimSpace(uinfo.Business)
+	bizMap := make(map[string]string)
+	req := c.Request.Form
+	uinfo.BusinessMap = bizMap
+	extraArgs := model.BusinessExtraArgs(uinfo.Business)
+	for _, k := range extraArgs {
+		bizMap[k] = req.Get(k)
+	}
+
+	c.JSON(nil, srv.CommitInfo(c, uinfo))
+}
+
+// queryConWithBusiness query with business
+func queryConWithBusiness(business string) func(*bm.Context) {
+	return func(c *bm.Context) {
+		params := new(model.QueryRecoveryInfoReq)
+		if err := c.Bind(params); err != nil {
+			return
+		}
+		params.Bussiness = business
+		if perms, ok := c.Get(permit.CtxPermissions); ok {
+			for _, p := range perms.([]string) {
+				if p == "ACCOUNT_RECOVERY_ADVANCED" {
+					params.IsAdvanced = true
+				}
+			}
+		}
+		req := c.Request
+		if inStatus := req.Form.Get("status"); inStatus != "" {
+			status, err := strconv.ParseInt(inStatus, 10, 64)
+			if err != nil {
+				log.Error("Invalid status: %s: %+v", inStatus, err)
+				status = 0
+			}
+			params.Status = &status
+		}
+		if inGame := req.Form.Get("game"); inGame != "" {
+			game, err := strconv.ParseInt(inGame, 10, 64)
+			if err != nil {
+				log.Error("Invalid game: %s: %+v", inGame, err)
+				game = 0
+			}
+			params.Game = &game
+		}
+		if params.Size <= 0 {
+			params.Size = 50
+		}
+		c.JSON(srv.QueryCon(c, params))
+	}
+}
+
+// judge is reject or agree one operation
+func judge(c *bm.Context) {
+	req := new(model.JudgeReq)
+	if err := c.Bind(req); err != nil {
+		return
+	}
+	c.JSON(nil, srv.Judge(c, req))
+}
+
+// batchJudge reject or agree more operation
+func batchJudge(c *bm.Context) {
+	req := new(model.BatchJudgeReq)
+	if err := c.Bind(req); err != nil {
+		return
+	}
+	split := strings.Split(req.Rids, ",")
+	rids := make([]int64, 0, len(split))
+	for _, v := range split {
+		rid, err := strconv.ParseInt(v, 10, 64)
+		if err != nil {
+			c.JSON(nil, err)
+			return
+		}
+		rids = append(rids, rid)
+	}
+	req.RidsAry = rids
+	c.JSON(nil, srv.BatchJudge(c, req))
+}
+
+// getCaptchaMail
+func getCaptchaMail(c *bm.Context) {
+	req := new(model.CaptchaMailReq)
+	if err := c.Bind(req); err != nil {
+		return
+	}
+	if !strings.Contains(req.LinkMail, "@") {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if req.Mid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var err error
+	state, err := srv.GetCaptchaMail(c, req)
+	c.JSON(map[string]int64{
+		"state": state,
+	}, err)
+}
+
+func parseMid(midStr string) (mid int64) {
+	if len(midStr) == 0 {
+		return 0
+	}
+	mid, err := strconv.ParseInt(midStr, 10, 64)
+	if err != nil {
+		return 0
+	}
+	return
+}
+
+func verifyCode(c *bm.Context) {
+	var err error
+	arg := new(struct {
+		Token string `form:"token" validate:"required"`
+		Code  string `form:"code" validate:"required"` //验证码
+	})
+	if err = c.Bind(arg); err != nil {
+		return
+	}
+	if err = srv.Verify(c, arg.Token, arg.Code); err != nil {
+		c.JSON(nil, ecode.CreativeGeetestErr)
+		return
+	}
+	c.JSON(nil, err)
+}
+
+func webToken(c *bm.Context) {
+	c.JSON(srv.WebToken(c))
+}
+
+func compareInfo(c *bm.Context) {
+	rid := parseMid(c.Request.Form.Get("rid"))
+	if rid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.CompareInfo(c, rid))
+}
+
+func sendMail(c *bm.Context) {
+	req := new(model.SendMailReq)
+	if err := c.Bind(req); err != nil {
+		return
+	}
+	if req.RID <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.SendMail(c, req))
+}
+
+// gameList game list
+func gameList(c *bm.Context) {
+	mids := c.Request.Form.Get("mids")
+	if mids == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(srv.GameList(c, mids))
+}

app/service/main/account-recovery/http/bfs.go

@@ -0,0 +1,89 @@
+package http
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+
+	"go-common/app/service/main/account-recovery/model"
+	"go-common/library/database/bfs"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+)
+
+var _allowedExt = map[string]struct{}{
+	".zip": {},
+	".rar": {},
+	".7z":  {},
+}
+
+func fileUpload(c *bm.Context) {
+	defer c.Request.Form.Del("file") // 防止日志不出现
+	c.Request.ParseMultipartForm(32 << 20)
+	recoveryFile, fileName, err := func() ([]byte, string, error) {
+		f, fh, err := c.Request.FormFile("file")
+		if err != nil {
+			return nil, "", errors.Wrapf(err, "parse file form file: ")
+		}
+		defer f.Close()
+		data, err := ioutil.ReadAll(f)
+		if err != nil {
+			return nil, "", errors.Wrapf(err, "read file form file:")
+		}
+		if len(data) <= 0 {
+			return nil, "", errors.Wrapf(err, "form file data: length: %d", len(data))
+		}
+		log.Info("Succeeded to parse file from form file: length: %d", len(data))
+		return data, fh.Filename, nil
+	}()
+	if err != nil {
+		log.Error("Failed to parse file file: %+v", err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	log.Info("Succeeded to parse recoveryFile data: recoveryFile-length: %d", len(recoveryFile))
+
+	//限制文件大小
+	if len(recoveryFile) > 10*1024*1024 {
+		log.Error("account-recovery: file is to large(%v)", len(recoveryFile))
+		c.JSON(nil, ecode.FileTooLarge)
+		return
+	}
+
+	//限制文件类型 *.zip, *.rar, *.7z
+	ext := filepath.Ext(fileName)
+	_, allowed := _allowedExt[ext]
+	if !allowed {
+		c.JSON(nil, ecode.BfsUploadFileContentTypeIllegal)
+		return
+	}
+
+	request := &bfs.Request{
+		Bucket:   "account",
+		Dir:      "recovery",
+		File:     recoveryFile,
+		Filename: fmt.Sprintf("%s%s", uuid4(), ext),
+	}
+	bfsClient := bfs.New(nil)
+	location, err := bfsClient.Upload(c, request)
+	if err != nil {
+		log.Error("err(%+v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	fileURL := model.BuildFileURL(location)
+	data := map[string]interface{}{
+		"url":     location,
+		"fileURL": fileURL,
+	}
+	c.JSON(data, nil)
+}
+
+func uuid4() string {
+	return uuid.New().String()
+}

app/service/main/account-recovery/http/http.go

@@ -0,0 +1,72 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/service/main/account-recovery/conf"
+	"go-common/app/service/main/account-recovery/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 (
+	srv     *service.Service
+	vfy     *verify.Verify
+	authSvr *permit.Permit
+)
+
+// Init init
+func Init(c *conf.Config) {
+	srv = service.New(c)
+	vfy = verify.New(c.Verify)
+	authSvr = permit.New(c.Auth)
+	engine := bm.DefaultServer(c.BM)
+	router(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start() error(%v)", err)
+		panic(err)
+	}
+}
+
+func router(e *bm.Engine) {
+	e.Ping(ping)
+	e.Register(register)
+	g := e.Group("/x/account-recovery")
+	{
+		g.POST("/query", queryAccount)
+		g.POST("/commit", commitInfo)
+		g.POST("/getCaptchaMail", getCaptchaMail)
+		g.GET("/captcha/token", webToken)
+		g.POST("/captcha/verify", verifyCode)
+		g.POST("/file/upload", bm.CORS(), fileUpload)
+	}
+	adminGroup := e.Group("/x/admin/account-recovery", authSvr.Permit("ACCOUNT_RECOVERY_NORMAL"))
+	{
+		adminGroup.GET("/queryCon", queryConWithBusiness(""))
+		adminGroup.GET("/queryCon/account", authSvr.Permit("ACCOUNT_RECOVERY_ACCOUNT"), queryConWithBusiness("account"))
+		adminGroup.GET("/queryCon/game", authSvr.Permit("ACCOUNT_RECOVERY_GAME"), queryConWithBusiness("game"))
+		// todo judge,batchJudge也需要分配权限
+		adminGroup.POST("/judge", judge)
+		adminGroup.POST("/batchJudge", batchJudge)
+		adminGroup.POST("/gameList", gameList)
+	}
+
+	internalGroup := e.Group("/x/internal/account-recovery", vfy.Verify)
+	{
+		internalGroup.POST("/compare", compareInfo)
+		internalGroup.POST("/sendMail", sendMail)
+	}
+}
+
+func ping(c *bm.Context) {
+	if err := srv.Ping(c); err != nil {
+		log.Error("ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}
+
+func register(c *bm.Context) {
+	c.JSON(map[string]interface{}{}, nil)
+}