Create & Init Project...

app/admin/main/growup/http/BUILD

@@ -0,0 +1,66 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "activity.go",
+        "authority.go",
+        "auto.go",
+        "banner.go",
+        "blacklist.go",
+        "budgetstatistics.go",
+        "charge.go",
+        "cheat.go",
+        "csv.go",
+        "http.go",
+        "income.go",
+        "local.go",
+        "notice.go",
+        "offlineactivity.go",
+        "special_award.go",
+        "tag.go",
+        "trade.go",
+        "upload.go",
+        "web.go",
+        "white.go",
+        "withdraw.go",
+    ],
+    importpath = "go-common/app/admin/main/growup/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/growup/conf:go_default_library",
+        "//app/admin/main/growup/dao:go_default_library",
+        "//app/admin/main/growup/dao/shell:go_default_library",
+        "//app/admin/main/growup/model:go_default_library",
+        "//app/admin/main/growup/model/offlineactivity:go_default_library",
+        "//app/admin/main/growup/service:go_default_library",
+        "//app/admin/main/growup/service/income: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/render:go_default_library",
+        "//library/time: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/admin/main/growup/http/activity.go

@@ -0,0 +1,154 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/admin/main/growup/model"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+	"go-common/library/time"
+)
+
+func activityAdd(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("checkCookie error(%v)", err)
+		return
+	}
+	v := new(model.CActivity)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if err = svr.AddActivity(c, v, username); err != nil {
+		log.Error("svr.AddActivity error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    500,
+			"message": err.Error(),
+		}))
+	} else {
+		c.JSON(nil, nil)
+	}
+}
+
+func activityList(c *bm.Context) {
+	v := new(struct {
+		Name  string `form:"name"`
+		From  int    `form:"from" validate:"min=0" default:"0"`
+		Limit int    `form:"limit" validate:"min=1" default:"20"`
+		Sort  string `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, total, err := svr.ListActivity(c, v.Name, v.From, v.Limit, v.Sort)
+	if err != nil {
+		log.Error("svr.ListActivity error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code": 0,
+		"data": data,
+		"paging": map[string]int{
+			"size":  v.Limit,
+			"total": total,
+		},
+	}))
+}
+
+func activityUpdate(c *bm.Context) {
+	var err error
+	v := new(model.CActivity)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if err = svr.UpdateActivity(c, v); err != nil {
+		log.Error("svr.UpdateActivity error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    500,
+			"message": err.Error(),
+		}))
+	} else {
+		c.JSON(nil, nil)
+	}
+}
+
+func activitySignUp(c *bm.Context) {
+	v := new(struct {
+		ID    int64 `form:"id"`
+		From  int   `form:"from" validate:"min=0" default:"0"`
+		Limit int   `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, total, err := svr.ListActivitySignUp(c, v.ID, v.From, v.Limit)
+	if err != nil {
+		log.Error("svr.ListActivitySignUp error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code": 0,
+		"data": data,
+		"paging": map[string]int{
+			"size":  v.Limit,
+			"total": total,
+		},
+	}))
+}
+
+func activityWinners(c *bm.Context) {
+	v := new(struct {
+		ID    int64 `form:"id"`
+		MID   int64 `form:"mid"`
+		From  int   `form:"from" validate:"min=0" default:"0"`
+		Limit int   `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, total, err := svr.ListActivityWinners(c, v.ID, v.MID, v.From, v.Limit)
+	if err != nil {
+		log.Error("svr.ListActivityWinners error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code": 0,
+		"data": data,
+		"paging": map[string]int{
+			"size":  v.Limit,
+			"total": total,
+		},
+	}))
+}
+
+func activityAward(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("checkCookie error(%v)", err)
+		return
+	}
+	v := new(struct {
+		ID            int64     `form:"id" validate:"required"`
+		Name          string    `form:"name" validate:"required"`
+		Date          time.Time `form:"date" validate:"required"`
+		StatisticsEnd time.Time `form:"statistics_end" validate:"required"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if err = svr.ActivityAward(c, v.ID, v.Name, v.Date, v.StatisticsEnd, username); err != nil {
+		log.Error("svr.ActivityAward error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    500,
+			"message": err.Error(),
+		}))
+	} else {
+		c.JSON(nil, nil)
+	}
+}

app/admin/main/growup/http/authority.go

@@ -0,0 +1,562 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+
+	"go-common/library/ecode"
+)
+
+// check username and dashboard sessionid
+func checkCookie(c *bm.Context) (username, sid string, err error) {
+	var r = c.Request
+	var name *http.Cookie
+	if name, err = r.Cookie("username"); err == nil {
+		username = name.Value
+	}
+	var session *http.Cookie
+	if session, err = r.Cookie("_AJSESSIONID"); err == nil {
+		sid = session.Value
+	}
+	if username == "" || sid == "" {
+		err = ecode.Unauthorized
+	}
+	return
+}
+
+func getAuthorityUserPrivileges(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup checkCookie error(%v)", err)
+		return
+	}
+
+	data, err := svr.GetAuthorityUserPrivileges(username)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.GetAuthorityUserPrivileges error(%v)", err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func getAuthorityUserGroup(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup checkCookie error(%v)", err)
+		return
+	}
+	data, err := svr.GetAuthorityUserGroup(username)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.GetAuthorityUserGroup error(%v)", err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func listAuthorityUsers(c *bm.Context) {
+	v := new(struct {
+		Username string `form:"username"`
+		From     int    `form:"from" validate:"min=0" default:"0"`
+		Limit    int    `form:"limit" validate:"min=1" default:"20"`
+		Sort     string `form:"sort"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	users, total, err := svr.ListAuthorityUsers(v.Username, v.From, v.Limit, v.Sort)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.ListAuthorityUsers error(%v)", err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    users,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func addAuthorityUser(c *bm.Context) {
+	v := new(struct {
+		Username string `form:"username"`
+		Nickname string `form:"nickname"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.AddAuthorityUser(v.Username, v.Nickname)
+	if err != nil {
+		log.Error("growup svr.AddAuthorityUser error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func updateAuthorityUserInfo(c *bm.Context) {
+	v := new(struct {
+		ID       int64  `form:"id"`
+		Nickname string `form:"nickname"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.UpdateAuthorityUserInfo(v.ID, v.Nickname)
+	if err != nil {
+		log.Error("growup svr.UpdateAuthorityUserInfo error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func updateAuthorityUserAuth(c *bm.Context) {
+	v := new(struct {
+		ID      int64  `form:"id"`
+		GroupID string `form:"group_id"`
+		RoleID  string `form:"role_id"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.UpdateAuthorityUserAuth(v.ID, v.GroupID, v.RoleID)
+	if err != nil {
+		log.Error("growup svr.UpdateAuthorityUserAuth error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func deleteAuthorityUser(c *bm.Context) {
+	v := new(struct {
+		ID int64 `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.DeleteAuthorityUser(v.ID)
+	if err != nil {
+		log.Error("growup svr.DeleteAuthorityUser error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func listAuthorityTaskGroups(c *bm.Context) {
+	v := new(struct {
+		From  int    `form:"from" validate:"min=0" default:"0"`
+		Limit int    `form:"limit" validate:"min=1" default:"20"`
+		Sort  string `form:"sort"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	groups, total, err := svr.ListAuthorityTaskGroups(v.From, v.Limit, v.Sort)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.ListAuthorityTaskGroups error(%v)", err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    groups,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func addAuthorityTaskGroup(c *bm.Context) {
+	v := new(struct {
+		Name string `form:"name"`
+		Desc string `form:"desc"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.AddAuthorityTaskGroup(v.Name, v.Desc)
+	if err != nil {
+		log.Error("growup svr.AddAuthorityTaskGroup error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func addAuthorityTaskGroupUser(c *bm.Context) {
+	v := new(struct {
+		Username string `form:"username"`
+		GroupID  string `form:"group_id"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.AddAuthorityTaskGroupUser(v.Username, v.GroupID)
+	if err != nil {
+		log.Error("growup svr.AddAuthorityTaskGroupUser error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func updateAuthorityTaskGroupInfo(c *bm.Context) {
+	v := new(struct {
+		GroupID int64  `form:"group_id"`
+		Name    string `form:"name"`
+		Desc    string `form:"desc"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.UpdateAuthorityTaskGroupInfo(v.GroupID, v.Name, v.Desc)
+	if err != nil {
+		log.Error("growup svr.UpdateAuthorityTaskGroupInfo error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func deleteAuthorityTaskGroup(c *bm.Context) {
+	v := new(struct {
+		GroupID int64 `form:"group_id"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.DeleteAuthorityTaskGroup(v.GroupID)
+	if err != nil {
+		log.Error("growup svr.DeleteAuthorityTaskGroup error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func deleteAuthorityTaskGroupUser(c *bm.Context) {
+	v := new(struct {
+		ID      int64 `form:"id"`
+		GroupID int64 `form:"group_id"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.DeleteAuthorityTaskGroupUser(v.ID, v.GroupID)
+	if err != nil {
+		log.Error("growup svr.DeleteAuthorityTaskGroupUser error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func listAuthorityGroupPrivilege(c *bm.Context) {
+	v := new(struct {
+		GroupID  int64 `form:"group_id"`
+		FatherID int64 `form:"father_id" validate:"required"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, err := svr.ListAuthorityGroupPrivilege(v.GroupID, v.FatherID)
+	if err != nil {
+		log.Error("growup svr.ListAuthorityGroupPrivilege error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func updateAuthorityGroupPrivilege(c *bm.Context) {
+	v := new(struct {
+		Add     string `form:"add"`
+		Minus   string `form:"minus"`
+		GroupID int64  `form:"group_id"`
+		Type    int    `form:"type"` // 1 数据源
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.UpdateAuthorityGroupPrivilege(v.GroupID, v.Add, v.Minus, v.Type)
+	if err != nil {
+		log.Error("growup svr.UpdateAuthorityGroupPrivilege error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func listAuthorityTaskRoles(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup checkCookie error(%v)", err)
+		return
+	}
+	v := new(struct {
+		From  int    `form:"from" validate:"min=0" default:"0"`
+		Limit int    `form:"limit" validate:"min=1" default:"20"`
+		Sort  string `form:"sort"`
+	})
+
+	if err = c.Bind(v); err != nil {
+		return
+	}
+
+	roles, total, err := svr.ListAuthorityTaskRoles(username, v.From, v.Limit, v.Sort)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.ListAuthorityTaskRoles error(%v)", err)
+		return
+	}
+
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    roles,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func addAuthorityTaskRole(c *bm.Context) {
+	v := new(struct {
+		GroupID int64  `form:"group_id" validate:"required"`
+		Name    string `form:"name"`
+		Desc    string `form:"desc"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.AddAuthorityTaskRole(v.GroupID, v.Name, v.Desc)
+	if err != nil {
+		log.Error("growup svr.AddAuthorityTaskRole error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func addAuthorityTaskRoleUser(c *bm.Context) {
+	v := new(struct {
+		Username string `form:"username"`
+		RoleID   string `form:"role_id"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.AddAuthorityTaskRoleUser(v.Username, v.RoleID)
+	if err != nil {
+		log.Error("growup svr.AddAuthorityTaskRoleUser error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func updateAuthorityTaskRoleInfo(c *bm.Context) {
+	v := new(struct {
+		RoleID int64  `form:"role_id"`
+		Name   string `form:"name"`
+		Desc   string `form:"desc"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.UpdateAuthorityTaskRoleInfo(v.RoleID, v.Name, v.Desc)
+	if err != nil {
+		log.Error("growup svr.UpdateAuthorityTaskRoleInfo error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func deleteAuthorityTaskRole(c *bm.Context) {
+	v := new(struct {
+		RoleID int64 `form:"role_id"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.DeleteAuthorityTaskRole(v.RoleID)
+	if err != nil {
+		log.Error("growup svr.DeleteAuthorityTaskRole error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func deleteAuthorityTaskRoleUser(c *bm.Context) {
+	v := new(struct {
+		ID     int64 `form:"id"`
+		RoleID int64 `form:"role_id"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.DeleteAuthorityTaskRoleUser(v.ID, v.RoleID)
+	if err != nil {
+		log.Error("growup svr.DeleteAuthorityTaskRoleUser error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func listAuthorityRolePrivilege(c *bm.Context) {
+	v := new(struct {
+		GroupID  int64 `form:"group_id"`
+		RoleID   int64 `form:"role_id"`
+		FatherID int64 `form:"father_id" validate:"required"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, err := svr.ListAuthorityRolePrivilege(v.GroupID, v.RoleID, v.FatherID)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.ListAuthorityRolePrivilege error(%v)", err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func updateAuthorityRolePrivilege(c *bm.Context) {
+	v := new(struct {
+		Add    string `form:"add"`
+		Minus  string `form:"minus"`
+		RoleID int64  `form:"role_id"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.UpdateAuthorityRolePrivilege(v.RoleID, v.Add, v.Minus)
+	if err != nil {
+		log.Error("growup svr.UpdateAuthorityRolePrivilege error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func listAuthorityGroupAndRole(c *bm.Context) {
+	groups, roles, err := svr.ListGroupAndRole()
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.ListGroupAndRole error(%v)", err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data": map[string]interface{}{
+			"groups": groups,
+			"roles":  roles,
+		},
+	}))
+}
+
+func listPrivilege(c *bm.Context) {
+	data, err := svr.ListPrivilege()
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.AddPrivilege error(%v)", err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func addPrivilege(c *bm.Context) {
+	v := new(struct {
+		Level    int64  `form:"level" validate:"required"`
+		Name     string `form:"name" validate:"required"`
+		FatherID int64  `form:"father_id"`
+		IsRouter uint8  `form:"is_router"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if v.Level > 1 && v.FatherID == 0 {
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    ecode.RequestErr,
+			"message": "privilege > 1 but father_id = 0",
+		}))
+		return
+	}
+	err := svr.AddPrivilege(v.Name, v.Level, v.FatherID, v.IsRouter)
+	if err != nil {
+		log.Error("growup svr.AddPrivilege error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func updatePrivilege(c *bm.Context) {
+	v := new(struct {
+		ID       int64  `form:"id" validate:"required"`
+		Level    int64  `form:"level" validate:"required"`
+		Name     string `form:"name" validate:"required"`
+		FatherID int64  `form:"father_id"`
+		IsRouter uint8  `form:"is_router"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	if v.Level > 1 && v.FatherID == 0 {
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    ecode.RequestErr,
+			"message": "privilege > 1 but father_id = 0",
+		}))
+		return
+	}
+
+	err := svr.UpdatePrivilege(v.ID, v.Name, v.Level, v.FatherID, v.IsRouter)
+	if err != nil {
+		log.Error("growup svr.UpdatePrivilege error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func busPrivilege(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup checkCookie error(%v)", err)
+		return
+	}
+	v := new(struct {
+		Type string `form:"type"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	data, err := svr.BusPrivilege(c, username, v.Type)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.BusPrivilege error(%v)", err)
+		return
+	}
+	c.JSON(data, nil)
+}

app/admin/main/growup/http/auto.go

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+var (
+	_username = "shaozhenyu"
+)
+
+func autoBreach(c *bm.Context) {
+	var err error
+	v := new(struct {
+		Type   int     `form:"type"`
+		AIDs   []int64 `form:"aids,split" validate:"required"`
+		MID    int64   `form:"mid" validate:"required"`
+		Reason string  `form:"reason" validate:"required"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+
+	err = incomeSvr.ArchiveBreach(c, v.Type, v.AIDs, v.MID, v.Reason, _username)
+	if err != nil {
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    500,
+			"message": err.Error(),
+		}))
+	} else {
+		c.JSON(nil, nil)
+	}
+}
+
+func autoDismiss(c *bm.Context) {
+	var err error
+	v := new(struct {
+		Type   int    `form:"type"`
+		MID    int64  `form:"mid" validate:"required"`
+		Reason string `form:"reason" validate:"required"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	err = svr.AutoDismiss(c, _username, v.Type, v.MID, v.Reason)
+	if err != nil {
+		log.Error("growup svr.Dismiss error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func autoForbid(c *bm.Context) {
+	var err error
+	v := new(struct {
+		Type   int    `form:"type"`
+		MID    int64  `form:"mid" validate:"required"`
+		Reason string `form:"reason" validate:"required"`
+		Days   int    `form:"days"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	err = svr.AutoForbid(c, _username, v.Type, v.MID, v.Reason, v.Days, v.Days*86400)
+	if err != nil {
+		log.Error("growup svr.Forbid error(%v)", err)
+	}
+	c.JSON(nil, err)
+}

app/admin/main/growup/http/banner.go

@@ -0,0 +1,102 @@
+package http
+
+import (
+	"net/http"
+	"time"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func banners(c *bm.Context) {
+	v := new(struct {
+		From  int64 `form:"from" validate:"min=0" default:"0"`
+		Limit int64 `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	total, bs, err := svr.Banners(c, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup svr.Banners error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    bs,
+		"paging": map[string]int64{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func addBanner(c *bm.Context) {
+	v := new(struct {
+		Image   string `form:"image" validate:"required"`
+		Link    string `form:"link" validate:"required"`
+		StartAt int64  `form:"start_at" validate:"required"`
+		EndAt   int64  `form:"end_at" validate:"required"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	dup, err := svr.AddBanner(c, v.Image, v.Link, v.StartAt, v.EndAt)
+	if err != nil {
+		log.Error("growup svr.AddBanner error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    dup,
+	}))
+}
+
+func editBanner(c *bm.Context) {
+	v := new(struct {
+		ID      int64  `form:"id" validate:"required"`
+		Image   string `form:"image" validate:"required"`
+		Link    string `form:"link" validate:"required"`
+		StartAt int64  `form:"start_at" validate:"required"`
+		EndAt   int64  `form:"end_at" validate:"required"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	dup, err := svr.EditBanner(c, v.ID, v.StartAt, v.EndAt, v.Image, v.Link)
+	if err != nil {
+		log.Error("growup svr.AddBanner error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    dup,
+	}))
+}
+
+func off(c *bm.Context) {
+	v := new(struct {
+		ID int64 `form:"id" validate:"required"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.Off(c, time.Now().Unix(), v.ID)
+	if err != nil {
+		log.Error("growup svr.AddBanner error(%v)", err)
+	}
+	c.JSON(nil, err)
+}

app/admin/main/growup/http/blacklist.go

@@ -0,0 +1,90 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func queryBlacklist(c *bm.Context) {
+	v := new(struct {
+		FromTime int64  `form:"from_time"`
+		ToTime   int64  `form:"to_time"`
+		Type     int    `form:"type"`
+		Reason   int    `form:"reason"`
+		MID      int64  `form:"mid"`
+		Nickname string `form:"nickname"`
+		AID      int64  `form:"aid"`
+		From     int    `form:"from" validate:"min=0" default:"0"`
+		Limit    int    `form:"limit" validate:"min=1" default:"20"`
+		Sort     string `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	total, blacklist, err := svr.QueryBlacklist(v.FromTime, v.ToTime, v.Type, v.Reason, v.MID, v.Nickname, v.AID, v.From, v.Limit, v.Sort)
+	if err != nil {
+		log.Error("growup svr.QueryBlacklist error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    blacklist,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func exportBlack(c *bm.Context) {
+	v := new(struct {
+		FromTime int64  `form:"from_time"`
+		ToTime   int64  `form:"to_time"`
+		Type     int    `form:"type"`
+		Reason   int    `form:"reason"`
+		MID      int64  `form:"mid"`
+		Nickname string `form:"nickname"`
+		AID      int64  `form:"aid"`
+		From     int    `form:"from" validate:"min=0" default:"0"`
+		Limit    int    `form:"limit" validate:"min=1" default:"20"`
+		Sort     string `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	content, err := svr.ExportBlacklist(v.FromTime, v.ToTime, v.Type, v.Reason, v.MID, v.Nickname, v.AID, v.From, v.Limit, v.Sort)
+	if err != nil {
+		log.Error("growup svr.ExportBlacklist error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "blacklist"),
+	})
+}
+
+func recoverBlacklist(c *bm.Context) {
+	v := new(struct {
+		AID  int64 `form:"aid"`
+		Type int   `form:"type"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.RecoverBlacklist(v.AID, v.Type)
+	if err != nil {
+		log.Error("growup svr.RecoverBlacklist error(%v)", err)
+	}
+	c.JSON(nil, err)
+}

app/admin/main/growup/http/budgetstatistics.go

@@ -0,0 +1,80 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func budgetDayStatistics(c *bm.Context) {
+	v := new(struct {
+		Type  int `form:"type"`
+		From  int `form:"from" default:"0" validate:"min=0"`
+		Limit int `form:"limit" default:"20" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	total, infos, err := svr.BudgetDayStatistics(c, v.Type, v.From, v.Limit)
+	if err != nil {
+		log.Error("s.budgetDayStatistics error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code": 0,
+		"data": infos,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func budgetDayGraph(c *bm.Context) {
+	v := new(struct {
+		Type int `form:"type"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	info, err := svr.BudgetDayGraph(c, v.Type)
+	if err != nil {
+		log.Error("s.budgetDayGraph error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code": 0,
+		"data": info,
+	}))
+}
+
+func budgetMonthStatistics(c *bm.Context) {
+	v := new(struct {
+		Type  int `form:"type"`
+		From  int `form:"from" default:"0" validate:"min=0"`
+		Limit int `form:"limit" default:"20" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	total, infos, err := svr.BudgetMonthStatistics(c, v.Type, v.From, v.Limit)
+	if err != nil {
+		log.Error("s.budgetMonthStatistics BudgetMonthStatistics error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code": 0,
+		"data": infos,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}

app/admin/main/growup/http/charge.go

@@ -0,0 +1,96 @@
+package http
+
+import (
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func archiveChargeStatis(c *bm.Context) {
+	v := new(struct {
+		CategoryID []int64 `form:"category_id,split"`
+		Type       int     `form:"type"`
+		GroupType  int     `form:"group_type" default:"1"`
+		FromTime   int64   `form:"from_time" validate:"required,min=1"`
+		ToTime     int64   `form:"to_time" validate:"required,min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := incomeSvr.ArchiveChargeStatis(c, v.CategoryID, v.Type, v.GroupType, v.FromTime, v.ToTime)
+	if err != nil {
+		log.Error("incomeSvr.ArchiveChargeStatis error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func archiveChargeSection(c *bm.Context) {
+	v := new(struct {
+		CategoryID []int64 `form:"category_id,split"`
+		Type       int     `form:"type"`
+		GroupType  int     `form:"group_type" default:"1"`
+		FromTime   int64   `form:"from_time" validate:"required,min=1"`
+		ToTime     int64   `form:"to_time" validate:"required,min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := incomeSvr.ArchiveChargeSection(c, v.CategoryID, v.Type, v.GroupType, v.FromTime, v.ToTime)
+	if err != nil {
+		log.Error("growup incomeSvr.ArchiveChargeSection error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func archiveChargeDetail(c *bm.Context) {
+	v := new(struct {
+		AID  int64 `form:"aid" validate:"required"`
+		Type int   `form:"type"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := incomeSvr.ArchiveChargeDetail(c, v.AID, v.Type)
+	if err != nil {
+		log.Error("growup incomeSvr.ArchiveDetail error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func bgmChargeDetail(c *bm.Context) {
+	v := new(struct {
+		SID int64 `form:"sid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := incomeSvr.BgmChargeDetail(c, v.SID)
+	if err != nil {
+		log.Error("growup incomeSvr.BgmChargeDetail error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func upRatio(c *bm.Context) {
+	v := new(struct {
+		From  int64 `form:"from"`
+		Limit int64 `form:"limit" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := incomeSvr.UpRatio(c, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup incomeSvr.UpRatio error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}

app/admin/main/growup/http/cheat.go

@@ -0,0 +1,155 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func cheatUps(c *bm.Context) {
+	v := new(struct {
+		MID      int64  `form:"mid"`
+		Nickname string `form:"nickname"`
+		From     int    `form:"from" validate:"min=0" default:"0"`
+		Limit    int    `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	total, spies, err := svr.CheatUps(c, v.MID, v.Nickname, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup svr.CheatUps error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    spies,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func cheatArchives(c *bm.Context) {
+	v := new(struct {
+		MID       int64  `form:"mid"`
+		ArchiveID int64  `form:"archive_id"`
+		Nickname  string `form:"nickname"`
+		From      int    `form:"from" validate:"min=0" default:"0"`
+		Limit     int    `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	total, spies, err := svr.CheatArchives(c, v.MID, v.ArchiveID, v.Nickname, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup svr.CheatUps error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    spies,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func exportCheatUps(c *bm.Context) {
+	v := new(struct {
+		MID      int64  `form:"mid"`
+		Nickname string `form:"nickname"`
+		From     int    `form:"from" validate:"min=0" default:"0"`
+		Limit    int    `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	content, err := svr.ExportCheatUps(c, v.MID, v.Nickname, v.From, v.Limit)
+	if err != nil {
+		log.Error("s.exportSpyUp ExportSpyUp error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "cheat_ups"),
+	})
+}
+
+func exportCheatAvs(c *bm.Context) {
+	v := new(struct {
+		MID       int64  `form:"mid"`
+		Nickname  string `form:"nickname"`
+		ArchiveID int64  `form:"archive_id"`
+		From      int    `form:"from" validate:"min=0" default:"0"`
+		Limit     int    `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	content, err := svr.ExportCheatAvs(c, v.MID, v.ArchiveID, v.Nickname, v.From, v.Limit)
+	if err != nil {
+		log.Error("s.exportSpyAV ExportSpyAV error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "cheat_avs"),
+	})
+}
+
+func queryCheatFans(c *bm.Context) {
+	v := new(struct {
+		From  int64 `form:"from" default:"0" validate:"min=0"`
+		Limit int64 `form:"limit" default:"20" validate:"min=1"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	total, fans, err := svr.QueryCheatFans(c, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup svr.QueryCheatFans error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code": 0,
+		"data": fans,
+		"paging": map[string]int64{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func cheatFans(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.CheatFans(c, v.MID)
+	if err != nil {
+		log.Error("Exec cheatFans error!(%v)", err)
+	}
+	c.JSON(nil, err)
+}

app/admin/main/growup/http/csv.go

@@ -0,0 +1,47 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// CSVContentType
+var (
+	CSVContentType        = []string{"application/csv"}
+	_              Render = CSV{}
+)
+
+// Render http reponse render.
+type Render interface {
+	Render(http.ResponseWriter) error
+	WriteContentType(w http.ResponseWriter)
+}
+
+// CSV str.
+type CSV struct {
+	Content []byte
+	Title   string
+}
+
+// WriteContentType fn
+func (j CSV) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, CSVContentType, j.Title)
+}
+
+func writeContentType(w http.ResponseWriter, value []string, title string) {
+	header := w.Header()
+	if val := header["Content-Type"]; len(val) == 0 {
+		header["Content-Type"] = value
+	}
+	header["Content-Disposition"] = append(header["Content-Disposition"], fmt.Sprintf("attachment; filename=%s.csv", title))
+}
+
+// Render (JSON) writes data with json ContentType.
+func (j CSV) Render(w http.ResponseWriter) (err error) {
+	if _, err = w.Write(j.Content); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}

app/admin/main/growup/http/http.go

@@ -0,0 +1,235 @@
+package http
+
+import (
+	"go-common/app/admin/main/growup/conf"
+	"go-common/app/admin/main/growup/service"
+	"go-common/app/admin/main/growup/service/income"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+var (
+	svr       *service.Service
+	incomeSvr *income.Service
+)
+
+// Init init
+func Init(c *conf.Config, s *service.Service) {
+	svr = s
+	incomeSvr = income.New(conf.Conf)
+	engine := bm.DefaultServer(c.BM)
+	initRouter(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func initRouter(r *bm.Engine) {
+	r.Ping(ping)
+	// 在up-profit.bilibili.co域名下
+	b := r.Group("/allowance/api/x/admin/growup")
+	up := b.Group("/up")
+	{
+		up.GET("/list", queryForUps)
+		up.POST("/add", add)
+		up.POST("/reject", reject)
+		up.POST("/pass", pass)
+		up.POST("/dismiss", dismiss)
+		up.POST("/forbid", forbid)
+		up.POST("/recovery", recovery)
+		up.POST("/delete", deleteUp)
+		up.POST("/state", updateAccountState)
+		up.POST("/account/delete", delUpAccount)
+		up.POST("/account/update", updateUpAccount)
+		up.GET("/export", exportUps)
+		up.POST("/white/add", addWhite)
+		up.GET("/account/state", upState)
+		credit := up.Group("/credit")
+		{
+			credit.GET("/list", creditRecords)
+			credit.POST("/recover", recoverCredit)
+		}
+	}
+	block := b.Group("/block")
+	{
+		block.GET("/list", queryFromBlocked)
+		block.POST("/add", addToBlocked)
+		block.POST("/delete", deleteFromBlocked)
+	}
+	authority := b.Group("/authority")
+	{
+		authority.GET("/user/privileges", getAuthorityUserPrivileges)
+		authority.GET("/user/groups", getAuthorityUserGroup)
+
+		authority.GET("/user/list", listAuthorityUsers)
+		authority.POST("/user/add", addAuthorityUser)
+		authority.POST("/user/update/info", updateAuthorityUserInfo)
+		authority.POST("/user/update/auth", updateAuthorityUserAuth)
+		authority.POST("/user/delete", deleteAuthorityUser)
+
+		authority.GET("/taskgroup/list", listAuthorityTaskGroups)
+		authority.POST("/taskgroup/add", addAuthorityTaskGroup)
+		authority.POST("/taskgroup/add/user", addAuthorityTaskGroupUser)
+		authority.POST("/taskgroup/update/info", updateAuthorityTaskGroupInfo)
+		authority.POST("/taskgroup/delete", deleteAuthorityTaskGroup)
+		authority.POST("/taskgroup/delete/user", deleteAuthorityTaskGroupUser)
+		authority.GET("/taskgroup/list/privilege", listAuthorityGroupPrivilege)
+		authority.POST("/taskgroup/update/privilege", updateAuthorityGroupPrivilege)
+
+		authority.GET("/taskrole/list", listAuthorityTaskRoles)
+		authority.POST("/taskrole/add", addAuthorityTaskRole)
+		authority.POST("/taskrole/add/user", addAuthorityTaskRoleUser)
+		authority.POST("/taskrole/update/info", updateAuthorityTaskRoleInfo)
+		authority.POST("/taskrole/delete", deleteAuthorityTaskRole)
+		authority.POST("/taskrole/delete/user", deleteAuthorityTaskRoleUser)
+		authority.GET("/taskrole/list/privilege", listAuthorityRolePrivilege)
+		authority.POST("/taskrole/update/privilege", updateAuthorityRolePrivilege)
+
+		authority.GET("/list/groupandrole", listAuthorityGroupAndRole) //list task groups and task roles
+		authority.GET("/privilege/list", listPrivilege)
+		authority.POST("/privilege/add", addPrivilege)
+		authority.POST("/privilege/update", updatePrivilege)
+
+		// merge business and privilege
+		authority.GET("/business", busPrivilege)
+	}
+	tag := b.Group("/tag")
+	{
+		tag.POST("/add", addTagInfo)
+		tag.POST("/update", updateTagInfo)
+		tag.POST("/state", modTagState)
+		tag.POST("/addups", addTagUps)
+		tag.POST("/release", releaseUp)
+		tag.GET("/list", listTagInfo)
+		tag.GET("/listup", listUps)
+		tag.GET("/listav", listAvs)
+		tag.GET("/details", tagDetails)
+		tag.POST("/update/activity", updateActivity)
+	}
+	income := b.Group("/income")
+	{
+		income.GET("/up/list", upIncomeList)
+		income.GET("/up/list/export", upIncomeListExport)
+		income.GET("/up/statis", upIncomeStatis)
+		income.GET("/archive/detail", archiveDetail)
+		income.GET("/archive/statis", archiveStatis)
+		income.GET("/archive/section", archiveSection)
+		income.GET("/archive/top", archiveTop)
+		income.GET("/bgm/detail", bgmDetail)
+		income.POST("/archive/black", archiveBlack)
+		income.POST("/archive/breach", archiveBreach)
+		income.GET("/up/withdraw", upWithdraw)
+		income.GET("/up/withdraw/export", upWithdrawExport)
+		income.GET("/up/withdraw/statis", upWithdrawStatis)
+		income.GET("/up/withdraw/detail", upWithdrawDetail)
+		income.GET("/up/withdraw/detail/export", upWithdrawDetailExport)
+		income.GET("/breach/list", breachList)
+		income.GET("/breach/statis", breachStatis)
+		income.GET("/breach/export", exportBreach)
+		income.GET("/black/list", queryBlacklist)
+		income.GET("/black/export", exportBlack)
+		income.POST("/black/recover", recoverBlacklist)
+	}
+	notice := b.Group("/notice")
+	{
+		notice.GET("/list", notices)
+		notice.POST("/add", insertNotice)
+		notice.POST("/update", updateNotice)
+	}
+	cheat := b.Group("/cheat")
+	{
+		cheat.GET("/up", cheatUps)
+		cheat.GET("/av", cheatArchives)
+		cheat.GET("/export/up", exportCheatUps)
+		cheat.GET("/export/av", exportCheatAvs)
+		cheat.GET("/up/fans", queryCheatFans)
+		cheat.POST("/up/info", cheatFans)
+	}
+	charge := b.Group("/charge")
+	{
+		charge.GET("/archive/statis", archiveChargeStatis)
+		charge.GET("/archive/section", archiveChargeSection)
+		charge.GET("/archive/detail", archiveChargeDetail)
+		charge.GET("/bgm/detail", bgmChargeDetail)
+		charge.GET("/up/ratio", upRatio)
+	}
+	b.POST("/upload", upload)
+
+	budget := b.Group("/budget")
+	{
+		budget.GET("/day/info", budgetDayStatistics)
+		budget.GET("/day/graph", budgetDayGraph)
+		budget.GET("/month/info", budgetMonthStatistics)
+	}
+
+	banner := b.Group("/banner")
+	{
+		banner.GET("/list", banners)
+		banner.POST("/add", addBanner)
+		banner.POST("/edit", editBanner)
+		banner.POST("/off", off)
+	}
+
+	activity := b.Group("/activity")
+	{
+		activity.POST("/add", activityAdd)
+		activity.GET("/list", activityList)
+		activity.POST("/update", activityUpdate)
+		activity.GET("/sign_up", activitySignUp)
+		activity.GET("/winners", activityWinners)
+		activity.POST("/award", activityAward)
+	}
+	auto := b.Group("/auto")
+	{
+		auto.POST("/archive/breach", autoBreach)
+		auto.POST("/up/dismiss", autoDismiss)
+		auto.POST("/up/forbid", autoForbid)
+	}
+	offlineActivity := b.Group("/offlineactivity")
+	{
+		offlineActivity.POST("/add", offlineactivityAdd)
+		offlineActivity.POST("/pre_add", offlineactivityPreAdd)
+		offlineActivity.POST("/upload", uploadLocal)
+		offlineActivity.GET("/query/activity", offlineactivityQueryActivity)
+		offlineActivity.GET("/query/upbonus_summary", offlineactivityQueryUpBonusSummary)
+		offlineActivity.GET("/query/upbonus_activity", offlineactivityQueryUpBonusActivity)
+		offlineActivity.GET("/query/month", offlineactivityQueryMonth)
+	}
+
+	// 激励金兑换
+	trade := b.Group("/trade")
+	{
+		// goods query
+		trade.GET("/goods/list", goodsList)
+		// goods mng
+		trade.GET("/goods/sync", goodsSync)
+		trade.POST("/goods/update", goodsUpdate)
+		trade.POST("/goods/display_set", goodsDisplay)
+		// order query
+		trade.GET("/order/list", orderList)
+		trade.GET("/order/export", orderExport)
+		trade.GET("/order/statistics", orderStatistics)
+	}
+
+	// 专项奖
+	award := b.Group("/special_award")
+	{
+		award.POST("/add", awardAdd)                      //新增专项奖
+		award.POST("/update", awardUpdate)                //编辑专项奖
+		award.GET("/list", awardList)                     //专项奖列表
+		award.GET("/detail", awardDetail)                 //专项奖详情
+		award.GET("/winner/list", awardWinnerList)        //获奖者列表
+		award.GET("/winner/export", awardWinnerExport)    //获奖者导出
+		award.POST("/winner/replace", awardWinnerReplace) //获奖者替换
+		award.GET("/result", awardResult)                 //评奖信息查询
+		award.POST("/result/save", awardResultSave)       //评奖信息录入
+	}
+
+	// 在api.bilibili.co域名下，建议迁移到service
+	api := r.Group("/x/internal/growup")
+	{
+		api.GET("/offlineactivity/callback", offlineactivityShellCallback)
+	}
+}

app/admin/main/growup/http/income.go

@@ -0,0 +1,390 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func upIncomeList(c *bm.Context) {
+	v := new(struct {
+		MIDs      []int64 `form:"mids,split"`
+		Type      int     `form:"type"`
+		GroupType int     `form:"group_type" default:"1"`
+		FromTime  int64   `form:"from_time" validate:"required,min=1"`
+		ToTime    int64   `form:"to_time" validate:"required,min=1"`
+		MinIncome int64   `form:"min_income"`
+		MaxIncome int64   `form:"max_income"`
+		From      int     `form:"from" validate:"min=0" default:"0"`
+		Limit     int     `form:"limit" validate:"min=1" default:"20"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, total, err := incomeSvr.UpIncomeList(c, v.MIDs, v.Type, v.GroupType, v.FromTime, v.ToTime, v.MinIncome, v.MaxIncome, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup incomeSvr.UpIncomeList error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func upIncomeListExport(c *bm.Context) {
+	v := new(struct {
+		MIDs      []int64 `form:"mids,split"`
+		Type      int     `form:"type"`
+		GroupType int     `form:"group_type" default:"1"`
+		FromTime  int64   `form:"from_time" validate:"min=1,required"`
+		ToTime    int64   `form:"to_time" validate:"min=1,required"`
+		MinIncome int64   `form:"min_income"`
+		MaxIncome int64   `form:"max_income"`
+		From      int     `form:"from" validate:"min=0" default:"0"`
+		Limit     int     `form:"limit" validate:"min=1" default:"20"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	content, err := incomeSvr.UpIncomeListExport(c, v.MIDs, v.Type, v.GroupType, v.FromTime, v.ToTime, v.MinIncome, v.MaxIncome, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup incomeSvr.UpIncomeListExport error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "up_income"),
+	})
+}
+
+func upIncomeStatis(c *bm.Context) {
+	v := new(struct {
+		MIDs      []int64 `form:"mids,split"`
+		Type      int     `form:"type"`
+		GroupType int     `form:"group_type" default:"1"`
+		FromTime  int64   `form:"from_time" validate:"required,min=1"`
+		ToTime    int64   `form:"to_time" validate:"required,min=1"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, err := incomeSvr.UpIncomeStatis(c, v.MIDs, v.Type, v.GroupType, v.FromTime, v.ToTime)
+	if err != nil {
+		log.Error("growup incomeSvr.UpIncomeStatis error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+	}))
+}
+
+func archiveStatis(c *bm.Context) {
+	v := new(struct {
+		CategoryID []int64 `form:"category_id,split"`
+		Type       int     `form:"type"`
+		GroupType  int     `form:"group_type" default:"1"`
+		FromTime   int64   `form:"from_time" validate:"required,min=1"`
+		ToTime     int64   `form:"to_time" validate:"required,min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := incomeSvr.ArchiveStatis(c, v.CategoryID, v.Type, v.GroupType, v.FromTime, v.ToTime)
+	if err != nil {
+		log.Error("growup incomeSvr.ArchiveStatis error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+	}))
+}
+
+func archiveSection(c *bm.Context) {
+	v := new(struct {
+		CategoryID []int64 `form:"category_id,split"`
+		Type       int     `form:"type"`
+		GroupType  int     `form:"group_type" default:"1"`
+		FromTime   int64   `form:"from_time" validate:"required,min=1"`
+		ToTime     int64   `form:"to_time" validate:"required,min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := incomeSvr.ArchiveSection(c, v.CategoryID, v.Type, v.GroupType, v.FromTime, v.ToTime)
+	if err != nil {
+		log.Error("growup incomeSvr.ArchiveSection error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+	}))
+}
+
+func archiveDetail(c *bm.Context) {
+	v := new(struct {
+		MID       int64 `form:"mid" validate:"required"`
+		Type      int   `form:"type"`
+		GroupType int   `form:"group_type" default:"1"`
+		FromTime  int64 `form:"from_time" validate:"required,min=1"`
+		ToTime    int64 `form:"to_time" validate:"required,min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, err := incomeSvr.ArchiveDetail(c, v.MID, v.Type, v.GroupType, v.FromTime, v.ToTime)
+	if err != nil {
+		log.Error("growup incomeSvr.ArchiveDetail error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+	}))
+}
+
+func archiveTop(c *bm.Context) {
+	v := new(struct {
+		AIDs      []int64 `form:"aids,split"`
+		Type      int     `form:"type"`
+		GroupType int     `form:"group_type" default:"1"`
+		FromTime  int64   `form:"from_time" validate:"required,min=1"`
+		ToTime    int64   `form:"to_time" validate:"required,min=1"`
+		From      int     `form:"from" validate:"min=0" default:"0"`
+		Limit     int     `form:"limit" validate:"min=1" default:"20"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, total, err := incomeSvr.ArchiveTop(c, v.AIDs, v.Type, v.GroupType, v.FromTime, v.ToTime, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup incomeSvr.ArchiveTop error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func bgmDetail(c *bm.Context) {
+	v := new(struct {
+		SID      int64 `form:"sid"`
+		FromTime int64 `form:"from_time" validate:"required,min=1"`
+		ToTime   int64 `form:"to_time" validate:"required,min=1"`
+		From     int   `form:"from" validate:"min=0" default:"0"`
+		Limit    int   `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, total, err := incomeSvr.BgmDetail(c, v.SID, v.FromTime, v.ToTime, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup incomeSvr.BgmDetail error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func archiveBreach(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	v := new(struct {
+		Type   int     `form:"type"`
+		AIDs   []int64 `form:"aids,split" validate:"required"`
+		MID    int64   `form:"mid" validate:"required"`
+		Reason string  `form:"reason" validate:"required"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+
+	err = incomeSvr.ArchiveBreach(c, v.Type, v.AIDs, v.MID, v.Reason, username)
+	if err != nil {
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    500,
+			"message": err.Error(),
+		}))
+	} else {
+		c.JSON(nil, nil)
+	}
+}
+
+func archiveBlack(c *bm.Context) {
+	v := new(struct {
+		Type int     `form:"type"`
+		AIDs []int64 `form:"aids,split" validate:"required"`
+		MID  int64   `form:"mid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := incomeSvr.ArchiveBlack(c, v.Type, v.AIDs, v.MID)
+	if err != nil {
+		log.Error("growup incomeSvr.ArchiveBlack error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func breachList(c *bm.Context) {
+	v := new(struct {
+		MIDs     []int64 `form:"mids,split"`
+		AIDs     []int64 `form:"aids,split"`
+		Type     int     `form:"type"`
+		FromTime int64   `form:"from_time" validate:"required,min=1"`
+		ToTime   int64   `form:"to_time" validate:"required,min=1"`
+		Reason   string  `form:"reason"`
+		From     int     `form:"from" validate:"min=0" default:"0"`
+		Limit    int     `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, total, err := incomeSvr.BreachList(c, v.MIDs, v.AIDs, v.Type, v.FromTime, v.ToTime, v.Reason, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup incomeSvr.BreachList error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func breachStatis(c *bm.Context) {
+	v := new(struct {
+		MIDs      []int64 `form:"mids,split"`
+		AIDs      []int64 `form:"aids,split"`
+		Type      int     `form:"type"`
+		GroupType int     `form:"group_type"`
+		FromTime  int64   `form:"from_time" validate:"required,min=1"`
+		ToTime    int64   `form:"to_time" validate:"required,min=1"`
+		Reason    string  `form:"reason"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, err := incomeSvr.BreachStatis(c, v.MIDs, v.AIDs, v.Type, v.GroupType, v.FromTime, v.ToTime, v.Reason)
+	if err != nil {
+		log.Error("growup incomeSvr.BreachStatis error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+	}))
+}
+
+func exportBreach(c *bm.Context) {
+	v := new(struct {
+		MIDs     []int64 `form:"mids,split"`
+		AIDs     []int64 `form:"aids,split"`
+		Type     int     `form:"type"`
+		FromTime int64   `form:"from_time" validate:"required,min=1"`
+		ToTime   int64   `form:"to_time" validate:"required,min=1"`
+		Reason   string  `form:"reason"`
+		From     int     `form:"from" validate:"min=0" default:"0"`
+		Limit    int     `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	content, err := incomeSvr.ExportBreach(c, v.MIDs, v.AIDs, v.Type, v.FromTime, v.ToTime, v.Reason, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup svr.ExportBreach error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "breach_record"),
+	})
+}

app/admin/main/growup/http/local.go

@@ -0,0 +1,17 @@
+package http
+
+import (
+	"net/http"
+
+	"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 = svr.Ping(c); err != nil {
+		log.Error("growup-admin ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/admin/main/growup/http/notice.go

@@ -0,0 +1,75 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func notices(c *bm.Context) {
+	v := new(struct {
+		Type     int `form:"type"`
+		Status   int `form:"status"`
+		Platform int `form:"platform"`
+		From     int `form:"from" default:"0" validate:"min=0"`
+		Limit    int `form:"limit" default:"20" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	total, notices, err := svr.Notices(c, v.Type, v.Status, v.Platform, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup svr.Notices error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    notices,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func insertNotice(c *bm.Context) {
+	v := new(struct {
+		Title    string `form:"title" validate:"required"`
+		Type     int    `form:"type" validate:"required"`
+		Platform int    `form:"platform" validate:"required"`
+		Link     string `form:"link" validate:"required"`
+		Status   int    `form:"status" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.InsertNotice(c, v.Title, v.Type, v.Platform, v.Link, v.Status)
+	if err != nil {
+		log.Error("growup svr.Notices error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func updateNotice(c *bm.Context) {
+	v := new(struct {
+		ID       int64  `form:"id"`
+		Title    string `form:"title"`
+		Type     int    `form:"type"`
+		Platform int    `form:"platform"`
+		Link     string `form:"link"`
+		Status   int    `form:"status"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.UpdateNotice(c, v.Type, v.Platform, v.Title, v.Link, v.ID, v.Status)
+	if err != nil {
+		log.Error("growup svr.Notices error(%v)", err)
+	}
+	c.JSON(nil, err)
+}

app/admin/main/growup/http/offlineactivity.go

@@ -0,0 +1,226 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"go-common/app/admin/main/growup/dao/shell"
+	"go-common/app/admin/main/growup/model"
+	"go-common/app/admin/main/growup/model/offlineactivity"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+	"io/ioutil"
+	"net/http"
+	"reflect"
+)
+
+func bmHTTPErrorWithMsg(c *blademaster.Context, err error, msg string) {
+	if c.IsAborted() {
+		return
+	}
+	c.Error = err
+	bcode := ecode.Cause(err)
+	if msg == "" {
+		msg = err.Error()
+	}
+	c.Render(http.StatusOK, render.JSON{
+		Code:    bcode.Code(),
+		Message: msg,
+		Data:    nil,
+	})
+}
+
+func checkCookieFun(c *blademaster.Context) (err error) {
+	_, _, err = checkCookie(c)
+	return
+}
+
+// service的函数原型
+type serviceFunc func(context context.Context, arg interface{}) (res interface{}, err error)
+
+// response writer
+type responseWriter func(c *blademaster.Context, arg interface{}, res interface{}, err error)
+
+type argParser func(c *blademaster.Context, arg interface{}) (err error)
+
+func argGetParser(c *blademaster.Context, arg interface{}) (err error) {
+	err = c.Bind(arg)
+	return
+}
+func argPosJSONParser(c *blademaster.Context, arg interface{}) (err error) {
+	respBody, _ := ioutil.ReadAll(c.Request.Body)
+	if err = json.Unmarshal(respBody, arg); err != nil {
+		log.Error("json unmarshal fail, err=%v", err)
+	}
+	return
+}
+
+func jsonWriter(c *blademaster.Context, arg interface{}, res interface{}, err error) {
+	c.JSON(res, err)
+}
+
+func csvWriter(c *blademaster.Context, arg interface{}, res interface{}, err error) {
+	formater, ok := res.(model.CsvFormatter)
+	if !ok {
+		log.Error("res cannot convert CsvFommater, res type=%s", reflect.TypeOf(res).Name())
+		c.String(ecode.ServerErr.Code(), "res cannot convert CsvFommater")
+		return
+	}
+
+	c.Writer.Header().Set("Content-Type", "application/csv")
+	c.Writer.Header().Set("Content-Disposition", fmt.Sprintf("attachment;filename=\"%s\"", formater.GetFileName()))
+
+	var buf = &bytes.Buffer{}
+	var csvWriter = csv.NewWriter(buf)
+	formater.ToCsv(csvWriter)
+	csvWriter.Flush()
+	c.Writer.Write(buf.Bytes())
+}
+
+func decideWriter(c *blademaster.Context, arg interface{}, res interface{}, err error) {
+	var writer responseWriter
+	var decider, ok = arg.(model.ExportArgInterface)
+	if ok {
+		switch decider.ExportFormat() {
+		case "json":
+			writer = jsonWriter
+		case "csv":
+			writer = csvWriter
+		}
+	}
+
+	if writer != nil {
+		writer(c, arg, res, err)
+	} else {
+		jsonWriter(c, arg, res, err)
+	}
+}
+
+func httpGetFuncWithWriter(arg interface{}, sfunc serviceFunc, description string, writer responseWriter) func(*blademaster.Context) {
+	return httpGenerateFunc(arg, sfunc, description, argGetParser, writer)
+}
+
+func httpGenerateFunc(arg interface{}, sfunc serviceFunc, description string, parser argParser, writer responseWriter, preFuncs ...func(*blademaster.Context) error) func(*blademaster.Context) {
+	return func(c *blademaster.Context) {
+		var res interface{}
+		var err error
+		var errMsg string
+	exitswitch:
+		switch {
+		default:
+			for _, f := range preFuncs {
+				err = f(c)
+				if err != nil {
+					log.Error("request err=%s, arg=%+v", err, arg)
+					break exitswitch
+				}
+			}
+
+			if err = parser(c, arg); err != nil {
+				log.Error("%s, request argument bind fail, err=%v", description, err)
+				errMsg = fmt.Sprintf("wrong argument, %s", err.Error())
+				err = ecode.RequestErr
+				break
+			}
+
+			var scoreRes, e = sfunc(c, arg)
+			err = e
+			if e != nil {
+				errMsg = err.Error()
+				log.Error("%s query fail, req=%+v, err=%+v", description, arg, err)
+				break
+			}
+			log.Info("%s query ok, req=%+v, result=%+v", description, arg, scoreRes)
+			res = scoreRes
+		}
+		if err != nil {
+			bmHTTPErrorWithMsg(c, err, errMsg)
+		} else {
+			writer(c, arg, res, err)
+		}
+	}
+}
+
+func httpPostFunCheckCookie(arg interface{}, sfunc serviceFunc, description string, preFuncs ...func(*blademaster.Context) error) func(*blademaster.Context) {
+	preFuncs = append(preFuncs, checkCookieFun)
+	return httpGenerateFunc(arg, sfunc, description, argPosJSONParser, jsonWriter, preFuncs...)
+}
+
+// 贝壳回调
+func offlineactivityShellCallback(c *blademaster.Context) {
+	var err error
+	var v = new(shell.OrderCallbackParam)
+	if e := c.Bind(v); e != nil {
+		err = e
+		log.Error("parse arg error, err=%s", err)
+		return
+	}
+	var result = "SUCCESS"
+	if err = svr.ShellCallback(c, v); err != nil {
+		log.Error("shell call back err, err=%s, arg=%v", err, v)
+		result = "FAIL"
+	}
+	c.String(0, result)
+}
+
+func offlineactivityAdd(c *blademaster.Context) {
+	httpPostFunCheckCookie(
+		new(offlineactivity.AddActivityArg),
+		func(context context.Context, arg interface{}) (res interface{}, err error) {
+			return svr.AddOfflineActivity(context, arg.(*offlineactivity.AddActivityArg))
+		},
+		"offlineactivityAdd")(c)
+}
+
+func offlineactivityPreAdd(c *blademaster.Context) {
+	httpPostFunCheckCookie(
+		new(offlineactivity.AddActivityArg),
+		func(context context.Context, arg interface{}) (res interface{}, err error) {
+			return svr.PreAddOfflineActivity(context, arg.(*offlineactivity.AddActivityArg))
+		},
+		"offlienactivityPreAdd")(c)
+}
+
+func offlineactivityQueryActivity(c *blademaster.Context) {
+	httpGetFuncWithWriter(
+		new(offlineactivity.QueryActivityByIDArg),
+		func(context context.Context, arg interface{}) (res interface{}, err error) {
+			return svr.OfflineActivityQueryActivity(context, arg.(*offlineactivity.QueryActivityByIDArg))
+		},
+		"offlineactivityQueryActivity",
+		decideWriter)(c)
+}
+func offlineactivityQueryUpBonusSummary(c *blademaster.Context) {
+	httpGetFuncWithWriter(
+		new(offlineactivity.QueryUpBonusByMidArg),
+		func(context context.Context, arg interface{}) (res interface{}, err error) {
+			return svr.OfflineActivityQueryUpBonusSummary(context, arg.(*offlineactivity.QueryUpBonusByMidArg))
+		},
+
+		"offlineactivityQueryUpBonus",
+		decideWriter)(c)
+}
+
+func offlineactivityQueryUpBonusActivity(c *blademaster.Context) {
+	httpGetFuncWithWriter(
+		new(offlineactivity.QueryUpBonusByMidArg),
+		func(context context.Context, arg interface{}) (res interface{}, err error) {
+			return svr.OfflineActivityQueryUpBonusByActivity(context, arg.(*offlineactivity.QueryUpBonusByMidArg))
+		},
+		"offlineactivityQueryUpBonusActivity",
+		decideWriter)(c)
+}
+
+func offlineactivityQueryMonth(c *blademaster.Context) {
+	httpGetFuncWithWriter(
+		new(offlineactivity.QueryActvityMonthArg),
+		func(context context.Context, arg interface{}) (res interface{}, err error) {
+			return svr.OfflineActivityQueryActivityByMonth(context, arg.(*offlineactivity.QueryActvityMonthArg))
+		},
+		"offlineactivityQueryMonth",
+		decideWriter)(c)
+}

app/admin/main/growup/http/special_award.go

@@ -0,0 +1,163 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"go-common/app/admin/main/growup/model"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func awardAdd(c *blademaster.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	arg := new(model.AddAwardArg)
+	if err = c.BindWith(arg, binding.JSON); err != nil {
+		return
+	}
+	awardID, err := svr.AddAward(c, arg, username)
+	if err != nil {
+		log.Error("svr.AddAward err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(awardID, nil)
+}
+
+func awardUpdate(c *blademaster.Context) {
+	arg := new(model.SaveAwardArg)
+	if err := c.BindWith(arg, binding.JSON); err != nil {
+		return
+	}
+	err := svr.UpdateAward(c, arg)
+	if err != nil {
+		log.Error("svr.UpdateAward err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(true, nil)
+}
+
+func awardList(c *blademaster.Context) {
+	arg := new(struct {
+		From  int `form:"from" validate:"min=0" default:"0"`
+		Limit int `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	total, list, err := svr.ListAward(c, arg.From, arg.Limit)
+	if err != nil {
+		log.Error("svr.ListAward err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	renderPagRes(list, total, arg.Limit)(c)
+}
+
+func awardDetail(c *blademaster.Context) {
+	arg := new(struct {
+		AwardID int64 `form:"award_id" validate:"required"`
+	})
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	data, err := svr.DetailAward(c, arg.AwardID)
+	if err != nil {
+		log.Error("svr.DetailAward err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func awardWinnerList(c *blademaster.Context) {
+	arg := new(model.QueryAwardWinnerArg)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	total, list, err := svr.ListAwardWinner(c, arg)
+	if err != nil {
+		log.Error("svr.ListAwardRecord err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	renderPagRes(list, total, arg.Limit)(c)
+}
+
+func awardWinnerExport(c *blademaster.Context) {
+	arg := new(model.QueryAwardWinnerArg)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	content, err := svr.ExportAwardWinner(c, arg)
+	if err != nil {
+		log.Error("svr.ExportAwardWinner err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "award_winner"),
+	})
+}
+
+func awardResult(c *blademaster.Context) {
+	arg := new(struct {
+		AwardID int64 `form:"award_id" validate:"required"`
+	})
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	data, err := svr.AwardResult(c, arg.AwardID)
+	if err != nil {
+		log.Error("svr.AwardResult err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+func awardResultSave(c *blademaster.Context) {
+	arg := new(model.AwardResult)
+	if err := c.BindWith(arg, binding.JSON); err != nil {
+		return
+	}
+	if arg.AwardID == 0 {
+		c.JSON(false, ecode.Error(ecode.RequestErr, "illegal award_id"))
+		return
+	}
+	err := svr.SaveAwardResult(c, arg)
+	if err != nil {
+		log.Error("svr.SaveAwardResult err(%v)", err)
+		c.JSON(false, err)
+		return
+	}
+	c.JSON(true, nil)
+}
+
+func awardWinnerReplace(c *blademaster.Context) {
+	arg := new(struct {
+		AwardID int64 `form:"award_id" validate:"required"`
+		PrevMID int64 `form:"prev_mid" validate:"required"`
+		MID     int64 `form:"mid" validate:"required"`
+	})
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	err := svr.ReplaceAwardWinner(c, arg.AwardID, arg.PrevMID, arg.MID)
+	if err != nil {
+		log.Error("svr.ReplaceAwardWinner err(%v)", err)
+		c.JSON(false, err)
+		return
+	}
+	c.JSON(true, nil)
+}

app/admin/main/growup/http/tag.go

@@ -0,0 +1,235 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/admin/main/growup/model"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func addTagInfo(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup checkCookie error(%v)", err)
+		return
+	}
+	v := new(model.TagInfo)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+
+	err = svr.AddTagInfo(c, v, username)
+	if err != nil {
+		log.Error("growup svr.AddTagInfo error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    500,
+			"message": err.Error(),
+		}))
+	} else {
+		c.JSON(nil, nil)
+	}
+}
+
+func updateTagInfo(c *bm.Context) {
+	username, _, err := checkCookie(c)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup checkCookie error(%v)", err)
+		return
+	}
+	v := new(model.TagInfo)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	err = svr.UpdateTagInfo(c, v, username)
+	if err != nil {
+		log.Error("growup svr.UpdateTagInfo error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    500,
+			"message": err.Error(),
+		}))
+	} else {
+		c.JSON(nil, nil)
+	}
+}
+
+func modTagState(c *bm.Context) {
+	v := new(struct {
+		IsDelete int `form:"is_delete"`
+		TagID    int `form:"tag_id" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.ModeTagState(c, v.TagID, v.IsDelete)
+	if err != nil {
+		log.Error("growup svr.ModTagState error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func addTagUps(c *bm.Context) {
+	v := new(struct {
+		TagID    int     `form:"tag_id" validate:"required"`
+		MIDs     []int64 `form:"mids,split"`
+		IsCommon int     `form:"is_common"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.AddTagUps(c, v.TagID, v.MIDs, v.IsCommon)
+	if err != nil {
+		log.Error("growup svr.AddTagUPs error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func releaseUp(c *bm.Context) {
+	v := new(struct {
+		TagID int   `form:"tag_id" validate:"required"`
+		MID   int64 `form:"mid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.ReleaseUp(c, v.TagID, v.MID)
+	if err != nil {
+		log.Error("growup svr.ReleaseUps error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func listTagInfo(c *bm.Context) {
+	v := new(struct {
+		StartTime  int64   `form:"start_time"`
+		EndTime    int64   `form:"end_time"`
+		Categories []int64 `form:"categories,split"`
+		Business   []int64 `form:"business,split"`
+		Tag        string  `form:"tag"`
+		Effect     int     `form:"effect"`
+		From       int     `form:"from" default:"0" validate:"min=0"`
+		Limit      int     `form:"limit" default:"20" validate:"min=1"`
+		Sort       string  `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	total, tagInfos, err := svr.QueryTagInfo(c, v.StartTime, v.EndTime, v.Categories, v.Business, v.Tag, v.Effect, v.From, v.Limit, v.Sort)
+	if err != nil {
+		log.Error("growup svr.queryTagInfo error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    tagInfos,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func listUps(c *bm.Context) {
+	v := new(struct {
+		TagID int    `form:"tag_id" validate:"required"`
+		MID   int64  `form:"mid"`
+		From  int    `form:"from" default:"0" validate:"min=0"`
+		Limit int    `form:"limit" default:"20" validate:"min=1"`
+		Sort  string `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	total, upIncomes, err := svr.ListUps(c, v.TagID, v.MID, v.From, v.Limit)
+	if err != nil {
+		log.Error("svr.ListUps error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    upIncomes,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func listAvs(c *bm.Context) {
+	v := new(struct {
+		TagID int    `form:"tag_id" validate:"required"`
+		AvID  int64  `form:"av_id"`
+		From  int    `form:"from" default:"0" validate:"min=0"`
+		Limit int    `form:"limit" default:"20" validate:"min=1"`
+		Sort  string `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	total, avIncomes, err := svr.ListAvs(c, v.TagID, v.From, v.Limit, v.AvID)
+	if err != nil {
+		log.Error("svr.ListAvs error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    avIncomes,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func tagDetails(c *bm.Context) {
+	v := new(struct {
+		TagID int    `form:"tag_id" validate:"required"`
+		From  int    `form:"from" default:"0" validate:"min=0"`
+		Limit int    `form:"limit" default:"20" validate:"min=1"`
+		Sort  string `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	total, details, err := svr.TagDetails(c, v.TagID, v.From, v.Limit)
+	if err != nil {
+		log.Error("growup svr.queryDetails error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    details,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func updateActivity(c *bm.Context) {
+	v := new(struct {
+		TagID      int64 `form:"tag_id" validate:"required"`
+		ActivityID int64 `form:"activity_id" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.UpdateTagActivity(c, v.TagID, v.ActivityID)
+	if err != nil {
+		log.Error("growup svr.AddActivity error(%v)", err)
+	}
+	c.JSON(nil, err)
+}

app/admin/main/growup/http/trade.go

@@ -0,0 +1,139 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"go-common/app/admin/main/growup/model"
+
+	"go-common/library/log"
+	"go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func goodsSync(c *blademaster.Context) {
+	var arg = new(struct {
+		GoodsType int `form:"goods_type" validate:"required"`
+	})
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	eff, err := svr.SyncGoods(c, arg.GoodsType)
+	if err != nil {
+		log.Error("svr.SyncGoods err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(eff, nil)
+}
+
+func goodsUpdate(c *blademaster.Context) {
+	var arg = new(struct {
+		ID       int64 `form:"id" validate:"required"`
+		Discount int   `form:"discount" validate:"min=1,max=100"`
+	})
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	eff, err := svr.UpdateGoodsInfo(c, arg.Discount, arg.ID)
+	if err != nil {
+		log.Error("svr.UpdateGoodsInfo err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(eff, nil)
+}
+
+func goodsDisplay(c *blademaster.Context) {
+	arg := new(struct {
+		IDs     []int64 `form:"ids,split" validate:"required"`
+		Display int     `form:"display" validate:"required"`
+	})
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	eff, err := svr.UpdateGoodsDisplay(c, model.DisplayStatus(arg.Display), arg.IDs)
+	if err != nil {
+		log.Error("svr.UpdateGoodsDisplay err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(eff, nil)
+}
+
+func goodsList(c *blademaster.Context) {
+	arg := new(struct {
+		From  int `form:"from" validate:"min=0" default:"0"`
+		Limit int `form:"limit" validate:"min=1" default:"20"`
+	})
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	total, list, err := svr.GoodsList(c, arg.From, arg.Limit)
+	if err != nil {
+		log.Error("svr.GoodsList err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	renderPagRes(list, total, arg.Limit)(c)
+}
+
+func orderList(c *blademaster.Context) {
+	arg := new(model.OrderQueryArg)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	total, list, err := svr.OrderList(c, arg, arg.From, arg.Limit)
+	if err != nil {
+		log.Error("svr.OrderList err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	renderPagRes(list, total, arg.Limit)(c)
+}
+
+func renderPagRes(list interface{}, total int64, ps int) func(c *blademaster.Context) {
+	return func(c *blademaster.Context) {
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":    0,
+			"message": "0",
+			"data":    list,
+			"paging": map[string]interface{}{
+				"page_size": ps,
+				"total":     total,
+			},
+		}))
+	}
+}
+
+func orderExport(c *blademaster.Context) {
+	arg := new(model.OrderQueryArg)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	content, err := svr.OrderExport(c, arg, arg.From, arg.Limit)
+	if err != nil {
+		log.Error("svr.OrderExport err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "creative_order"),
+	})
+}
+
+func orderStatistics(c *blademaster.Context) {
+	arg := new(model.OrderQueryArg)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	res, err := svr.OrderStatistics(c, arg)
+	if err != nil {
+		log.Error("svr.OrderStatistics err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(res, nil)
+}

app/admin/main/growup/http/upload.go

@@ -0,0 +1,141 @@
+package http
+
+import (
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"path"
+	"strings"
+	"time"
+
+	"bytes"
+	"crypto/md5"
+	"fmt"
+	"go-common/app/admin/main/growup/conf"
+	"go-common/app/admin/main/growup/dao"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+	"io"
+	"os"
+)
+
+// upload
+func upload(c *bm.Context) {
+	var (
+		fileTpye string
+		file     multipart.File
+		header   *multipart.FileHeader
+		fileName string
+		body     []byte
+		location string
+		err      error
+	)
+	if file, header, err = c.Request.FormFile("file"); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		log.Error("c.Request().FormFile(\"file\") error(%v)", err)
+		return
+	}
+	defer file.Close()
+	fileName = header.Filename
+	fileTpye = strings.TrimPrefix(path.Ext(fileName), ".")
+	if body, err = ioutil.ReadAll(file); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		log.Error("ioutil.ReadAll(c.Request().Body) error(%v)", err)
+		return
+	}
+	if location, err = svr.Upload(c, "", fileTpye, time.Now(), body); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data": struct {
+			URL string `json:"url"`
+		}{
+			location,
+		},
+	}))
+}
+
+const (
+	uploadFilePath = "/data/uploadfiles/"
+)
+
+type localUploadResult struct {
+	FileName string `json:"filename"`
+}
+type uploadResult struct {
+	localUploadResult
+	MemberCount int64 `json:"member_count"`
+}
+
+// upload
+func uploadLocal(c *bm.Context) {
+	var (
+		file   multipart.File
+		header *multipart.FileHeader
+		result uploadResult
+		err    error
+	)
+	switch {
+	default:
+		if file, header, err = c.Request.FormFile("file"); err != nil {
+			log.Error("c.Request().FormFile(\"file\") error(%v)", err)
+			break
+		}
+		if header.Size >= int64(conf.Conf.Bfs.MaxFileSize) {
+			log.Error("file is too big, filesize=%d, expected<=%d", conf.Conf.Bfs.MaxFileSize, header.Size)
+			err = fmt.Errorf("文件过大，需要小于%dkb", conf.Conf.Bfs.MaxFileSize/1024)
+			break
+		}
+		var ext = path.Ext(header.Filename)
+		if ext != ".csv" && ext != ".txt" {
+			log.Error("only csv or txt supported")
+			err = fmt.Errorf("只支持csv或txt格式文件，以逗号或换行分隔")
+			break
+		}
+
+		defer file.Close()
+		// 创建保存文件
+		if _, e := os.Stat(uploadFilePath); os.IsNotExist(e) {
+			os.MkdirAll(uploadFilePath, 0777)
+		}
+		var h = md5.New()
+		h.Write([]byte(header.Filename))
+		var filenameMd5 = fmt.Sprintf("%x", h.Sum(nil))
+		var desfilename = filenameMd5 + ext
+		var destFile *os.File
+		destFile, err = os.Create(uploadFilePath + desfilename)
+		if err != nil {
+			log.Error("Create failed: %s\n", err)
+			break
+		}
+
+		defer destFile.Close()
+		var membuf = bytes.NewBuffer(nil)
+		_, err = io.Copy(membuf, file)
+		if err != nil {
+			log.Error("err copy file, err=%s", err)
+			break
+		}
+		var midList = dao.ParseMidsFromString(membuf.String())
+		result.MemberCount = int64(len(midList))
+
+		_, err = destFile.Write(membuf.Bytes())
+		if err != nil {
+			log.Error("write file error, err=%s", err)
+			break
+		}
+		result.FileName = desfilename
+	}
+
+	if err != nil {
+		bmHTTPErrorWithMsg(c, err, err.Error())
+	} else {
+		c.JSON(&result, err)
+	}
+}

app/admin/main/growup/http/web.go

@@ -0,0 +1,353 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func add(c *bm.Context) {
+	v := new(struct {
+		MID         int64 `form:"mid"`
+		AccountType int   `form:"account_type"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.AddUp(c, v.MID, v.AccountType)
+	if err != nil {
+		log.Error("growup svr.AddUp error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func recovery(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.Recovery(c, v.MID)
+	if err != nil {
+		log.Error("growup svr.Recovery error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+// pgc移除不区分业务
+func deleteUp(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	err := svr.DeleteUp(c, v.MID)
+	if err != nil {
+		log.Error("growup svr.DeleteUp error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func queryForUps(c *bm.Context) {
+	v := new(struct {
+		BusinessType int     `form:"business_type"`
+		AccountType  int     `form:"account_type"`
+		States       []int64 `form:"account_states,split"`
+		MID          int64   `form:"mid"`
+		Category     int     `form:"category"`
+		SignType     int     `form:"sign_type"`
+		Nickname     string  `form:"nickname"`
+		Lower        int     `form:"lower"`
+		Upper        int     `form:"upper"`
+		From         int     `form:"from" default:"0" validate:"min=0"`
+		Limit        int     `form:"limit" default:"20" validate:"min=1"`
+		Sort         string  `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	ups, total, err := svr.QueryFromUpInfo(c, v.BusinessType, v.AccountType, v.States, v.MID, v.Category, v.SignType, v.Nickname, v.Lower, v.Upper, v.From, v.Limit, v.Sort)
+	if err != nil {
+		log.Error("growup svr.QueryFromUpInfo error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    ups,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func reject(c *bm.Context) {
+	v := new(struct {
+		Type   int     `form:"type"`
+		MIDs   []int64 `form:"mids,split"`
+		Reason string  `form:"reason" validate:"required"`
+		Days   int     `form:"days"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.Reject(c, v.Type, v.MIDs, v.Reason, v.Days)
+	if err != nil {
+		log.Error("growup svr.Reject error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func pass(c *bm.Context) {
+	v := new(struct {
+		Type int     `form:"type"`
+		MIDs []int64 `form:"mids,split"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.Pass(c, v.MIDs, v.Type)
+	if err != nil {
+		log.Error("growup svr.Pass error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func dismiss(c *bm.Context) {
+	v := new(struct {
+		Type   int    `form:"type"`
+		MID    int64  `form:"mid" validate:"required"`
+		Reason string `form:"reason" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	u, err := c.Request.Cookie("username")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	username := u.Value
+	err = svr.Dismiss(c, username, v.Type, 3, v.MID, v.Reason)
+	if err != nil {
+		log.Error("growup svr.Dismiss error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func forbid(c *bm.Context) {
+	v := new(struct {
+		Type   int    `form:"type"`
+		MID    int64  `form:"mid" validate:"required"`
+		Reason string `form:"reason" validate:"required"`
+		Days   int    `form:"days"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	u, err := c.Request.Cookie("username")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	username := u.Value
+	err = svr.Forbid(c, username, v.Type, 3, v.MID, v.Reason, v.Days, v.Days*86400)
+	if err != nil {
+		log.Error("growup svr.Forbid error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func addToBlocked(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.Block(c, v.MID)
+	if err != nil {
+		log.Error("growup svr.Block error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func queryFromBlocked(c *bm.Context) {
+	v := new(struct {
+		MID      int64  `form:"mid"`
+		Category int    `form:"category"`
+		Nickname string `form:"nickname"`
+		Lower    int    `form:"lower"`
+		Upper    int    `form:"upper"`
+		From     int    `form:"from" default:"0" validate:"min=0"`
+		Limit    int    `form:"limit" default:"20" validate:"min=1"`
+		Sort     string `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	ups, total, err := svr.QueryFromBlocked(c, v.MID, v.Category, v.Nickname, v.Lower, v.Upper, v.From, v.Limit, v.Sort)
+	if err != nil {
+		log.Error("growup svr.QueryFromBlocked error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"data":    ups,
+		"paging": map[string]int{
+			"page_size": v.Limit,
+			"total":     total,
+		},
+	}))
+}
+
+func deleteFromBlocked(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.DeleteFromBlocked(c, v.MID)
+	if err != nil {
+		log.Error("growup svr.DeleteFromBlocked error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func updateAccountState(c *bm.Context) {
+	v := new(struct {
+		MID   int64 `form:"mid"`
+		State int   `form:"state"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.UpdateUpAccountState(c, "up_info_video", v.MID, v.State)
+	if err != nil {
+		log.Error("growup svr.UpdateUpAccountState error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func delUpAccount(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.DelUpAccount(c, v.MID)
+	if err != nil {
+		log.Error("growup svr.DelUpAccount error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func updateUpAccount(c *bm.Context) {
+	v := new(struct {
+		MID          int64  `form:"mid" validate:"required"`
+		IsDeleted    int    `form:"is_deleted"`
+		WithdrawDate string `form:"withdraw_date" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.UpdateUpAccount(c, v.MID, v.IsDeleted, v.WithdrawDate)
+	if err != nil {
+		log.Error("growup svr.UpdateUpAccount error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func recoverCredit(c *bm.Context) {
+	v := new(struct {
+		Type int   `form:"type"`
+		ID   int64 `form:"id" validate:"required"`
+		MID  int64 `form:"mid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.RecoverCreditScore(c, v.Type, v.ID, v.MID)
+	if err != nil {
+		log.Error("growup svr.RecoverCreditScore error(%v)", err)
+	}
+	c.JSON(nil, err)
+}
+
+func creditRecords(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	crs, err := svr.CreditRecords(c, v.MID)
+	if err != nil {
+		log.Error("growup svr.CreditRecords error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(crs, nil)
+}
+
+func exportUps(c *bm.Context) {
+	v := new(struct {
+		BusinessType int     `form:"business_type"`
+		AccountType  int     `form:"account_type"`
+		States       []int64 `form:"account_states,split"`
+		MID          int64   `form:"mid"`
+		Category     int     `form:"category"`
+		SignType     int     `form:"sign_type"`
+		Nickname     string  `form:"nickname"`
+		Lower        int     `form:"lower"`
+		Upper        int     `form:"upper"`
+		From         int     `form:"from" default:"0" validate:"min=0"`
+		Limit        int     `form:"limit" default:"20" validate:"min=1"`
+		Sort         string  `form:"sort"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	content, err := svr.ExportUps(c, v.BusinessType, v.AccountType, v.States, v.MID, v.Category, v.SignType, v.Nickname, v.Lower, v.Upper, v.From, v.Limit, v.Sort)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.ExportUps error(%v)", err)
+		return
+	}
+
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "ups"),
+	})
+}
+
+func upState(c *bm.Context) {
+	v := new(struct {
+		Type int   `form:"type"`
+		MID  int64 `form:"mid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := svr.UpState(c, v.MID, v.Type)
+	if err != nil {
+		log.Error("growup svr.UpState error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}

app/admin/main/growup/http/white.go

@@ -0,0 +1,21 @@
+package http
+
+import (
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func addWhite(c *bm.Context) {
+	v := new(struct {
+		MID  int64 `form:"mid" validate:"required"`
+		Type int   `form:"type" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := svr.InsertWhite(c, v.MID, v.Type)
+	if err != nil {
+		log.Error("growup svr.AddWhite error(%v)", err)
+	}
+	c.JSON(nil, err)
+}

app/admin/main/growup/http/withdraw.go

@@ -0,0 +1,144 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func upWithdraw(c *bm.Context) {
+	v := new(struct {
+		MIDs      []int64 `form:"mids,split"`
+		IsDeleted int     `form:"is_deleted"`
+		Page      int     `form:"page" validate:"min=1" default:"1"`
+		Size      int     `form:"size" validtae:"min=1" default:"20"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	from := (v.Page - 1) * v.Size
+	data, total, err := incomeSvr.UpWithdraw(c, v.MIDs, v.IsDeleted, from, v.Size)
+	if err != nil {
+		log.Error("growup incomeSvr.UpWithdraw error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result": map[string]interface{}{
+			"data":        data,
+			"page":        v.Page,
+			"total_count": total,
+		},
+		"status": "success",
+	}))
+}
+
+func upWithdrawExport(c *bm.Context) {
+	v := new(struct {
+		MIDs      []int64 `form:"mids,split"`
+		IsDeleted int     `form:"is_deleted"`
+		Page      int     `form:"page" validate:"min=1" default:"1"`
+		Size      int     `form:"size" validtae:"min=1" default:"20"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	from := (v.Page - 1) * v.Size
+	content, err := incomeSvr.UpWithdrawExport(c, v.MIDs, v.IsDeleted, from, v.Size)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup incomeSvr.UpWithdrawExport error(%v)", err)
+		return
+	}
+
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "up_withdraw"),
+	})
+}
+
+func upWithdrawStatis(c *bm.Context) {
+	v := new(struct {
+		FromTime  int64 `form:"from_time"`
+		ToTime    int64 `form:"to_time"`
+		IsDeleted int   `form:"is_deleted"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, err := incomeSvr.UpWithdrawStatis(c, v.FromTime, v.ToTime, v.IsDeleted)
+	if err != nil {
+		log.Error("growup incomeSvr.UpWithdrawStatis error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+	}))
+}
+
+func upWithdrawDetail(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid" validate:"required"`
+	})
+
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	data, err := incomeSvr.UpWithdrawDetail(c, v.MID)
+	if err != nil {
+		log.Error("growup incomeSvr.UpWithdrawStatis error(%v)", err)
+		c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+			"code":   err,
+			"status": "fail",
+		}))
+		return
+	}
+	c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{
+		"code":    0,
+		"message": "0",
+		"result":  data,
+		"status":  "success",
+	}))
+}
+
+func upWithdrawDetailExport(c *bm.Context) {
+	v := new(struct {
+		MID int64 `form:"mid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	content, err := incomeSvr.UpWithdrawDetailExport(c, v.MID)
+	if err != nil {
+		c.JSON(nil, err)
+		log.Error("growup svr.UpWithdrawDetailExport error(%v)", err)
+		return
+	}
+
+	c.Render(http.StatusOK, CSV{
+		Content: content,
+		Title:   fmt.Sprintf("%s-%s", time.Now().Format("2006-01-02"), "up_withdraw_detail"),
+	})
+}