532 lines
12 KiB
Go
532 lines
12 KiB
Go
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)
|
||
}
|