You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
403 lines
11 KiB
403 lines
11 KiB
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)) |
|
}
|
|
|