Create & Init Project...

app/admin/main/push/http/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "apps.go",
+        "auths.go",
+        "business.go",
+        "dataplatform.go",
+        "http.go",
+        "tasks.go",
+        "upload.go",
+    ],
+    importpath = "go-common/app/admin/main/push/http",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/push/conf:go_default_library",
+        "//app/admin/main/push/model:go_default_library",
+        "//app/admin/main/push/service:go_default_library",
+        "//app/service/main/push/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/permit:go_default_library",
+        "//library/time: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/push/http/apps.go

@@ -0,0 +1,88 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/push/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func appList(c *bm.Context) {
+	var (
+		err   error
+		items []*model.App
+	)
+	if err = pushSrv.DB.Find(&items).Error; err != nil {
+		log.Error("appList error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(items, nil)
+}
+
+func addApp(c *bm.Context) {
+	app := new(model.App)
+	if err := c.Bind(app); err != nil {
+		return
+	}
+	if !pushSrv.DB.Where("name=?", app.Name).First(&model.App{}).RecordNotFound() {
+		log.Warn("addApp(%+v) repeat", app)
+		c.JSON(nil, ecode.PushRecordRepeatErr)
+		return
+	}
+	if err := pushSrv.DB.Create(app).Error; err != nil {
+		log.Error("addApp(%s) error(%v)", app.Name, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func appInfo(c *bm.Context) {
+	var (
+		req  = c.Request.Form
+		info = &model.App{}
+	)
+	id, _ := strconv.ParseInt(req.Get("id"), 10, 64)
+	if id == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.First(info, id).Error; err != nil {
+		log.Error("appInfo(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(info, nil)
+}
+
+func saveApp(c *bm.Context) {
+	app := new(model.App)
+	if err := c.Bind(app); err != nil {
+		return
+	}
+	if err := pushSrv.DB.Model(&model.App{ID: app.ID}).Updates(map[string]interface{}{"name": app.Name, "push_limit_user": app.PushLimitUser}).Error; err != nil {
+		log.Error("saveApp(%d,%s) error(%v)", app.ID, app.Name, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func delApp(c *bm.Context) {
+	req := c.Request.Form
+	id, _ := strconv.ParseInt(req.Get("id"), 10, 64)
+	if id == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.Model(&model.App{ID: id}).Update("dtime", time.Now().Unix()).Error; err != nil {
+		log.Error("delApps(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}

app/admin/main/push/http/auths.go

@@ -0,0 +1,78 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/push/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func authList(c *bm.Context) {
+	var (
+		req   = c.Request.Form
+		auths []*model.Auth
+	)
+	appID, _ := strconv.ParseInt(req.Get("app_id"), 10, 64)
+	if err := pushSrv.DB.Model(&model.App{ID: appID}).Related(&auths).Error; err != nil {
+		log.Error("authList error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(auths, nil)
+}
+
+func addAuth(c *bm.Context) {
+	auth := new(model.Auth)
+	if err := c.Bind(auth); err != nil {
+		return
+	}
+	if err := pushSrv.DB.Create(auth).Error; err != nil {
+		log.Error("addAuth(%+v) error(%v)", auth, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func authInfo(c *bm.Context) {
+	auth := new(model.Auth)
+	if err := c.Bind(auth); err != nil {
+		return
+	}
+	if err := pushSrv.DB.First(auth, auth.ID).Error; err != nil {
+		log.Error("authInfo(%d) error(%v)", auth.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(auth, nil)
+}
+
+func saveAuth(c *bm.Context) {
+	auth := new(model.Auth)
+	if err := c.Bind(auth); err != nil {
+		return
+	}
+	if err := pushSrv.DB.Model(&model.Auth{ID: auth.ID}).Update(auth).Error; err != nil {
+		log.Error("saveAuth(%+v) error(%v)", auth, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func delAuth(c *bm.Context) {
+	id, _ := strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if id == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.Model(&model.Auth{ID: id}).Update("dtime", time.Now().Unix()).Error; err != nil {
+		log.Error("delAuth(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}

app/admin/main/push/http/business.go

@@ -0,0 +1,122 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/push/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func businessList(c *bm.Context) {
+	var (
+		items   []*model.Business
+		err     error
+		count   int
+		apps    []*model.App
+		appsMap = make(map[int64]*model.App)
+	)
+	pager := new(model.Pager)
+	if err = c.Bind(pager); err != nil {
+		return
+	}
+	if err = pushSrv.DB.Offset((pager.Pn - 1) * pager.Ps).Limit(pager.Ps).Find(&items).Error; err != nil {
+		log.Error("businessList(%d,%d) error(%v)", pager.Pn, pager.Ps, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = pushSrv.DB.Find(&apps).Error; err != nil {
+		log.Error("businessList(%d,%d) error(%v)", pager.Pn, pager.Ps, err)
+		c.JSON(nil, err)
+		return
+	}
+	for _, app := range apps {
+		appsMap[app.ID] = app
+	}
+	for _, item := range items {
+		if appsMap[item.AppID] != nil {
+			item.AppName = appsMap[item.AppID].Name
+		}
+	}
+	if err = pushSrv.DB.Model(&model.Business{}).Count(&count).Error; err != nil {
+		log.Error("businessList count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	data := map[string]interface{}{
+		"data": items,
+		"pager": &model.Pager{
+			Pn:    pager.Pn,
+			Ps:    pager.Ps,
+			Total: count,
+		},
+	}
+	c.JSONMap(data, nil)
+}
+
+func addBusiness(c *bm.Context) {
+	biz := new(model.Business)
+	if err := c.Bind(biz); err != nil {
+		return
+	}
+	biz.Token = model.RandomString(32)
+	if !pushSrv.DB.Where("app_id=? and name=?", biz.AppID, biz.Name).First(&model.Business{}).RecordNotFound() {
+		log.Warn("addBusiness(%+v) repeat", biz)
+		c.JSON(nil, ecode.PushRecordRepeatErr)
+		return
+	}
+	if err := pushSrv.DB.Create(biz).Error; err != nil {
+		log.Error("addBusiness(%+v) error(%v)", biz, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func businessInfo(c *bm.Context) {
+	var (
+		req  = c.Request.Form
+		info = &model.Business{}
+	)
+	id, _ := strconv.ParseInt(req.Get("id"), 10, 64)
+	if id == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.First(info, id).Error; err != nil {
+		log.Error("businessInfo(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(info, nil)
+}
+
+func saveBusiness(c *bm.Context) {
+	biz := new(model.Business)
+	if err := c.Bind(biz); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.Omit("token", "mtime", "ctime", "dtime").Save(biz).Error; err != nil {
+		log.Error("saveBusiness(%+v) error(%v)", biz, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func delBusiness(c *bm.Context) {
+	id, _ := strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if id == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.Model(&model.Business{ID: id}).Update("dtime", time.Now().Unix()).Error; err != nil {
+		log.Error("delBusiness(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}

app/admin/main/push/http/dataplatform.go

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/push/model"
+	pushmdl "go-common/app/service/main/push/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func addDPTask(ctx *bm.Context) {
+	task := &model.DPTask{}
+	if err := ctx.Bind(task); err != nil {
+		return
+	}
+	if err := parseDpTask(task); err != nil {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ctx.JSON(nil, pushSrv.AddDPTask(context.Background(), task))
+}
+
+func parseDpTask(task *model.DPTask) (err error) {
+	if task.ActivePeriodStr != "" {
+		if err = json.Unmarshal([]byte(task.ActivePeriodStr), &task.ActivePeriods); err != nil {
+			log.Error("parse ActivePeriod(%s) error(%v)", task.ActivePeriodStr, err)
+			return
+		}
+	}
+	if task.VipExpireStr != "" {
+		if err = json.Unmarshal([]byte(task.VipExpireStr), &task.VipExpires); err != nil {
+			log.Error("parse VipExpire(%s) error(%v)", task.VipExpireStr, err)
+			return
+		}
+	}
+	if task.AttentionStr != "" {
+		if err = json.Unmarshal([]byte(task.AttentionStr), &task.Attentions); err != nil {
+			log.Error("parse Attention(%s) error(%v)", task.AttentionStr, err)
+			return
+		}
+	}
+	task.PushTime = time.Unix(task.PushTimeUnix, 0)
+	task.ExpireTime = time.Unix(task.ExpireTimeUnix, 0)
+	task.Job = strconv.FormatInt(pushmdl.JobName(time.Now().UnixNano(), task.Summary, task.LinkValue, task.Group), 10)
+	task.Status = int(pushmdl.TaskStatusPending)
+	extra, _ := json.Marshal(pushmdl.TaskExtra{Group: task.Group})
+	task.Extra = string(extra)
+	return
+}
+
+func dpTaskInfo(ctx *bm.Context) {
+	task := new(model.Task)
+	if err := ctx.Bind(task); err != nil {
+		return
+	}
+	id, _ := strconv.ParseInt(task.ID, 10, 64)
+	if id < 1 {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ctx.JSON(pushSrv.DpTaskInfo(ctx, id, task.Job))
+}
+
+func checkDpData(ctx *bm.Context) {
+	ctx.JSON(nil, pushSrv.CheckDpData(ctx))
+}

app/admin/main/push/http/http.go

@@ -0,0 +1,89 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/admin/main/push/conf"
+	"go-common/app/admin/main/push/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+)
+
+var (
+	pushSrv *service.Service
+	authSrv *permit.Permit
+)
+
+// Init init http sever instance.
+func Init(c *conf.Config, s *service.Service) {
+	pushSrv = s
+	authSrv = permit.New(c.Auth)
+	engine := bm.DefaultServer(c.HTTPServer)
+	route(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func route(e *bm.Engine) {
+	e.Ping(ping)
+	g := e.Group("/x/admin/push")
+	{
+		gapp := g.Group("/apps")
+		{
+			gapp.GET("/list", authSrv.Permit("PUSH_APPS_LIST"), appList)
+			gapp.GET("/info", authSrv.Permit("PUSH_APPS"), appInfo)
+			gapp.POST("/add", authSrv.Permit("PUSH_APPS"), addApp)
+			gapp.POST("/save", authSrv.Permit("PUSH_APPS"), saveApp)
+			gapp.POST("/delete", authSrv.Permit("PUSH_APPS"), delApp)
+		}
+		gauth := g.Group("/auths", authSrv.Permit("PUSH_AUTH"))
+		{
+			gauth.GET("/list", authList)
+			gauth.GET("/info", authInfo)
+			gauth.POST("/add", addAuth)
+			gauth.POST("/save", saveAuth)
+			gauth.POST("/delete", delAuth)
+		}
+		gbiz := g.Group("/business")
+		{
+			gbiz.GET("/list", authSrv.Permit("PUSH_BUSINESS_LIST"), businessList)
+			gbiz.GET("/info", authSrv.Permit("PUSH_BUSINESS"), businessInfo)
+			gbiz.POST("/add", authSrv.Permit("PUSH_BUSINESS"), addBusiness)
+			gbiz.POST("/save", authSrv.Permit("PUSH_BUSINESS"), saveBusiness)
+			gbiz.POST("/delete", authSrv.Permit("PUSH_BUSINESS"), delBusiness)
+		}
+		gtask := g.Group("/tasks")
+		{
+			gtask.GET("/list", authSrv.Permit("PUSH_TASK"), taskList)
+			gtask.GET("/info", authSrv.Permit("PUSH_TASK"), taskInfo)
+			gtask.POST("/add", authSrv.Permit("PUSH_TASK"), addTask)
+			gtask.POST("/save", authSrv.Permit("PUSH_TASK"), saveTask)
+			gtask.POST("/delete", authSrv.Permit("PUSH_TASK"), delTask)
+			gtask.POST("/upload", authSrv.Permit("PUSH_TASK"), upload)
+			gtask.POST("/upimg", authSrv.Permit("PUSH_TASK"), upimg)
+			gtask.POST("/stop", authSrv.Permit("PUSH_TASK"), stopTask)
+			gtask.POST("/confirm", authSrv.Permit("PUSH_CONFIRM"), confirmTask)
+			gdp := gtask.Group("dataplatform", authSrv.Permit("PUSH_TASK"))
+			{
+				gdp.POST("/add", addDPTask)
+				gdp.GET("/info", dpTaskInfo)
+				gdp.GET("/check", checkDpData)
+			}
+		}
+		gtest := g.Group("/test", authSrv.Permit("PUSH_TEST"))
+		{
+			gtest.POST("/mid", testPushMid)     // 按 mids 测试推送
+			gtest.POST("/token", testPushToken) // 按单个 token 测试推送
+		}
+	}
+}
+
+func ping(ctx *bm.Context) {
+	if err := pushSrv.Ping(ctx); err != nil {
+		log.Error("push-admin ping error(%v)", err)
+		ctx.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/admin/main/push/http/tasks.go

@@ -0,0 +1,403 @@
+package http
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/push/model"
+	pushmdl "go-common/app/service/main/push/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	xtime "go-common/library/time"
+)
+
+func taskList(c *bm.Context) {
+	var (
+		items []*model.Task
+		types []int
+		err   error
+		pager = new(model.Pager)
+	)
+	params := new(struct {
+		Type  string `form:"type"`
+		Stime string `form:"stime"`
+		Etime string `form:"etime"`
+	})
+	if err = c.Bind(params); err != nil {
+		return
+	}
+	if err = c.Bind(pager); err != nil {
+		return
+	}
+	for _, v := range strings.Split(params.Type, ",") {
+		i, e := strconv.Atoi(v)
+		if e != nil {
+			continue
+		}
+		types = append(types, i)
+	}
+	if params.Stime == "" {
+		params.Stime = time.Now().Add(-1 * time.Hour).Format("2006-01-02 15:04:05")
+	}
+	if params.Etime == "" {
+		params.Etime = time.Now().Format("2006-01-02 15:04:05")
+	}
+	if err = pushSrv.DB.Model(&model.Task{}).Where("push_time between ? and ?", params.Stime, params.Etime).Where("type in(?)", types).Order("push_time desc").Find(&items).Error; err != nil {
+		log.Error("taskList(%d,%s,%s) error(%v)", params.Type, params.Stime, params.Etime, err)
+		c.JSON(nil, err)
+		return
+	}
+	res := fmtTasks(items)
+	total := len(res)
+	data := map[string]interface{}{
+		"pager": &model.Pager{
+			Pn:    pager.Pn,
+			Ps:    pager.Ps,
+			Total: total,
+		},
+		"data": []*model.Task{},
+	}
+	start := pager.Ps * (pager.Pn - 1)
+	if start >= total {
+		c.JSONMap(data, nil)
+		return
+	}
+	end := start + pager.Ps
+	if len(res[start:]) < pager.Ps {
+		end = start + len(res[start:])
+	}
+	data["data"] = res[start:end]
+	c.JSONMap(data, nil)
+}
+
+func fmtTasks(items []*model.Task) (res []*model.Task) {
+	var jobs []string
+	tasks := make(map[string]*pushmdl.Task)
+	for _, t := range items {
+		p := &pushmdl.Progress{}
+		if t.Progress != "" {
+			if err := json.Unmarshal([]byte(t.Progress), &p); err != nil {
+				log.Error("unmarshal task(%d) progress(%s) error(%v)", t.ID, t.Progress, err)
+				continue
+			}
+		}
+		extra := new(pushmdl.TaskExtra)
+		if t.Extra != "" {
+			if err := json.Unmarshal([]byte(t.Extra), &extra); err != nil {
+				log.Error("unmarshal task(%d) extra(%s) error(%v)", t.ID, t.Extra, err)
+				continue
+			}
+		}
+		if v, ok := tasks[t.Job]; !ok {
+			job, _ := strconv.ParseInt(t.Job, 10, 64)
+			tasks[t.Job] = &pushmdl.Task{
+				ID:         t.ID,
+				Job:        job,
+				Type:       t.Type,
+				APPID:      t.AppID,
+				BusinessID: t.BusinessID,
+				Title:      t.Title,
+				Summary:    t.Summary,
+				LinkType:   int8(t.LinkType),
+				LinkValue:  t.LinkValue,
+				Progress:   p,
+				PushTime:   xtime.Time(t.PushTime.Unix()),
+				ExpireTime: xtime.Time(t.ExpireTime.Unix()),
+				Status:     int8(t.Status),
+				Extra:      extra,
+			}
+			jobs = append(jobs, t.Job)
+		} else {
+			v.Status = calStatus(v.Status, int8(t.Status))
+			vp := v.Progress
+			vp.MidTotal += p.MidTotal
+			vp.MidValid += p.MidValid
+			vp.TokenTotal += p.TokenTotal
+			vp.TokenValid += p.TokenValid
+			vp.TokenFailed += p.TokenFailed
+		}
+	}
+	for _, j := range jobs {
+		v := tasks[j]
+		p, _ := json.Marshal(v.Progress)
+		e, _ := json.Marshal(v.Extra)
+		t := &model.Task{
+			ID:             v.ID,
+			Job:            strconv.FormatInt(v.Job, 10),
+			Type:           v.Type,
+			AppID:          v.APPID,
+			BusinessID:     v.BusinessID,
+			Title:          v.Title,
+			Summary:        v.Summary,
+			LinkType:       int(v.LinkType),
+			LinkValue:      v.LinkValue,
+			Progress:       string(p),
+			PushTimeUnix:   int64(v.PushTime),
+			ExpireTimeUnix: int64(v.ExpireTime),
+			Status:         int(v.Status),
+			Extra:          string(e),
+		}
+		res = append(res, t)
+	}
+	return
+}
+
+func calStatus(currStatus, newStatus int8) int8 {
+	// 聚合任务状态
+	// 如果有进行中的任务，显示进行中
+	// 如果没有，显示其中最小的状态（负数是异常状态）
+	if currStatus == pushmdl.TaskStatusDoing || newStatus == pushmdl.TaskStatusDoing {
+		return pushmdl.TaskStatusDoing
+	}
+	if newStatus == pushmdl.TaskStatusPrepared {
+		return pushmdl.TaskStatusPrepared
+	}
+	if newStatus < currStatus {
+		return newStatus
+	}
+	return currStatus
+}
+
+func addTask(c *bm.Context) {
+	var (
+		task     = &model.Task{}
+		filename = c.Request.Form.Get("filename")
+	)
+	if err := c.Bind(task); err != nil {
+		return
+	}
+	task.PushTime = time.Unix(task.PushTimeUnix, 0)
+	task.ExpireTime = time.Unix(task.ExpireTimeUnix, 0)
+	job := pushmdl.JobName(time.Now().UnixNano(), task.Summary, task.LinkValue, task.Group)
+	task.Job = strconv.FormatInt(job, 10)
+	extra, _ := json.Marshal(pushmdl.TaskExtra{
+		Group:    task.Group,
+		Filename: filename,
+	})
+	task.Extra = string(extra)
+	task.Status = int(pushmdl.TaskStatusPending)
+	c.JSON(nil, pushSrv.AddTask(context.Background(), task))
+}
+
+func taskInfo(c *bm.Context) {
+	task := &model.Task{}
+	id, _ := strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if id == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.First(task, id).Error; err != nil {
+		log.Error("taskInfo(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	task.PushTimeUnix = task.PushTime.Unix()
+	task.ExpireTimeUnix = task.ExpireTime.Unix()
+	c.JSON(task, nil)
+}
+
+func saveTask(c *bm.Context) {
+	var (
+		task     = new(model.Task)
+		filename = c.Request.Form.Get("filename")
+	)
+	if err := c.Bind(task); err != nil {
+		return
+	}
+	if task.Job == "" {
+		log.Warn("job is empty")
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	extra, _ := json.Marshal(pushmdl.TaskExtra{
+		Group:    task.Group,
+		Filename: filename,
+	})
+	data := map[string]interface{}{
+		"app_id":      task.AppID,
+		"type":        task.Type,
+		"business_id": task.BusinessID,
+		"title":       task.Title,
+		"summary":     task.Summary,
+		"link_type":   task.LinkType,
+		"link_value":  task.LinkValue,
+		"build":       task.Build,
+		"sound":       task.Sound,
+		"vibration":   task.LinkValue,
+		"push_time":   time.Unix(task.PushTimeUnix, 0),
+		"expire_time": time.Unix(task.ExpireTimeUnix, 0),
+		"group":       task.Group,
+		"image_url":   task.ImageURL,
+		"extra":       string(extra),
+	}
+	if err := pushSrv.DB.Model(&model.Task{}).Where("job=?", task.Job).Updates(data).Error; err != nil {
+		log.Error("saveTask(%+v) error(%v)", data, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func delTask(c *bm.Context) {
+	job := c.Request.Form.Get("job")
+	if job == "" {
+		log.Error("job is empty")
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.Model(&model.Task{}).Where("job=?", job).Update("dtime", time.Now().Unix()).Error; err != nil {
+		log.Error("delTask(%s) error(%v)", job, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func stopTask(c *bm.Context) {
+	job := c.Request.Form.Get("job")
+	if job == "" {
+		log.Error("job is empty")
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := pushSrv.DB.Model(&model.Task{}).Where("job=?", job).Update("status", pushmdl.TaskStatusStop).Error; err != nil {
+		log.Error("stopTask(%s) error(%v)", job, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func confirmTask(c *bm.Context) {
+	job := c.Request.Form.Get("job")
+	if job == "" {
+		log.Error("job is empty")
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	task := &model.Task{}
+	if err := pushSrv.DB.Model(&model.Task{}).Where("job=?", job).First(task).Error; err != nil {
+		log.Error("confirmTask(%s) query task error(%v)", job, err)
+		c.JSON(nil, err)
+		return
+	}
+	status := pushmdl.TaskStatusPretreatmentPrepared
+	if task.Type == pushmdl.TaskTypeDataPlatformMid || task.Type == pushmdl.TaskTypeDataPlatformToken {
+		status = pushmdl.TaskStatusWaitDataPlatform
+		if err := pushSrv.UpdateDpCondtionStatus(c, job, pushmdl.DpCondStatusPrepared); err != nil {
+			log.Error("confirmTask(%s) update data platform conditions error(%v)", job, err)
+			return
+		}
+	}
+	if err := pushSrv.DB.Model(&model.Task{}).Where("job=?", job).Update("status", status).Error; err != nil {
+		log.Error("confirmTask(%s) error(%v)", job, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func testPushMid(c *bm.Context) {
+	task := &model.Task{}
+	if err := c.Bind(task); err != nil {
+		return
+	}
+	builds := make(map[int]*pushmdl.Build)
+	if task.Build != "" {
+		if err := json.Unmarshal([]byte(task.Build), &builds); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			log.Warn("buildformat task(%+v) error(%v)", task, err)
+			return
+		}
+	}
+	var (
+		plats []string
+		mid   = c.Request.Form.Get("mid")
+	)
+	for plat := range builds {
+		plats = append(plats, strconv.Itoa(plat))
+	}
+	task.Platform = strings.Join(plats, ",")
+	task.PushTime = time.Unix(task.PushTimeUnix, 0)
+	task.ExpireTime = time.Unix(task.ExpireTimeUnix, 0)
+	job := pushmdl.JobName(time.Now().UnixNano(), task.Summary, task.LinkValue, task.Group)
+	task.Job = strconv.FormatInt(job, 10)
+	extra, _ := json.Marshal(pushmdl.TaskExtra{Group: task.Group})
+	task.Extra = string(extra)
+	c.JSON(nil, pushSrv.TestPushMid(c, mid, task))
+}
+
+func testPushToken(c *bm.Context) {
+	params := c.Request.Form
+	appID, _ := strconv.ParseInt(params.Get("app_id"), 10, 64)
+	if appID < 1 {
+		c.JSON(nil, ecode.RequestErr)
+		log.Error("app_id is wrong: %s", params.Get("app_id"))
+		return
+	}
+	platform, _ := strconv.Atoi(params.Get("platform"))
+	if platform < 1 {
+		c.JSON(nil, ecode.RequestErr)
+		log.Error("platform is wrong: %s", params.Get("platform"))
+		return
+	}
+	alertTitle := params.Get("alert_title")
+	if alertTitle == "" {
+		alertTitle = pushmdl.DefaultMessageTitle
+	}
+	alertBody := params.Get("alert_body")
+	if alertBody == "" {
+		c.JSON(nil, ecode.RequestErr)
+		log.Error("alert_body is empty")
+		return
+	}
+	token := params.Get("token")
+	if token == "" {
+		c.JSON(nil, ecode.RequestErr)
+		log.Error("token is empty")
+		return
+	}
+	linkType, _ := strconv.Atoi(params.Get("link_type"))
+	if linkType < 1 {
+		c.JSON(nil, ecode.RequestErr)
+		log.Error("link_type is wrong: %s", params.Get("link_type"))
+		return
+	}
+	linkValue := params.Get("link_value")
+	expireTime, _ := strconv.ParseInt(params.Get("expire_time"), 10, 64)
+	if expireTime == 0 {
+		expireTime = time.Now().Add(7 * 24 * time.Hour).Unix()
+	}
+	sound, vibration := pushmdl.SwitchOn, pushmdl.SwitchOn
+	if params.Get("sound") != "" {
+		if sd, _ := strconv.Atoi(params.Get("sound")); sd == pushmdl.SwitchOff {
+			sound = pushmdl.SwitchOff
+		}
+	}
+	if params.Get("vibration") != "" {
+		if vr, _ := strconv.Atoi(params.Get("vibration")); vr == pushmdl.SwitchOff {
+			vibration = pushmdl.SwitchOff
+		}
+	}
+	passThrough, _ := strconv.Atoi(params.Get("pass_through"))
+	if passThrough != pushmdl.SwitchOn {
+		passThrough = pushmdl.SwitchOff
+	}
+	info := &pushmdl.PushInfo{
+		TaskID:      pushmdl.TempTaskID(),
+		APPID:       appID,
+		Title:       alertTitle,
+		Summary:     alertBody,
+		LinkType:    int8(linkType),
+		LinkValue:   linkValue,
+		ExpireTime:  xtime.Time(expireTime),
+		PassThrough: passThrough,
+		Sound:       sound,
+		Vibration:   vibration,
+	}
+	c.JSON(nil, pushSrv.TestPushToken(c, info, platform, token))
+}

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

@@ -0,0 +1,89 @@
+package http
+
+import (
+	"crypto/md5"
+	"fmt"
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/push/conf"
+	"go-common/app/admin/main/push/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func upload(c *bm.Context) {
+	var (
+		err error
+		req = c.Request
+	)
+	req.ParseMultipartForm(1024 * 1024 * 1024) // 1G
+	fileName := req.FormValue("filename")
+	if fileName == "" {
+		log.Error("filename is empty")
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	file, header, err := req.FormFile("file")
+	if err != nil {
+		log.Error("req.FormFile() error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	defer file.Close()
+	bs, err := ioutil.ReadAll(file)
+	if err != nil {
+		log.Error("ioutil.ReadAll() error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	typ, _ := strconv.Atoi(req.FormValue("type"))
+	if typ == model.UploadTypeMid {
+		if err = pushSrv.CheckUploadMid(c, bs); err != nil {
+			c.JSON(nil, err)
+			return
+		}
+	} else if typ == model.UploadTypeToken {
+		if err = pushSrv.CheckUploadToken(c, bs); err != nil {
+			c.JSON(nil, err)
+			return
+		}
+	} else {
+		log.Error("type(%d) invalid", typ)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	dir := fmt.Sprintf("%s/%s", strings.TrimSuffix(conf.Conf.Cfg.MountDir, "/"), time.Now().Format("20060102"))
+	path := fmt.Sprintf("%s/%x", dir, md5.Sum([]byte(fileName)))
+	if err = pushSrv.Upload(c, dir, path, bs); err != nil {
+		log.Error("upload file file(%s) error(%v)", path, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(struct {
+		Name string `json:"name"`
+		Path string `json:"path"`
+	}{
+		Name: header.Filename,
+		Path: path,
+	}, nil)
+}
+
+func upimg(ctx *bm.Context) {
+	f, h, err := ctx.Request.FormFile("file")
+	if err != nil {
+		log.Error("upimg error(%v)", err)
+		ctx.JSON(nil, err)
+		return
+	}
+	defer f.Close()
+	url, err := pushSrv.Upimg(ctx, f, h)
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	ctx.JSON(map[string]string{"url": url}, nil)
+}