648 lines
21 KiB
Go
648 lines
21 KiB
Go
package controllers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"server/models"
|
|
"server/pkg/jwtutil"
|
|
|
|
"github.com/beego/beego/v2/client/orm"
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
)
|
|
|
|
type PlatformAccountPoolCursorController struct{ beego.Controller }
|
|
type PlatformAccountPoolWindsurfController struct{ beego.Controller }
|
|
type PlatformAccountPoolKrioController struct{ beego.Controller }
|
|
|
|
type accountPoolCreateRow struct {
|
|
DataType string `json:"type"`
|
|
Account string `json:"account"`
|
|
Password string `json:"password"`
|
|
Token string `json:"token"`
|
|
Remark string `json:"remark"`
|
|
}
|
|
|
|
func requirePlatformAuth(c *beego.Controller) (*jwtutil.Claims, error) {
|
|
auth := c.Ctx.Request.Header.Get("Authorization")
|
|
if auth == "" {
|
|
return nil, fmt.Errorf("未登录")
|
|
}
|
|
parts := strings.SplitN(auth, " ", 2)
|
|
if len(parts) != 2 || parts[0] != "Bearer" {
|
|
return nil, fmt.Errorf("认证信息格式错误")
|
|
}
|
|
claims, err := jwtutil.ParseToken(parts[1])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("无效token")
|
|
}
|
|
if claims.UserType != "platform" {
|
|
return nil, fmt.Errorf("无权访问")
|
|
}
|
|
return claims, nil
|
|
}
|
|
|
|
func poolJSONErr(c *beego.Controller, httpStatus, code int, msg string) {
|
|
c.Ctx.Output.SetStatus(httpStatus)
|
|
c.Data["json"] = map[string]interface{}{"code": code, "msg": msg}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func isValidPoolType(t string) bool {
|
|
return t == "account" || t == "tk" || t == "account_tk"
|
|
}
|
|
|
|
func validateCreateRow(row accountPoolCreateRow) error {
|
|
if !isValidPoolType(row.DataType) {
|
|
return fmt.Errorf("账号类型不正确")
|
|
}
|
|
row.Account = strings.TrimSpace(row.Account)
|
|
row.Password = strings.TrimSpace(row.Password)
|
|
row.Token = strings.TrimSpace(row.Token)
|
|
if row.DataType == "account" && (row.Account == "" || row.Password == "") {
|
|
return fmt.Errorf("账号密码类型必须填写账号和密码")
|
|
}
|
|
if row.DataType == "tk" && row.Token == "" {
|
|
return fmt.Errorf("token类型必须填写token")
|
|
}
|
|
if row.DataType == "account_tk" && (row.Account == "" || row.Password == "" || row.Token == "") {
|
|
return fmt.Errorf("账号密码+token类型必须填写账号、密码、token")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func listPoolRows(c *beego.Controller, module string) {
|
|
if _, err := requirePlatformAuth(c); err != nil {
|
|
poolJSONErr(c, 401, 401, err.Error())
|
|
return
|
|
}
|
|
page, _ := c.GetInt("page", 1)
|
|
pageSize, _ := c.GetInt("pageSize", 30)
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 {
|
|
pageSize = 30
|
|
}
|
|
if pageSize > 200 {
|
|
pageSize = 200
|
|
}
|
|
keyword := strings.TrimSpace(c.GetString("keyword"))
|
|
dataType := strings.TrimSpace(c.GetString("type"))
|
|
status := strings.TrimSpace(c.GetString("status"))
|
|
|
|
applyFilters := func(qs orm.QuerySeter) orm.QuerySeter {
|
|
if dataType != "" && isValidPoolType(dataType) {
|
|
qs = qs.Filter("data_type", dataType)
|
|
}
|
|
if status == "unused" {
|
|
qs = qs.Filter("is_extracted", 0)
|
|
}
|
|
if status == "extracted" {
|
|
qs = qs.Filter("is_extracted", 1)
|
|
}
|
|
if keyword != "" {
|
|
qs = qs.Filter("account__icontains", keyword)
|
|
}
|
|
return qs
|
|
}
|
|
|
|
var list interface{}
|
|
var total int64
|
|
var err error
|
|
|
|
switch module {
|
|
case "cursor":
|
|
qs := applyFilters(models.Orm.QueryTable(new(models.PlatformAccountPoolCursor)))
|
|
total, err = qs.Count()
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "获取列表失败: "+err.Error())
|
|
return
|
|
}
|
|
var rows []models.PlatformAccountPoolCursor
|
|
_, err = qs.OrderBy("-id").Limit(pageSize, (page-1)*pageSize).All(&rows)
|
|
if err != nil && err != orm.ErrNoRows {
|
|
poolJSONErr(c, 500, 500, "cursor查询失败: "+err.Error())
|
|
return
|
|
}
|
|
if rows == nil {
|
|
rows = []models.PlatformAccountPoolCursor{}
|
|
}
|
|
list = rows
|
|
case "windsurf":
|
|
qs := applyFilters(models.Orm.QueryTable(new(models.PlatformAccountPoolWindsurf)))
|
|
total, err = qs.Count()
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "获取列表失败: "+err.Error())
|
|
return
|
|
}
|
|
var rows []models.PlatformAccountPoolWindsurf
|
|
_, err = qs.OrderBy("-id").Limit(pageSize, (page-1)*pageSize).All(&rows)
|
|
if err != nil && err != orm.ErrNoRows {
|
|
poolJSONErr(c, 500, 500, "获取列表失败: "+err.Error())
|
|
return
|
|
}
|
|
if rows == nil {
|
|
rows = []models.PlatformAccountPoolWindsurf{}
|
|
}
|
|
list = rows
|
|
case "krio":
|
|
qs := applyFilters(models.Orm.QueryTable(new(models.PlatformAccountPoolKiro)))
|
|
total, err = qs.Count()
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "获取列表失败: "+err.Error())
|
|
return
|
|
}
|
|
var rows []models.PlatformAccountPoolKiro
|
|
_, err = qs.OrderBy("-id").Limit(pageSize, (page-1)*pageSize).All(&rows)
|
|
if err != nil && err != orm.ErrNoRows {
|
|
poolJSONErr(c, 500, 500, "获取列表失败: "+err.Error())
|
|
return
|
|
}
|
|
if rows == nil {
|
|
rows = []models.PlatformAccountPoolKiro{}
|
|
}
|
|
list = rows
|
|
default:
|
|
poolJSONErr(c, 400, 400, "无效模块")
|
|
return
|
|
}
|
|
|
|
c.Data["json"] = map[string]interface{}{
|
|
"code": 200,
|
|
"msg": "success",
|
|
"data": map[string]interface{}{
|
|
"list": list,
|
|
"total": total,
|
|
},
|
|
}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func addPoolRow(c *beego.Controller, module string) {
|
|
if _, err := requirePlatformAuth(c); err != nil {
|
|
poolJSONErr(c, 401, 401, err.Error())
|
|
return
|
|
}
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
var row accountPoolCreateRow
|
|
if err := json.Unmarshal(raw, &row); err != nil {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
if err := validateCreateRow(row); err != nil {
|
|
poolJSONErr(c, 400, 400, err.Error())
|
|
return
|
|
}
|
|
|
|
switch module {
|
|
case "cursor":
|
|
r := &models.PlatformAccountPoolCursor{
|
|
DataType: strings.TrimSpace(row.DataType),
|
|
Account: strings.TrimSpace(row.Account),
|
|
Password: strings.TrimSpace(row.Password),
|
|
Token: strings.TrimSpace(row.Token),
|
|
Remark: strings.TrimSpace(row.Remark),
|
|
IsExtracted: 0,
|
|
}
|
|
_, err = models.Orm.Insert(r)
|
|
case "windsurf":
|
|
r := &models.PlatformAccountPoolWindsurf{
|
|
DataType: strings.TrimSpace(row.DataType),
|
|
Account: strings.TrimSpace(row.Account),
|
|
Password: strings.TrimSpace(row.Password),
|
|
Token: strings.TrimSpace(row.Token),
|
|
Remark: strings.TrimSpace(row.Remark),
|
|
IsExtracted: 0,
|
|
}
|
|
_, err = models.Orm.Insert(r)
|
|
case "krio":
|
|
r := &models.PlatformAccountPoolKiro{
|
|
DataType: strings.TrimSpace(row.DataType),
|
|
Account: strings.TrimSpace(row.Account),
|
|
Password: strings.TrimSpace(row.Password),
|
|
Token: strings.TrimSpace(row.Token),
|
|
Remark: strings.TrimSpace(row.Remark),
|
|
IsExtracted: 0,
|
|
}
|
|
_, err = models.Orm.Insert(r)
|
|
default:
|
|
poolJSONErr(c, 400, 400, "无效模块")
|
|
return
|
|
}
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "添加失败: "+err.Error())
|
|
return
|
|
}
|
|
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "添加成功"}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func batchAddPoolRows(c *beego.Controller, module string) {
|
|
if _, err := requirePlatformAuth(c); err != nil {
|
|
poolJSONErr(c, 401, 401, err.Error())
|
|
return
|
|
}
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
var payload struct {
|
|
Rows []accountPoolCreateRow `json:"rows"`
|
|
}
|
|
if err := json.Unmarshal(raw, &payload); err != nil || len(payload.Rows) == 0 {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
for _, row := range payload.Rows {
|
|
if err := validateCreateRow(row); err != nil {
|
|
poolJSONErr(c, 400, 400, err.Error())
|
|
return
|
|
}
|
|
}
|
|
for _, row := range payload.Rows {
|
|
switch module {
|
|
case "cursor":
|
|
_, err = models.Orm.Insert(&models.PlatformAccountPoolCursor{
|
|
DataType: strings.TrimSpace(row.DataType),
|
|
Account: strings.TrimSpace(row.Account),
|
|
Password: strings.TrimSpace(row.Password),
|
|
Token: strings.TrimSpace(row.Token),
|
|
Remark: strings.TrimSpace(row.Remark),
|
|
IsExtracted: 0,
|
|
})
|
|
case "windsurf":
|
|
_, err = models.Orm.Insert(&models.PlatformAccountPoolWindsurf{
|
|
DataType: strings.TrimSpace(row.DataType),
|
|
Account: strings.TrimSpace(row.Account),
|
|
Password: strings.TrimSpace(row.Password),
|
|
Token: strings.TrimSpace(row.Token),
|
|
Remark: strings.TrimSpace(row.Remark),
|
|
IsExtracted: 0,
|
|
})
|
|
case "krio":
|
|
_, err = models.Orm.Insert(&models.PlatformAccountPoolKiro{
|
|
DataType: strings.TrimSpace(row.DataType),
|
|
Account: strings.TrimSpace(row.Account),
|
|
Password: strings.TrimSpace(row.Password),
|
|
Token: strings.TrimSpace(row.Token),
|
|
Remark: strings.TrimSpace(row.Remark),
|
|
IsExtracted: 0,
|
|
})
|
|
default:
|
|
poolJSONErr(c, 400, 400, "无效模块")
|
|
return
|
|
}
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "批量添加失败: "+err.Error())
|
|
return
|
|
}
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "批量添加成功"}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func getPoolDetail(c *beego.Controller, module string) {
|
|
if _, err := requirePlatformAuth(c); err != nil {
|
|
poolJSONErr(c, 401, 401, err.Error())
|
|
return
|
|
}
|
|
id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if err != nil || id == 0 {
|
|
poolJSONErr(c, 400, 400, "无效ID")
|
|
return
|
|
}
|
|
|
|
switch module {
|
|
case "cursor":
|
|
var row models.PlatformAccountPoolCursor
|
|
if err := models.Orm.QueryTable(new(models.PlatformAccountPoolCursor)).Filter("id", id).One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "记录不存在")
|
|
return
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": row}
|
|
case "windsurf":
|
|
var row models.PlatformAccountPoolWindsurf
|
|
if err := models.Orm.QueryTable(new(models.PlatformAccountPoolWindsurf)).Filter("id", id).One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "记录不存在")
|
|
return
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": row}
|
|
case "krio":
|
|
var row models.PlatformAccountPoolKiro
|
|
if err := models.Orm.QueryTable(new(models.PlatformAccountPoolKiro)).Filter("id", id).One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "记录不存在")
|
|
return
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": row}
|
|
default:
|
|
poolJSONErr(c, 400, 400, "无效模块")
|
|
return
|
|
}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func extractPoolRow(c *beego.Controller, module string) {
|
|
if _, err := requirePlatformAuth(c); err != nil {
|
|
poolJSONErr(c, 401, 401, err.Error())
|
|
return
|
|
}
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
var payload struct {
|
|
ID uint64 `json:"id"`
|
|
Type string `json:"type"`
|
|
Platform string `json:"platform"` // local | xianyu | taobao | pinduoduo | jingdong | douyin | ziyoushangcheng
|
|
Remark string `json:"remark"`
|
|
}
|
|
if err := json.Unmarshal(raw, &payload); err != nil {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
if payload.Platform != "local" &&
|
|
payload.Platform != "xianyu" &&
|
|
payload.Platform != "taobao" &&
|
|
payload.Platform != "pinduoduo" &&
|
|
payload.Platform != "jingdong" &&
|
|
payload.Platform != "douyin" &&
|
|
payload.Platform != "ziyoushangcheng" {
|
|
poolJSONErr(c, 400, 400, "提取平台错误")
|
|
return
|
|
}
|
|
if payload.Type != "" && !isValidPoolType(payload.Type) {
|
|
poolJSONErr(c, 400, 400, "提取类型错误")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
platform := payload.Platform
|
|
remark := strings.TrimSpace(payload.Remark)
|
|
|
|
switch module {
|
|
case "cursor":
|
|
var row models.PlatformAccountPoolCursor
|
|
qs := models.Orm.QueryTable(new(models.PlatformAccountPoolCursor)).Filter("is_extracted", 0)
|
|
if payload.ID > 0 {
|
|
qs = qs.Filter("id", payload.ID)
|
|
} else if payload.Type != "" {
|
|
qs = qs.Filter("data_type", payload.Type)
|
|
}
|
|
if err := qs.OrderBy("id").One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "没有可提取数据")
|
|
return
|
|
}
|
|
_, err = models.Orm.QueryTable(new(models.PlatformAccountPoolCursor)).Filter("id", row.ID).Update(map[string]interface{}{
|
|
"is_extracted": 1,
|
|
"extracted_time": now,
|
|
"extracted_platform": platform,
|
|
"remark": remark,
|
|
})
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "提取失败: "+err.Error())
|
|
return
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "提取成功", "data": row}
|
|
case "windsurf":
|
|
var row models.PlatformAccountPoolWindsurf
|
|
qs := models.Orm.QueryTable(new(models.PlatformAccountPoolWindsurf)).Filter("is_extracted", 0)
|
|
if payload.ID > 0 {
|
|
qs = qs.Filter("id", payload.ID)
|
|
} else if payload.Type != "" {
|
|
qs = qs.Filter("data_type", payload.Type)
|
|
}
|
|
if err := qs.OrderBy("id").One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "没有可提取数据")
|
|
return
|
|
}
|
|
_, err = models.Orm.QueryTable(new(models.PlatformAccountPoolWindsurf)).Filter("id", row.ID).Update(map[string]interface{}{
|
|
"is_extracted": 1,
|
|
"extracted_time": now,
|
|
"extracted_platform": platform,
|
|
"remark": remark,
|
|
})
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "提取失败: "+err.Error())
|
|
return
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "提取成功", "data": row}
|
|
case "krio":
|
|
var row models.PlatformAccountPoolKiro
|
|
qs := models.Orm.QueryTable(new(models.PlatformAccountPoolKiro)).Filter("is_extracted", 0)
|
|
if payload.ID > 0 {
|
|
qs = qs.Filter("id", payload.ID)
|
|
} else if payload.Type != "" {
|
|
qs = qs.Filter("data_type", payload.Type)
|
|
}
|
|
if err := qs.OrderBy("id").One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "没有可提取数据")
|
|
return
|
|
}
|
|
_, err = models.Orm.QueryTable(new(models.PlatformAccountPoolKiro)).Filter("id", row.ID).Update(map[string]interface{}{
|
|
"is_extracted": 1,
|
|
"extracted_time": now,
|
|
"extracted_platform": platform,
|
|
"remark": remark,
|
|
})
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "提取失败: "+err.Error())
|
|
return
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "提取成功", "data": row}
|
|
default:
|
|
poolJSONErr(c, 400, 400, "无效模块")
|
|
return
|
|
}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func replenishPoolRow(c *beego.Controller, module string) {
|
|
if _, err := requirePlatformAuth(c); err != nil {
|
|
poolJSONErr(c, 401, 401, err.Error())
|
|
return
|
|
}
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
var payload struct {
|
|
Type string `json:"type"`
|
|
Platform string `json:"platform"`
|
|
Remark string `json:"remark"`
|
|
}
|
|
if err := json.Unmarshal(raw, &payload); err != nil {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
if !isValidPoolType(payload.Type) {
|
|
poolJSONErr(c, 400, 400, "账号类型不正确")
|
|
return
|
|
}
|
|
validPlatforms := map[string]bool{"local": true, "xianyu": true, "pinduoduo": true, "jingdong": true, "douyin": true}
|
|
if !validPlatforms[payload.Platform] {
|
|
poolJSONErr(c, 400, 400, "提取平台错误")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
platform := payload.Platform
|
|
remark := strings.TrimSpace(payload.Remark)
|
|
|
|
switch module {
|
|
case "cursor":
|
|
var row models.PlatformAccountPoolCursor
|
|
if err := models.Orm.QueryTable(new(models.PlatformAccountPoolCursor)).
|
|
Filter("is_extracted", 0).Filter("data_type", payload.Type).
|
|
OrderBy("id").One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "暂无可用账号")
|
|
return
|
|
}
|
|
if _, err = models.Orm.QueryTable(new(models.PlatformAccountPoolCursor)).Filter("id", row.ID).Update(map[string]interface{}{
|
|
"is_extracted": 1, "extracted_time": now, "extracted_platform": platform, "remark": remark,
|
|
}); err != nil {
|
|
poolJSONErr(c, 500, 500, "补号失败: "+err.Error())
|
|
return
|
|
}
|
|
row.IsExtracted = 1
|
|
row.ExtractedTime = &now
|
|
row.ExtractedPlatform = &platform
|
|
row.Remark = remark
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "补号成功", "data": row}
|
|
case "windsurf":
|
|
var row models.PlatformAccountPoolWindsurf
|
|
if err := models.Orm.QueryTable(new(models.PlatformAccountPoolWindsurf)).
|
|
Filter("is_extracted", 0).Filter("data_type", payload.Type).
|
|
OrderBy("id").One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "暂无可用账号")
|
|
return
|
|
}
|
|
if _, err = models.Orm.QueryTable(new(models.PlatformAccountPoolWindsurf)).Filter("id", row.ID).Update(map[string]interface{}{
|
|
"is_extracted": 1, "extracted_time": now, "extracted_platform": platform, "remark": remark,
|
|
}); err != nil {
|
|
poolJSONErr(c, 500, 500, "补号失败: "+err.Error())
|
|
return
|
|
}
|
|
row.IsExtracted = 1
|
|
row.ExtractedTime = &now
|
|
row.ExtractedPlatform = &platform
|
|
row.Remark = remark
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "补号成功", "data": row}
|
|
case "krio":
|
|
var row models.PlatformAccountPoolKiro
|
|
if err := models.Orm.QueryTable(new(models.PlatformAccountPoolKiro)).
|
|
Filter("is_extracted", 0).Filter("data_type", payload.Type).
|
|
OrderBy("id").One(&row); err != nil {
|
|
poolJSONErr(c, 404, 404, "暂无可用账号")
|
|
return
|
|
}
|
|
if _, err = models.Orm.QueryTable(new(models.PlatformAccountPoolKiro)).Filter("id", row.ID).Update(map[string]interface{}{
|
|
"is_extracted": 1, "extracted_time": now, "extracted_platform": platform, "remark": remark,
|
|
}); err != nil {
|
|
poolJSONErr(c, 500, 500, "补号失败: "+err.Error())
|
|
return
|
|
}
|
|
row.IsExtracted = 1
|
|
row.ExtractedTime = &now
|
|
row.ExtractedPlatform = &platform
|
|
row.Remark = remark
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "补号成功", "data": row}
|
|
default:
|
|
poolJSONErr(c, 400, 400, "无效模块")
|
|
return
|
|
}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func updatePoolRemark(c *beego.Controller, module string) {
|
|
if _, err := requirePlatformAuth(c); err != nil {
|
|
poolJSONErr(c, 401, 401, err.Error())
|
|
return
|
|
}
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
var payload struct {
|
|
ID uint64 `json:"id"`
|
|
Remark string `json:"remark"`
|
|
}
|
|
if err := json.Unmarshal(raw, &payload); err != nil || payload.ID == 0 {
|
|
poolJSONErr(c, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
remark := strings.TrimSpace(payload.Remark)
|
|
|
|
var updated int64
|
|
switch module {
|
|
case "cursor":
|
|
updated, err = models.Orm.QueryTable(new(models.PlatformAccountPoolCursor)).Filter("id", payload.ID).Update(map[string]interface{}{
|
|
"remark": remark,
|
|
})
|
|
case "windsurf":
|
|
updated, err = models.Orm.QueryTable(new(models.PlatformAccountPoolWindsurf)).Filter("id", payload.ID).Update(map[string]interface{}{
|
|
"remark": remark,
|
|
})
|
|
case "krio":
|
|
updated, err = models.Orm.QueryTable(new(models.PlatformAccountPoolKiro)).Filter("id", payload.ID).Update(map[string]interface{}{
|
|
"remark": remark,
|
|
})
|
|
default:
|
|
poolJSONErr(c, 400, 400, "无效模块")
|
|
return
|
|
}
|
|
if err != nil {
|
|
poolJSONErr(c, 500, 500, "备注更新失败: "+err.Error())
|
|
return
|
|
}
|
|
if updated == 0 {
|
|
poolJSONErr(c, 404, 404, "记录不存在")
|
|
return
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "备注更新成功"}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *PlatformAccountPoolCursorController) List() { listPoolRows(&c.Controller, "cursor") }
|
|
func (c *PlatformAccountPoolCursorController) Add() { addPoolRow(&c.Controller, "cursor") }
|
|
func (c *PlatformAccountPoolCursorController) BatchAdd() { batchAddPoolRows(&c.Controller, "cursor") }
|
|
func (c *PlatformAccountPoolCursorController) Detail() { getPoolDetail(&c.Controller, "cursor") }
|
|
func (c *PlatformAccountPoolCursorController) Extract() { extractPoolRow(&c.Controller, "cursor") }
|
|
func (c *PlatformAccountPoolCursorController) Replenish() { replenishPoolRow(&c.Controller, "cursor") }
|
|
func (c *PlatformAccountPoolCursorController) UpdateRemark() {
|
|
updatePoolRemark(&c.Controller, "cursor")
|
|
}
|
|
|
|
func (c *PlatformAccountPoolWindsurfController) List() { listPoolRows(&c.Controller, "windsurf") }
|
|
func (c *PlatformAccountPoolWindsurfController) Add() { addPoolRow(&c.Controller, "windsurf") }
|
|
func (c *PlatformAccountPoolWindsurfController) BatchAdd() { batchAddPoolRows(&c.Controller, "windsurf") }
|
|
func (c *PlatformAccountPoolWindsurfController) Detail() { getPoolDetail(&c.Controller, "windsurf") }
|
|
func (c *PlatformAccountPoolWindsurfController) Extract() { extractPoolRow(&c.Controller, "windsurf") }
|
|
func (c *PlatformAccountPoolWindsurfController) Replenish() { replenishPoolRow(&c.Controller, "windsurf") }
|
|
func (c *PlatformAccountPoolWindsurfController) UpdateRemark() {
|
|
updatePoolRemark(&c.Controller, "windsurf")
|
|
}
|
|
|
|
func (c *PlatformAccountPoolKrioController) List() { listPoolRows(&c.Controller, "krio") }
|
|
func (c *PlatformAccountPoolKrioController) Add() { addPoolRow(&c.Controller, "krio") }
|
|
func (c *PlatformAccountPoolKrioController) BatchAdd() { batchAddPoolRows(&c.Controller, "krio") }
|
|
func (c *PlatformAccountPoolKrioController) Detail() { getPoolDetail(&c.Controller, "krio") }
|
|
func (c *PlatformAccountPoolKrioController) Extract() { extractPoolRow(&c.Controller, "krio") }
|
|
func (c *PlatformAccountPoolKrioController) Replenish() { replenishPoolRow(&c.Controller, "krio") }
|
|
func (c *PlatformAccountPoolKrioController) UpdateRemark() {
|
|
updatePoolRemark(&c.Controller, "krio")
|
|
}
|