Create & Init Project...

app/service/main/antispam/http/BUILD

@@ -0,0 +1,59 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cond.go",
+        "filter.go",
+        "http.go",
+        "keyword.go",
+        "protocol.go",
+        "regexp.go",
+        "rule.go",
+    ],
+    importpath = "go-common/app/service/main/antispam/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/antispam/conf:go_default_library",
+        "//app/service/main/antispam/dao:go_default_library",
+        "//app/service/main/antispam/model:go_default_library",
+        "//app/service/main/antispam/service:go_default_library",
+        "//app/service/main/antispam/util: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/verify:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_xtest",
+    srcs = ["cond_test.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/antispam/http:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert: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/antispam/http/cond.go

@@ -0,0 +1,91 @@
+package http
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"go-common/app/service/main/antispam/model"
+	"go-common/app/service/main/antispam/service"
+	"go-common/app/service/main/antispam/util"
+)
+
+// Condition .
+type Condition struct {
+	*util.Pagination
+
+	Tag  string
+	Tags []string
+
+	Content  string
+	Contents []string
+
+	Area      string
+	Search    string
+	State     string
+	HitCounts string
+
+	Order, OrderBy        string
+	LimitType, LimitScope string
+	StartTime, EndTime    *time.Time
+}
+
+// ToServiceCond .
+func ToServiceCond(cond *Condition) *service.Condition {
+	if cond == nil {
+		return nil
+	}
+	res := &service.Condition{
+		Pagination: cond.Pagination,
+
+		Area:    cond.Area,
+		Order:   cond.Order,
+		OrderBy: cond.OrderBy,
+
+		Tags:     cond.Tags,
+		Contents: cond.Contents,
+
+		Search:     cond.Search,
+		State:      cond.State,
+		HitCounts:  cond.HitCounts,
+		LimitType:  cond.LimitType,
+		LimitScope: cond.LimitScope,
+
+		StartTime: cond.StartTime,
+		EndTime:   cond.EndTime,
+	}
+	// TODO: how to handler it graceful ?
+	if cond.Tag != "" {
+		res.Tags = []string{cond.Tag}
+	}
+	if cond.Content != "" {
+		res.Contents = []string{cond.Content}
+	}
+	// history reasons
+	if res.OrderBy == "show_up_counts" {
+		res.OrderBy = "hit_counts"
+	}
+	return res
+}
+
+// Valid .
+func (c *Condition) Valid() error {
+	if c.Pagination != nil {
+		if c.CurPage == 0 {
+			c.CurPage = 1
+		}
+		if c.PerPage == 0 {
+			c.PerPage = 20
+		}
+	}
+	c.Search, c.Order = strings.TrimSpace(c.Search), strings.TrimSpace(c.Order)
+	if c.Order == "" {
+		c.Order = model.OrderASC
+	} else {
+		c.Order = strings.ToUpper(c.Order)
+	}
+	if c.Order != model.OrderASC && c.Order != model.OrderDESC {
+		return fmt.Errorf("Order by should be 'ASC' or 'DESC' but got(%s)", c.Order)
+	}
+	return nil
+}

app/service/main/antispam/http/cond_test.go

@@ -0,0 +1,32 @@
+package http_test
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"go-common/app/service/main/antispam/http"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestValid(t *testing.T) {
+	cases := []struct {
+		cond        *http.Condition
+		expectedErr error
+	}{
+		{&http.Condition{Search: " ", Order: ""}, nil},
+		{&http.Condition{Search: "foo", Order: ""}, nil},
+		{&http.Condition{Search: "bar", Order: "xxx"}, errors.New("Order by should be 'ASC' or 'DESC' but got(XXX)")},
+		{&http.Condition{Search: "bar", Order: "asc"}, nil},
+		{&http.Condition{Search: "bar", Order: "ASC"}, nil},
+		{&http.Condition{Search: "bar", Order: "DESC"}, nil},
+	}
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("Search(%q) Order(%q)", c.cond.Search, c.cond.Order), func(t *testing.T) {
+			assert := assert.New(t)
+			err := c.cond.Valid()
+			assert.Equal(c.expectedErr, err, fmt.Sprintf("cond.Valid() = %v, want %v", err, c.expectedErr))
+		})
+	}
+}

app/service/main/antispam/http/filter.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/service/main/antispam/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Filter .
+func Filter(c *bm.Context) {
+	params := c.Request.Form
+
+	senderID, err := strconv.ParseInt(params.Get(ProtocolKeywordSenderID), 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	oid, err := strconv.ParseInt(params.Get(ProtocolKeywordSubjectID), 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	susp := &model.Suspicious{
+		SenderId: senderID,
+		Content:  params.Get(ProtocolKeywordContent),
+		Area:     params.Get(ProtocolArea),
+		OId:      oid,
+	}
+	result, err := Svr.Filter(c, susp)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	c.JSON(result, nil)
+}

app/service/main/antispam/http/http.go

@@ -0,0 +1,120 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"go-common/app/service/main/antispam/conf"
+	"go-common/app/service/main/antispam/service"
+	"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/verify"
+)
+
+var (
+	// Svr .
+	Svr       service.Service
+	verifySvc *verify.Verify
+	authSvc   *auth.Auth
+)
+
+// Init .
+func Init(c *conf.Config, s service.Service) {
+	Svr = s
+	verifySvc = verify.New(c.Verify)
+	authSvc = auth.New(c.Auth)
+	engine := bm.DefaultServer(c.BM)
+
+	interRouter(engine)
+
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start() error(%v)", err)
+		panic(err)
+	}
+}
+
+func interRouter(e *bm.Engine) {
+	e.GET("/monitor/ping", ping)
+
+	e.GET("/register", register)
+	e.GET("/x/internal/antispam/filter", authSvc.Guest, Filter)
+
+	regexps := e.Group("/x/internal/antispam/regexps")
+	regexps.GET("", verifySvc.Verify, GetRegexps)
+	regexps.GET("/one", verifySvc.Verify, GetRegexp)
+	regexps.POST("/add", verifySvc.Verify, AddRegexp)
+	regexps.POST("/edit", verifySvc.Verify, EditRegexp)
+	regexps.POST("/del", verifySvc.Verify, DeleteRegexp)
+	regexps.POST("/recover", verifySvc.Verify, RecoverRegexp)
+
+	rules := e.Group("/x/internal/antispam/rules")
+	rules.GET("", verifySvc.Verify, GetRules)
+	rules.GET("/one", verifySvc.Verify, GetRule)
+	rules.POST("/add", verifySvc.Verify, AddRule)
+
+	keywords := e.Group("/x/internal/antispam/keywords")
+	keywords.GET("", verifySvc.Verify, GetKeywords)
+	keywords.GET("/senders", verifySvc.Verify, GetKeywordSenders)
+	keywords.GET("/one", verifySvc.Verify, GetKeyword)
+	keywords.POST("/dels", verifySvc.Verify, DeleteKeywords)
+	keywords.POST("/action", verifySvc.Verify, UpdateKeyword)
+}
+
+func ping(c *bm.Context) {
+	if err := Svr.Ping(c); err != nil {
+		log.Error("antispam service ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}
+
+func register(c *bm.Context) {
+	c.JSON(struct{}{}, nil)
+}
+
+func getAdminIDAndArea(params url.Values) (adminID int64, area string, err error) {
+	adminID, err = getAdminID(params)
+	if err != nil {
+		return 0, "", err
+	}
+	area, err = parseArea(params)
+	if err != nil {
+		return 0, "", err
+	}
+	return adminID, area, nil
+}
+
+func parseArea(params url.Values) (string, error) {
+	area := params.Get(ProtocolArea)
+	if _, ok := conf.Areas[area]; !ok {
+		err := fmt.Errorf("invalid area(%s)", area)
+		log.Error("%v", err)
+		return "", err
+	}
+	return area, nil
+}
+
+func getAdminID(params url.Values) (int64, error) {
+	adminIDStr := params.Get(ProtocolAdminID)
+	if adminIDStr == "" {
+		err := errors.New("empty admin id")
+		log.Error("%v", err)
+		return 0, err
+	}
+	adminID, err := strconv.ParseInt(adminIDStr, 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		return 0, err
+	}
+	return adminID, nil
+}
+
+func errResp(c *bm.Context, code interface{}, err error) {
+	c.JSONMap(map[string]interface{}{
+		ProtocolData:    code,
+		ProtocolMessage: err.Error(),
+	}, nil)
+}

app/service/main/antispam/http/keyword.go

@@ -0,0 +1,242 @@
+package http
+
+import (
+	"errors"
+	"strconv"
+	"time"
+
+	"go-common/app/service/main/antispam/conf"
+	"go-common/app/service/main/antispam/dao"
+	"go-common/app/service/main/antispam/model"
+	"go-common/app/service/main/antispam/util"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+var (
+	// ErrMissID .
+	ErrMissID = errors.New("error: id is required")
+	// ErrIllegalOp .
+	ErrIllegalOp = errors.New("error: this operation on keyword is not allowed")
+)
+
+// GetKeywordSenders return keyword's sender list
+func GetKeywordSenders(c *bm.Context) {
+	params := c.Request.Form
+	if _, err := getAdminID(params); err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	id, err := strconv.ParseInt(params.Get(ProtocolKeywordID), 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	k, err := Svr.GetKeywordByID(c, id)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	if k.State == model.StateDeleted {
+		errResp(c, ecode.ServerErr, dao.ErrResourceNotExist)
+		return
+	}
+	l, err := Svr.GetSenderIDsByKeywordID(c, id)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(l, nil)
+}
+
+// DeleteKeywords .
+func DeleteKeywords(c *bm.Context) {
+	params := c.Request.Form
+	if _, err := getAdminID(params); err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if params.Get(ProtocolKeywordIDs) == "" {
+		errResp(c, ecode.RequestErr, errors.New("empty ids"))
+		return
+	}
+	ids, err := util.StrToIntSli(params.Get(ProtocolKeywordIDs), ",")
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if len(ids) == 0 {
+		errResp(c, ecode.RequestErr, nil)
+		return
+	}
+	ks, err := Svr.DeleteKeywords(c, ids)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(ks, nil)
+}
+
+// UpdateKeyword .
+func UpdateKeyword(c *bm.Context) {
+	params := c.Request.Form
+	_, err := getAdminID(params)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	op := params.Get(ProtocolKeywordOperation)
+	if op != ProtocolKeywordOpDefaultLimit &&
+		op != ProtocolKeywordOpRestrictLimit &&
+		op != ProtocolKeywordOpBlack &&
+		op != ProtocolKeywordOpWhite {
+		log.Error("%v", ErrIllegalOp)
+		errResp(c, ecode.RequestErr, ErrIllegalOp)
+		return
+	}
+	id, err := strconv.ParseInt(params.Get(ProtocolKeywordID), 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	k, err := Svr.GetKeywordByID(c, id)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	if k.State == model.StateDeleted {
+		errResp(c, ecode.ServerErr, dao.ErrResourceNotExist)
+		return
+	}
+	if k.Tag == op {
+		c.JSON(k, nil)
+		return
+	}
+	k, err = Svr.OpKeyword(c, id, op)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(k, nil)
+}
+
+// GetKeyword .
+func GetKeyword(c *bm.Context) {
+	params := c.Request.Form
+	_, _, err := getAdminIDAndArea(params)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if params.Get(ProtocolKeywordID) == "" {
+		errResp(c, ecode.RequestErr, ErrMissID)
+		return
+	}
+	id, err := strconv.ParseInt(params.Get(ProtocolKeywordID), 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	keyword, err := Svr.GetKeywordByID(c, id)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(keyword, nil)
+}
+
+// GetKeywords .
+func GetKeywords(c *bm.Context) {
+	params := c.Request.Form
+	_, area, err := getAdminIDAndArea(params)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	var (
+		ctimeStart, ctimeEnd string
+		startTime, endTime   time.Time
+	)
+	cond := &Condition{
+		Pagination: &util.Pagination{},
+		Area:       area,
+		State:      model.StateDefault,
+		Search:     params.Get(ProtocolSearch),
+		Order:      params.Get(ProtocolOrder),
+		OrderBy:    params.Get(ProtocolOrderBy),
+		Tag:        params.Get(ProtocolKeywordTag),
+	}
+	if ctimeStart = params.Get(ProtocolCTimeStart); ctimeStart != "" {
+		startTime, err = time.Parse(util.TimeFormat, ctimeStart)
+		if err != nil {
+			log.Error("%v", err)
+			errResp(c, ecode.RequestErr, err)
+			return
+		}
+		cond.StartTime = &startTime
+	}
+	if ctimeEnd = params.Get(ProtocolCTimeEnd); ctimeEnd != "" {
+		endTime, err = time.Parse(util.TimeFormat, ctimeEnd)
+		if err != nil {
+			log.Error("%v", err)
+			errResp(c, ecode.RequestErr, err)
+			return
+		}
+		cond.EndTime = &endTime
+	}
+	if ctimeStart != "" && ctimeEnd != "" {
+		if startTime.After(endTime) {
+			err = errors.New("start_time cannot be bigger than end_time")
+			log.Error("%v", err)
+			errResp(c, ecode.RequestErr, err)
+			return
+		}
+	}
+	var export bool
+	if params.Get(ProtocolKeywordExport) != "" {
+		export, err = strconv.ParseBool(params.Get(ProtocolKeywordExport))
+		if err != nil {
+			log.Error("%v", err)
+			errResp(c, ecode.RequestErr, err)
+			return
+		}
+	}
+	if export {
+		cond.PerPage = conf.Conf.ServiceOption.MaxExportRows
+	} else {
+		if params.Get(ProtocolCurPage) != "" {
+			cond.CurPage, err = strconv.ParseInt(params.Get(ProtocolCurPage), 10, 64)
+			if err != nil {
+				log.Error("%v", err)
+				errResp(c, ecode.RequestErr, err)
+				return
+			}
+		}
+		if perPage := params.Get(ProtocolPerPage); perPage != "" {
+			if cond.PerPage, err = strconv.ParseInt(perPage, 10, 64); err != nil {
+				log.Error("%v", err)
+				errResp(c, ecode.RequestErr, err)
+				return
+			}
+		}
+	}
+	if err = cond.Valid(); err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	keywords, total, err := Svr.GetKeywordsByCond(c, ToServiceCond(cond))
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	res := map[string]interface{}{}
+	res[ProtocolTotalCounts] = total
+	res[ProtocolData] = keywords
+	c.JSONMap(res, nil)
+}

app/service/main/antispam/http/protocol.go

@@ -0,0 +1,94 @@
+package http
+
+const (
+	// ProtocolArea .
+	ProtocolArea = "area"
+
+	// ProtocolState .
+	ProtocolState = "state"
+	// ProtocolSearch .
+	ProtocolSearch = "q"
+	// ProtocolSynced .
+	ProtocolSynced = "synced"
+	// ProtocolAdminID .
+	ProtocolAdminID = "admin_id"
+
+	// ProtocolCurPage .
+	ProtocolCurPage = "cur_page"
+	// ProtocolPerPage .
+	ProtocolPerPage = "per_page"
+
+	// ProtocolCTime .
+	ProtocolCTime = "ctime"
+	// ProtocolCTimeStart .
+	ProtocolCTimeStart = "ctime_start"
+	// ProtocolCTimeEnd .
+	ProtocolCTimeEnd = "ctime_end"
+
+	// ProtocolOrder .
+	ProtocolOrder = "order"
+	// ProtocolOrderBy .
+	ProtocolOrderBy = "order_by"
+	// ProtocolOrderASC .
+	ProtocolOrderASC = "asc"
+	// ProtocolOrderDESC .
+	ProtocolOrderDESC = "desc"
+
+	// ProtocolCode .
+	ProtocolCode = "code"
+	// ProtocolData .
+	ProtocolData = "data"
+	// ProtocolMessage .
+	ProtocolMessage = "msg"
+	// ProtocolTotalCounts .
+	ProtocolTotalCounts = "total_counts"
+
+	// ProtocolRegexpID .
+	ProtocolRegexpID = "id"
+	// ProtocolRegexpName .
+	ProtocolRegexpName = "name"
+	// ProtocolRegexpContent .
+	ProtocolRegexpContent = "content"
+	// ProtocolRegexpOperation .
+	ProtocolRegexpOperation = "op"
+
+	// ProtocolRuleDuration .
+	ProtocolRuleDuration = "time_span"
+	// ProtocolRuleLimitType .
+	ProtocolRuleLimitType = "limit_type"
+	// ProtocolRuleLimitScope .
+	ProtocolRuleLimitScope = "limit_scope"
+	// ProtocolRuleAllowedCounts .
+	ProtocolRuleAllowedCounts = "allowed_counts"
+
+	// ProtocolKeywordID .
+	ProtocolKeywordID = "id"
+	// ProtocolKeywordIDs .
+	ProtocolKeywordIDs = "ids"
+	// ProtocolKeywordTag .
+	ProtocolKeywordTag = "tag"
+	// ProtocolKeywordExport .
+	ProtocolKeywordExport = "export"
+	// ProtocolKeywordHitCounts .
+	ProtocolKeywordHitCounts = "hit_counts"
+
+	// ProtocolKeywordOpWhite .
+	ProtocolKeywordOpWhite = "white"
+	// ProtocolKeywordOpBlack .
+	ProtocolKeywordOpBlack = "black"
+	// ProtocolKeywordOperation .
+	ProtocolKeywordOperation = "op"
+	// ProtocolKeywordOpDefaultLimit .
+	ProtocolKeywordOpDefaultLimit = "limit"
+	// ProtocolKeywordOpRestrictLimit .
+	ProtocolKeywordOpRestrictLimit = "restrict"
+	// ProtocolKeywordOpBlackAndDeleteReply .
+	ProtocolKeywordOpBlackAndDeleteReply = "black_and_del"
+
+	// ProtocolKeywordSenderID .
+	ProtocolKeywordSenderID = "sender_id"
+	// ProtocolKeywordSubjectID .
+	ProtocolKeywordSubjectID = "oid"
+	// ProtocolKeywordContent .
+	ProtocolKeywordContent = "content"
+)

app/service/main/antispam/http/regexp.go

@@ -0,0 +1,255 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"regexp"
+	"strconv"
+
+	"go-common/app/service/main/antispam/conf"
+	"go-common/app/service/main/antispam/dao"
+	"go-common/app/service/main/antispam/model"
+	"go-common/app/service/main/antispam/util"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// GetRegexp .
+func GetRegexp(c *bm.Context) {
+	params := c.Request.Form
+	_, err := getAdminID(params)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	id, err := strconv.ParseInt(params.Get(ProtocolRegexpID), 10, 64)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	regexp, err := Svr.GetRegexpByID(c, id)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	c.JSON(regexp, nil)
+}
+
+// GetRegexps .
+func GetRegexps(c *bm.Context) {
+	params := c.Request.Form
+	_, area, err := getAdminIDAndArea(params)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	cond := &Condition{
+		Area:       area,
+		Pagination: &util.Pagination{},
+	}
+	if params.Get(ProtocolCurPage) != "" {
+		if cond.CurPage, err = strconv.ParseInt(params.Get(ProtocolCurPage), 10, 64); err != nil {
+			log.Error("%v", err)
+			errResp(c, ecode.RequestErr, err)
+			return
+		}
+	}
+	if perPage := params.Get(ProtocolPerPage); perPage != "" {
+		if cond.PerPage, err = strconv.ParseInt(perPage, 10, 64); err != nil {
+			log.Error("%v", err)
+			errResp(c, ecode.RequestErr, err)
+			return
+		}
+	}
+	if err = cond.Valid(); err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	regexps, total, err := Svr.GetRegexpsByCond(c, ToServiceCond(cond))
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	res := map[string]interface{}{}
+	res[ProtocolTotalCounts] = total
+	res[ProtocolData] = regexps
+	c.JSONMap(res, nil)
+
+}
+
+// EditRegexp .
+func EditRegexp(c *bm.Context) {
+	params := c.Request.Form
+	if _, err := getAdminID(params); err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	id, err := strconv.ParseInt(params.Get(ProtocolRegexpID), 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	addOrEditRegexp(c, params, id)
+}
+
+// AddRegexp .
+func AddRegexp(c *bm.Context) {
+	params := c.Request.Form
+	if _, _, err := getAdminIDAndArea(params); err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	var id int64
+	addOrEditRegexp(c, params, id)
+}
+
+// RecoverRegexp .
+func RecoverRegexp(c *bm.Context) {
+	params := c.Request.Form
+	adminID, err := getAdminID(params)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	id, err := strconv.ParseInt(params.Get(ProtocolRegexpID), 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	r, err := Svr.GetRegexpByID(c, id)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if r.State != model.StateDeleted {
+		c.JSON(r, nil)
+		return
+	}
+	_, total, err := Svr.GetRegexpsByCond(c, ToServiceCond(&Condition{State: model.StateDefault, Area: r.Area}))
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	if total >= conf.Conf.ServiceOption.MaxRegexpCountsPerArea {
+		err = fmt.Errorf("regexp counts cannot exceed %d", conf.Conf.ServiceOption.MaxRegexpCountsPerArea)
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	r.State, r.AdminID = model.StateDefault, adminID
+	result, err := Svr.UpsertRegexp(c, r)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(result, nil)
+}
+
+// DeleteRegexp .
+func DeleteRegexp(c *bm.Context) {
+	params := c.Request.Form
+	adminID, err := getAdminID(params)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	id, err := strconv.ParseInt(params.Get(ProtocolRegexpID), 10, 64)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	r, err := Svr.DeleteRegexp(c, id, adminID)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(r, nil)
+}
+
+func addOrEditRegexp(c *bm.Context, params url.Values, id int64) {
+	adminID, err := getAdminID(params)
+	if err != nil {
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	name := params.Get(ProtocolRegexpName)
+	if name == "" {
+		err = errors.New("empty regexp name")
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	content := params.Get(ProtocolRegexpContent)
+	if content == "" {
+		err = errors.New("empty regexp content")
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if _, err = regexp.Compile(content); err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.FilterIllegalRegexp, err)
+		return
+	}
+	op := params.Get(ProtocolRegexpOperation)
+	if op == "" {
+		op = model.OperationLimit
+	}
+	area := params.Get(ProtocolArea)
+	if id == 0 {
+		_, total, err1 := Svr.GetRegexpsByCond(c, ToServiceCond(&Condition{State: model.StateDefault, Area: area}))
+		if err1 != nil {
+			errResp(c, ecode.ServerErr, err1)
+			return
+		}
+		if total >= conf.Conf.ServiceOption.MaxRegexpCountsPerArea {
+			err1 = fmt.Errorf("regexp counts cannot exceed %d", conf.Conf.ServiceOption.MaxRegexpCountsPerArea)
+			log.Error("%v", err1)
+			errResp(c, ecode.RequestErr, err1)
+			return
+		}
+
+		oldR, err1 := Svr.GetRegexpByAreaAndContent(c, area, content)
+		if err1 == nil {
+			if oldR.State != model.StateDefault {
+				oldR.State = model.StateDefault
+				result, err2 := Svr.UpsertRegexp(c, oldR)
+				if err2 != nil {
+					errResp(c, ecode.ServerErr, err2)
+					return
+				}
+				c.JSON(result, nil)
+				return
+			}
+			err1 = fmt.Errorf("regexp(%s) already exists", content)
+			log.Error("%v", err1)
+			errResp(c, ecode.RequestErr, err1)
+			return
+		}
+		if err != dao.ErrResourceNotExist {
+			log.Error("%v", err1)
+			errResp(c, ecode.ServerErr, err1)
+			return
+		}
+	}
+	r := &model.Regexp{
+		ID:        id,
+		Area:      area,
+		AdminID:   adminID,
+		Name:      name,
+		Content:   content,
+		Operation: op,
+	}
+	result, err := Svr.UpsertRegexp(c, r)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(result, nil)
+}

app/service/main/antispam/http/rule.go

@@ -0,0 +1,115 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+
+	"go-common/app/service/main/antispam/conf"
+	"go-common/app/service/main/antispam/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// GetRule .
+func GetRule(c *bm.Context) {
+	params := c.Request.Form
+	_, area, err := getAdminIDAndArea(params)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if params.Get(ProtocolRuleLimitType) == "" ||
+		params.Get(ProtocolRuleLimitScope) == "" {
+		err = errors.New("either limit_type or limit_scope is nil")
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	rule, err := Svr.GetRuleByAreaAndLimitTypeAndScope(c,
+		area, params.Get(ProtocolRuleLimitType), params.Get(ProtocolRuleLimitScope))
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(rule, nil)
+}
+
+// GetRules .
+func GetRules(c *bm.Context) {
+	params := c.Request.Form
+	_, area, err := getAdminIDAndArea(params)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	rules, err := Svr.GetRuleByArea(c, area)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(rules, nil)
+}
+
+// AddRule .
+func AddRule(c *bm.Context) {
+	params := c.Request.Form
+	_, area, err := getAdminIDAndArea(params)
+	if err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	typ := params.Get(ProtocolRuleLimitType)
+	if typ != model.LimitTypeDefault && typ != model.LimitTypeRestrict {
+		err = fmt.Errorf("illegal limit type %q", typ)
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	scope := params.Get(ProtocolRuleLimitScope)
+	if scope != model.LimitScopeLocal && scope != model.LimitScopeGlobal {
+		err = fmt.Errorf("illegal limit scope %q", scope)
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	r := &model.Rule{
+		Area:       area,
+		LimitType:  typ,
+		LimitScope: scope,
+	}
+	allowedCounts := params.Get(ProtocolRuleAllowedCounts)
+	if r.AllowedCounts, err = strconv.ParseInt(allowedCounts, 10, 64); err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if r.DurationSec, err = strconv.ParseInt(params.Get(ProtocolRuleDuration), 10, 64); err != nil {
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if r.DurationSec <= 0 || r.AllowedCounts <= 0 {
+		err = fmt.Errorf("both durationSec(%d) and allowedCounts(%d) must be greater than 0", r.AllowedCounts, r.DurationSec)
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	if r.DurationSec > conf.Conf.MaxDurationSec || r.AllowedCounts > conf.Conf.MaxAllowedCounts {
+		err = fmt.Errorf("either durationSec(%d) or allowedCounts(%d) exceed maxDurationSec(%d), maxAllowedCounts(%d)",
+			r.AllowedCounts, r.DurationSec, conf.Conf.MaxDurationSec, conf.Conf.MaxAllowedCounts)
+		log.Error("%v", err)
+		errResp(c, ecode.RequestErr, err)
+		return
+	}
+	r, err = Svr.UpsertRule(c, r)
+	if err != nil {
+		errResp(c, ecode.ServerErr, err)
+		return
+	}
+	c.JSON(r, nil)
+}