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.
531 lines
12 KiB
531 lines
12 KiB
package http |
|
|
|
import ( |
|
"bytes" |
|
"context" |
|
"encoding/csv" |
|
"fmt" |
|
"strconv" |
|
"strings" |
|
"time" |
|
|
|
"go-common/app/service/main/up/model" |
|
"go-common/app/service/main/up/service" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
bm "go-common/library/net/http/blademaster" |
|
"go-common/library/net/metadata" |
|
|
|
"github.com/siddontang/go-mysql/mysql" |
|
) |
|
|
|
func register(ctx *bm.Context) { |
|
param := ctx.Request.Form |
|
midStr := param.Get("mid") |
|
fromStr := param.Get("from") |
|
isAuthorStr := param.Get("is_author") |
|
// check params |
|
mid, err := strconv.ParseInt(midStr, 10, 64) |
|
if err != nil { |
|
log.Error("strconv.ParseInt(%s) error(%v)", midStr, err) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if mid <= 0 { |
|
log.Error("register error mid (%d)", mid) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
from, err := strconv.Atoi(fromStr) |
|
if err != nil { |
|
log.Error("strconv.ParseInt(%s) error(%v)", fromStr, err) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
isAuthor, err := strconv.Atoi(isAuthorStr) |
|
if err != nil { |
|
log.Error("strconv.ParseInt(%s) error(%v)", isAuthorStr, err) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
result := 0 |
|
row, err := Svc.Edit(ctx, mid, isAuthor, uint8(from)) |
|
if err != nil { |
|
ctx.JSON(nil, err) |
|
return |
|
} |
|
if row > 0 { |
|
result = 1 |
|
} |
|
ctx.JSON(map[string]interface{}{ |
|
"result": result, |
|
}, nil) |
|
} |
|
|
|
func info(ctx *bm.Context) { |
|
param := ctx.Request.Form |
|
midStr := param.Get("mid") |
|
fromStr := param.Get("from") |
|
// check params |
|
mid, err := strconv.ParseInt(midStr, 10, 64) |
|
if err != nil { |
|
log.Error("strconv.ParseInt(%s) error(%v)", midStr, err) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if mid <= 0 { |
|
log.Error("info error mid (%d)", mid) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
from, err := strconv.Atoi(fromStr) |
|
if err != nil { |
|
log.Error("strconv.ParseInt(%s) error(%v)", fromStr, err) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
isAuthor, err := Svc.Info(ctx, mid, uint8(from)) |
|
if err != nil { |
|
ctx.JSON(nil, err) |
|
return |
|
} |
|
ctx.JSON(map[string]interface{}{ |
|
"is_author": isAuthor, |
|
}, nil) |
|
} |
|
|
|
func all(ctx *bm.Context) { |
|
param := ctx.Request.Form |
|
midStr := param.Get("mid") |
|
ip := metadata.String(ctx, metadata.RemoteIP) |
|
// check params |
|
mid, err := strconv.ParseInt(midStr, 10, 64) |
|
if err != nil { |
|
log.Error("strconv.ParseInt(%s) error(%v)", midStr, err) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if mid <= 0 { |
|
log.Error("up all error mid (%d)", mid) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
identifyAll, err := Svc.IdentifyAll(ctx, mid, ip) |
|
if err != nil { |
|
ctx.JSON(nil, err) |
|
return |
|
} |
|
ctx.JSON(map[string]interface{}{ |
|
"identify": identifyAll, |
|
}, nil) |
|
} |
|
|
|
// flows get specialUps list |
|
func specialUps(c *bm.Context) { |
|
var res interface{} |
|
params := c.Request.Form |
|
groupStr := params.Get("group_id") |
|
var err error |
|
// check params |
|
//default all groups |
|
groupID := int64(0) |
|
if groupStr != "" { |
|
groupID, err = strconv.ParseInt(groupStr, 10, 64) |
|
if err != nil { |
|
log.Error("strconv.ParseInt(groupStr(%s)) error(%v)", groupStr, err) |
|
err = ecode.RequestErr |
|
c.JSON(res, err) |
|
return |
|
} |
|
} |
|
res = Svc.UpsByGroup(c, groupID) |
|
c.JSON(res, err) |
|
} |
|
|
|
func specialDel(c *bm.Context) { |
|
var res interface{} |
|
var err error |
|
var r = new(struct { |
|
Ids string `form:"ids" validate:"required"` |
|
}) |
|
if err = c.Bind(r); err != nil { |
|
log.Error("params error, err=%v", err) |
|
err = ecode.RequestErr |
|
c.JSON(res, err) |
|
return |
|
} |
|
var idstr = strings.Split(r.Ids, ",") |
|
for _, s := range idstr { |
|
var affectedRow int64 |
|
var id, e = strconv.ParseInt(s, 10, 64) |
|
err = e |
|
if err != nil { |
|
log.Error("id is not integer, id=%s", s) |
|
continue |
|
} |
|
affectedRow, err = Svc.SpecialDel(c, id) |
|
log.Info("delete special up, id=%d, affected=%d, err=%v", id, affectedRow, err) |
|
} |
|
c.JSON(res, err) |
|
} |
|
|
|
func specialAdd(c *bm.Context) { |
|
var res interface{} |
|
var err error |
|
var errMsg string |
|
var r = new(struct { |
|
GroupIds string `form:"group_ids" validate:"required"` // 支持多个group id，用,分隔 |
|
MidStr string `form:"mids" validate:"required"` // 支持多个mid，用,分隔 |
|
Note string `form:"note" default:""` |
|
}) |
|
switch { |
|
default: |
|
if err = c.Bind(r); err != nil { |
|
log.Error("params error, err=%v", err) |
|
err = ecode.RequestErr |
|
errMsg = "params error" |
|
break |
|
} |
|
var groupIds = strings.Split(r.GroupIds, ",") |
|
// 检查是否有特殊权限 |
|
for _, groupIDStr := range groupIds { |
|
var groupID, _ = strconv.ParseInt(groupIDStr, 10, 64) |
|
var e = Svc.SpecialGroupPermit(c, groupID) |
|
if e != nil { |
|
err = e |
|
break |
|
} |
|
} |
|
var midStrArray = strings.Split(r.MidStr, ",") |
|
if len(midStrArray) == 0 { |
|
log.Error("params error, no mid got, mid=%s", r.MidStr) |
|
err = ecode.RequestErr |
|
errMsg = "params error, no mid got" |
|
break |
|
} |
|
var mids []int64 |
|
for _, v := range midStrArray { |
|
mid, e := strconv.ParseInt(v, 10, 64) |
|
if e != nil { |
|
continue |
|
} |
|
mids = append(mids, int64(mid)) |
|
} |
|
if len(mids) == 0 { |
|
log.Error("params error, wrong mid got, mid=%s", r.MidStr) |
|
err = ecode.RequestErr |
|
errMsg = "params error, wrong mid got" |
|
break |
|
} |
|
|
|
uidtemp, ok := c.Get("uid") |
|
var uid int64 |
|
if ok { |
|
uid = uidtemp.(int64) |
|
} |
|
|
|
if len(groupIds) == 0 { |
|
log.Error("params error, no group id got, groupid=%s", r.GroupIds) |
|
err = ecode.RequestErr |
|
errMsg = "params error, wrong mid got" |
|
break |
|
} |
|
var uname, _ = bmGetStringOrDefault(c, "username", "unkown") |
|
for _, groupIDStr := range groupIds { |
|
var groupID, err2 = strconv.ParseInt(groupIDStr, 10, 64) |
|
if err2 != nil { |
|
log.Warn("group id convert fail, group id=%s", groupIDStr) |
|
continue |
|
} |
|
var data = &model.UpSpecial{ |
|
GroupID: groupID, |
|
Note: r.Note, |
|
UID: uid, |
|
} |
|
go func() { |
|
const step = 100 |
|
for start := 0; start < len(mids); start += step { |
|
var end = start + step |
|
if end > len(mids) { |
|
end = len(mids) |
|
} |
|
_, err = Svc.SpecialAdd(context.Background(), uname, data, mids[start:end]...) |
|
if err != nil { |
|
log.Error("add special fail, mid=%s, err=%v", r.MidStr, err) |
|
errMsg = "server error" |
|
return |
|
} |
|
log.Info("add special, id=%v, group id=%d", mids, groupID) |
|
} |
|
|
|
}() |
|
|
|
} |
|
|
|
} |
|
|
|
if err != nil { |
|
service.BmHTTPErrorWithMsg(c, err, errMsg) |
|
} else { |
|
c.JSON(res, err) |
|
} |
|
} |
|
|
|
func specialEdit(c *bm.Context) { |
|
var res interface{} |
|
var err error |
|
var errMsg string |
|
var r = new(struct { |
|
GroupID int64 `form:"group_id" validate:"required"` |
|
Mid int64 `form:"mid"` |
|
ID int64 `form:"id" validate:"required"` |
|
Note string `form:"note" default:""` |
|
}) |
|
switch { |
|
default: |
|
if err = c.Bind(r); err != nil { |
|
log.Error("request argument bind fail, err=%v", err) |
|
errMsg = fmt.Sprintf("wrong argument, %s", err.Error()) |
|
err = ecode.RequestErr |
|
break |
|
} |
|
// 检查是否有特殊权限 |
|
err = Svc.SpecialGroupPermit(c, r.GroupID) |
|
if err != nil { |
|
break |
|
} |
|
|
|
uidtemp, ok := c.Get("uid") |
|
var uid int64 |
|
if ok { |
|
uid = uidtemp.(int64) |
|
} |
|
var data = &model.UpSpecial{ |
|
GroupID: r.GroupID, |
|
Note: r.Note, |
|
UID: uid, |
|
ID: r.ID, |
|
} |
|
|
|
_, err = Svc.SpecialEdit(c, data, r.ID) |
|
if err != nil { |
|
log.Error("fail edit ups, err=%v, info=%v", err, data) |
|
errMsg = err.Error() |
|
break |
|
} |
|
log.Info("edit ups successful, info=%v", data) |
|
} |
|
if err != nil { |
|
service.BmHTTPErrorWithMsg(c, err, errMsg) |
|
} else { |
|
c.JSON(res, err) |
|
} |
|
} |
|
|
|
// 支持更多的条件类型 |
|
func specialGet(c *bm.Context) { |
|
var data interface{} |
|
var err error |
|
var errMsg string |
|
var r = new(model.GetSpecialArg) |
|
var ups []*model.UpSpecialWithName |
|
switch { |
|
default: |
|
if err = c.Bind(r); err != nil { |
|
log.Error("request argument bind fail, err=%v", err) |
|
errMsg = fmt.Sprintf("wrong argument, %s", err.Error()) |
|
err = ecode.RequestErr |
|
break |
|
} |
|
|
|
if r.Pn == 0 { |
|
r.Pn = 1 |
|
} |
|
if r.Ps == 0 { |
|
r.Ps = 20 |
|
} |
|
if r.Ps > 100 { |
|
r.Ps = 100 |
|
} |
|
if r.Ps < 5 { |
|
r.Ps = 5 |
|
} |
|
uidtemp, ok := c.Get("uid") |
|
var uid int64 |
|
if ok { |
|
uid, _ = uidtemp.(int64) |
|
} |
|
|
|
var total int |
|
ups, total, err = Svc.SpecialGet(c, r) |
|
if err != nil { |
|
log.Error("fail to get special, err=%v, arg=%+v", err, r) |
|
errMsg = err.Error() |
|
err = ecode.ServerErr |
|
break |
|
} |
|
log.Info("get special successful, arg=%+v, result count=%d", len(ups), uid) |
|
data = model.UpsPage{ |
|
Items: ups, |
|
Pager: &model.Pager{Num: r.Pn, Size: r.Ps, Total: total}, |
|
} |
|
} |
|
if err != nil { |
|
service.BmHTTPErrorWithMsg(c, err, errMsg) |
|
} else { |
|
|
|
if r.Export == "csv" { |
|
c.Writer.Header().Set("Content-Type", "application/csv") |
|
c.Writer.Header().Set("Content-Disposition", fmt.Sprintf("attachment;filename=\"up_special_%s.csv\"", time.Now().Format(mysql.TimeFormat))) |
|
|
|
var buf = &bytes.Buffer{} |
|
var csvWriter = csv.NewWriter(buf) |
|
csvWriter.Write((&model.UpSpecialWithName{}).GetTitleFields()) |
|
for _, v := range ups { |
|
csvWriter.Write(v.ToStringFields()) |
|
} |
|
csvWriter.Flush() |
|
c.Writer.Write(buf.Bytes()) |
|
} else { |
|
c.JSON(data, err) |
|
} |
|
} |
|
} |
|
|
|
func specialGetByMid(c *bm.Context) { |
|
var data interface{} |
|
var err error |
|
var errMsg string |
|
var r = new(model.GetSpecialByMidArg) |
|
switch { |
|
default: |
|
if err = c.Bind(r); err != nil { |
|
log.Error("request argument bind fail, err=%v", err) |
|
errMsg = fmt.Sprintf("wrong argument, %s", err.Error()) |
|
err = ecode.RequestErr |
|
break |
|
} |
|
|
|
uidtemp, ok := c.Get("uid") |
|
var uid int64 |
|
if ok { |
|
uid = uidtemp.(int64) |
|
} |
|
var ups []*model.UpSpecial |
|
ups, err = Svc.SpecialGetByMid(c, r) |
|
if err != nil { |
|
log.Error("fail to get special, err=%v, arg=%+v", err, r) |
|
errMsg = err.Error() |
|
err = ecode.ServerErr |
|
break |
|
} |
|
log.Info("get special successful, arg=%+v, result count=%d", len(ups), uid) |
|
data = ups |
|
} |
|
if err != nil { |
|
service.BmHTTPErrorWithMsg(c, err, errMsg) |
|
} else { |
|
c.JSON(data, err) |
|
} |
|
} |
|
|
|
func listUp(c *bm.Context) { |
|
var ( |
|
mids []int64 |
|
newLastID int64 |
|
err error |
|
errMsg string |
|
arg = new(model.ListUpBaseArg) |
|
) |
|
switch { |
|
default: |
|
if err = c.Bind(arg); err != nil { |
|
log.Error("request argument bind fail, err=%v", err) |
|
errMsg = err.Error() |
|
err = ecode.RequestErr |
|
break |
|
} |
|
if !arg.Validate() { |
|
errMsg, err = "illegal argument", ecode.RequestErr |
|
break |
|
} |
|
if arg.Size == 0 { |
|
arg.Size = 100 |
|
} |
|
|
|
mids, newLastID, err = Svc.ListUpBase(c, arg.Size, arg.LastID, arg.Activity) |
|
|
|
if err != nil { |
|
log.Error("fail to get special, err=%v, arg=%v", err, arg) |
|
errMsg = err.Error() |
|
err = ecode.ServerErr |
|
break |
|
} |
|
} |
|
|
|
if err != nil { |
|
service.BmHTTPErrorWithMsg(c, err, errMsg) |
|
return |
|
} |
|
|
|
c.JSON(map[string]interface{}{ |
|
"result": mids, |
|
"last_id": newLastID, |
|
}, nil) |
|
} |
|
|
|
func active(ctx *bm.Context) { |
|
var ( |
|
err error |
|
errMsg string |
|
req = new(model.UpInfoActiveReq) |
|
) |
|
|
|
if err = ctx.Bind(req); err != nil { |
|
log.Error("request param error: req: %+v, err: %+v", req, err) |
|
return |
|
} |
|
if req.Mid <= 0 { |
|
log.Error("param error mid: %d", req.Mid) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
|
|
log.Info("req: %+v", req) |
|
res, err := Svc.GetUpInfoActive(ctx, req) |
|
if err != nil { |
|
log.Error("Svc.GetUpInfoActive error: %+v", err) |
|
service.BmHTTPErrorWithMsg(ctx, err, errMsg) |
|
return |
|
} |
|
|
|
ctx.JSON(res, nil) |
|
} |
|
|
|
func actives(ctx *bm.Context) { |
|
var ( |
|
err error |
|
errMsg string |
|
req = new(model.UpsInfoActiveReq) |
|
) |
|
|
|
if err = ctx.Bind(req); err != nil { |
|
log.Error("request param error: req: %+v, err: %+v", req, err) |
|
return |
|
} |
|
if len(req.Mids) <= 0 { |
|
log.Error("param error mids: %+v", req.Mids) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
|
|
log.Info("req: %+v", req) |
|
res, err := Svc.GetUpsInfoActive(ctx, req) |
|
if err != nil { |
|
log.Error("Svc.GetUpsInfoActive error: %+v", err) |
|
service.BmHTTPErrorWithMsg(ctx, err, errMsg) |
|
return |
|
} |
|
|
|
ctx.JSON(res, nil) |
|
}
|
|
|