bilibili-backup/app/service/main/up/server/http/up.go

532 lines
12 KiB
Go
Raw Normal View History

2019-04-22 10:59:20 +08:00
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)
}