m5stack/StackChan
1
0
Fork 0
mirror of https://github.com/m5stack/StackChan.git synced 2026-04-28 03:22:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

server code 4/27

Browse Source
This commit is contained in:
袁智鸿
2026-04-27 10:35:03 +08:00
parent f0fa33cd67
commit 2ccbcd01c0
143 changed files with 5812 additions and 756 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/internal/controller/dance/dance_new.go
+6
View File
@@ -17,3 +17,9 @@ type ControllerV1 struct{}
func NewV1() dance.IDanceV1 {
return &ControllerV1{}
}
type ControllerV2 struct{}
func NewV2() dance.IDanceV2 {
return &ControllerV2{}
}
server/internal/controller/dance/dance_v1_create.go
+50 -35
View File
@@ -7,60 +7,75 @@ package dance
import (
"context"
"encoding/json"
"stackChan/internal/dao"
"stackChan/internal/model"
"stackChan/internal/model/do"
"stackChan/api/dance/v1"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
)
func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
if req.Index < 0 {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Index cannot be negative")
// 1. Get and validate MAC address (business required parameter)
mac := g.RequestFromCtx(ctx).GetCtxVar(model.Mac).String()
if mac == "" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "MAC address cannot be empty")
}
device, err := dao.Device.Ctx(ctx).Where("mac=", req.Mac).One()
if err != nil {
return nil, err
// 2. Auto validate using struct v tag (DanceName required), manual secondary validation as fallback
if req.DanceName == "" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Dance name cannot be empty")
}
if device.IsEmpty() {
_, err = dao.Device.Ctx(ctx).Data(dao.Device.Columns().Mac, req.Mac).Insert()
if err != nil {
return nil, err
// 3. Validate dance data not empty (RawMessage need to check if empty/only null)
if len(req.DanceData) == 0 || string(req.DanceData) == "null" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Dance data cannot be empty or null")
}
// 4. Use transaction to ensure data consistency
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
// 4.1 Query device, create if not exists
device, err := dao.Device.Ctx(ctx).TX(tx).Where("mac=?", mac).One()
if err != nil && !gerror.HasCode(err, gcode.CodeNotFound) {
return gerror.NewCode(gcode.CodeInternalError, "Failed to query device: %v", err.Error())
}
}
dance, err := dao.DeviceDance.Ctx(ctx).Where("mac=?", req.Mac).Where("dance_index=?", req.Index).One()
if err != nil {
return nil, err
}
// Create device if not exists
if device.IsEmpty() {
_, err = dao.Device.Ctx(ctx).TX(tx).Data(dao.Device.Columns().Mac, mac).Insert()
if err != nil {
return gerror.NewCode(gcode.CodeInternalError, "Failed to create device: %v", err.Error())
}
}
danceListJSON, err := json.Marshal(req.List)
if err != nil {
return nil, err
}
// 4.2 Check if dance data with same MAC+DanceName exists (avoid duplicates)
exist, err := dao.DeviceDance.Ctx(ctx).TX(tx).
Where("mac=?", mac).
Where("dance_name=?", req.DanceName).
Exist()
if err != nil {
return gerror.NewCode(gcode.CodeInternalError, "Failed to check duplicate dance data: %v", err.Error())
}
if exist {
return gerror.NewCode(gcode.CodeBusinessValidationFailed, "Dance data with MAC %s and name '%s' already exists", mac, req.DanceName)
}
if dance.IsEmpty() {
_, err = dao.DeviceDance.Ctx(ctx).Data(do.DeviceDance{
Mac: req.Mac,
DanceIndex: req.Index,
DanceData: danceListJSON,
// 4.3 Insert dance data (use RawMessage directly, no need for secondary serialization)
_, err = dao.DeviceDance.Ctx(ctx).TX(tx).Data(do.DeviceDance{
Mac: mac,
DanceData: req.DanceData, // Use RawMessage directly, avoid duplicate marshal
DanceName: req.DanceName,
MusicUrl: req.MusicUrl, // Add background music URL field
}).Insert()
if err != nil {
return nil, err
}
} else {
_, err = dao.DeviceDance.Ctx(ctx).Where("mac=?", req.Mac).Where("dance_index=?", req.Index).Data(do.DeviceDance{
DanceData: danceListJSON,
}).Update()
if err != nil {
return nil, err
return gerror.NewCode(gcode.CodeInternalError, "Failed to insert dance data: %v", err.Error())
}
return nil
})
if err != nil {
return nil, err
}
response := v1.CreateRes("Dance data saved successfully")
return &response, nil
server/internal/controller/dance/dance_v1_delete.go
+10 -1
View File
@@ -8,11 +8,20 @@ package dance
import (
"context"
"stackChan/internal/dao"
"stackChan/internal/model"
"stackChan/api/dance/v1"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
)
func (c *ControllerV1) Delete(ctx context.Context, req *v1.DeleteReq) (res *v1.DeleteRes, err error) {
_, err = dao.DeviceDance.Ctx(ctx).Where("mac=", req.Mac).Where("dance_index=", req.Index).Delete()
mac := g.RequestFromCtx(ctx).GetCtxVar(model.Mac).String()
if mac == "" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter)
}
_, err = dao.DeviceDance.Ctx(ctx).Where("id=", req.Id).Delete()
return
}
server/internal/controller/dance/dance_v1_get_dance.go
+34
View File
@@ -0,0 +1,34 @@
/*
SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
SPDX-License-Identifier: MIT
*/
package dance
import (
"context"
"stackChan/internal/dao"
"stackChan/internal/model"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"stackChan/api/dance/v1"
)
func (c *ControllerV1) GetDanceInfo(ctx context.Context, req *v1.GetDanceInfoReq) (res *v1.GetDanceInfoRes, err error) {
mac := g.RequestFromCtx(ctx).GetCtxVar(model.Mac).String()
if mac == "" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter)
}
if req.Id == 0 {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "The dance ID cannot be left blank.")
}
var dance model.Dance
err = dao.DeviceDance.Ctx(ctx).Where("mac=?", mac).Where("id=?", req.Id).Scan(&dance)
if err != nil {
return nil, gerror.NewCode(gcode.CodeInternalError)
}
return new(v1.GetDanceInfoRes(dance)), nil
}
server/internal/controller/dance/dance_v1_get_list.go
+31 -17
View File
@@ -7,38 +7,52 @@ package dance
import (
"context"
"encoding/json"
"stackChan/internal/dao"
"stackChan/internal/model"
"stackChan/internal/model/do"
"stackChan/internal/model/entity"
"strconv"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"stackChan/api/dance/v1"
)
func (c *ControllerV1) GetList(ctx context.Context, req *v1.GetListReq) (res *v1.GetListRes, err error) {
danceMap := make(map[string][]model.DanceData)
var list []entity.DeviceDance
mac := g.RequestFromCtx(ctx).GetCtxVar(model.Mac).String()
if mac == "" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter)
}
var danceList []model.Dance
err = dao.DeviceDance.Ctx(ctx).Where(do.DeviceDance{
Mac: req.Mac,
}).Scan(&list)
Mac: mac,
}).Scan(&danceList)
if err != nil {
return nil, err
}
if len(list) > 0 {
deviceDance := list[0]
var danceList []model.DanceData
err = json.Unmarshal([]byte(deviceDance.DanceData), &danceList)
if err != nil {
return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err)
// Core modification: insert default data only when query result is empty
if len(danceList) == 0 {
// Insert single default dance data
defaultDance := do.DeviceDance{
Mac: mac,
MusicUrl: "file/music/stackchan_music.mp3",
DanceData: model.DefaultDanceData,
}
_, err = dao.DeviceDance.Ctx(ctx).Data(defaultDance).Insert()
if err != nil {
return nil, err
}
// Re-query list (one data exists now)
err = dao.DeviceDance.Ctx(ctx).Where(do.DeviceDance{
Mac: mac,
}).Scan(&danceList)
if err != nil {
return nil, err
}
key := strconv.Itoa(deviceDance.DanceIndex)
danceMap[key] = danceList
}
response := v1.GetListRes(danceMap)
return &response, nil
return new(v1.GetListRes(danceList)), nil
}
server/internal/controller/dance/dance_v1_get_music_list.go
+17
View File
@@ -0,0 +1,17 @@
/*
SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
SPDX-License-Identifier: MIT
*/
package dance
import (
"context"
"stackChan/api/dance/v1"
)
func (c *ControllerV1) GetMusicList(ctx context.Context, req *v1.GetMusicListReq) (res *v1.GetMusicListRes, err error) {
var list = make([]string, 1)
list = append(list, "file/music/stackchan_music.mp3")
return new(v1.GetMusicListRes(list)), nil
}
server/internal/controller/dance/dance_v1_update.go
+29 -10
View File
@@ -9,23 +9,42 @@ import (
"context"
"encoding/json"
"stackChan/internal/dao"
"stackChan/internal/model"
"stackChan/internal/model/do"
"stackChan/api/dance/v1"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
)
func (c *ControllerV1) Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error) {
response := v1.UpdateRes("")
danceJSON, err := json.Marshal(req.Data)
mac := g.RequestFromCtx(ctx).GetCtxVar(model.Mac).String()
if mac == "" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "MAC address cannot be empty")
}
if req.Id == 0 { // Adjust based on actual type of req.Id (int/string)
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Dance ID cannot be empty")
}
updateData := do.DeviceDance{}
if req.MusicUrl != "" {
updateData.MusicUrl = req.MusicUrl
}
if req.DanceName != "" {
updateData.DanceName = req.DanceName
}
if req.DanceData != nil {
danceJSON, err := json.Marshal(req.DanceData)
if err != nil {
// Wrap serialization error, add business prompt
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Dance data serialization failed: %v")
}
updateData.DanceData = danceJSON
}
_, err = dao.DeviceDance.Ctx(ctx).Where("mac=?", mac).Where("id=?", req.Id).Data(updateData).Update()
if err != nil {
return nil, err
}
_, err = dao.DeviceDance.Ctx(ctx).Where("mac=?", req.Mac).Where("dance_index=?", req.Index).Data(do.DeviceDance{
DanceData: danceJSON,
}).Update()
if err != nil {
return nil, err
}
response = "Update successful"
return &response, nil
return new(v1.UpdateRes("Update successful")), nil
}
server/internal/controller/dance/dance_v2_create.go
+66
View File
@@ -0,0 +1,66 @@
/*
SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
SPDX-License-Identifier: MIT
*/
package dance
import (
"context"
"stackChan/internal/dao"
"stackChan/internal/model/do"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"stackChan/api/dance/v2"
)
func (c *ControllerV2) Create(ctx context.Context, req *v2.CreateReq) (res *v2.CreateRes, err error) {
mac := req.Mac
if req.DanceName == "" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Dance name cannot be empty")
}
if len(req.DanceData) == 0 || string(req.DanceData) == "null" {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Dance data cannot be empty or null")
}
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
device, err := dao.Device.Ctx(ctx).TX(tx).Where("mac=?", mac).One()
if err != nil && !gerror.HasCode(err, gcode.CodeNotFound) {
return gerror.NewCode(gcode.CodeInternalError, "Failed to query device: %v", err.Error())
}
if device.IsEmpty() {
_, err = dao.Device.Ctx(ctx).TX(tx).Data(dao.Device.Columns().Mac, mac).Insert()
if err != nil {
return gerror.NewCode(gcode.CodeInternalError, "Failed to create device: %v", err.Error())
}
}
exist, err := dao.DeviceDance.Ctx(ctx).TX(tx).
Where("mac=?", mac).
Where("dance_name=?", req.DanceName).
Exist()
if err != nil {
return gerror.NewCode(gcode.CodeInternalError, "Failed to check duplicate dance data: %v", err.Error())
}
if exist {
return gerror.NewCode(gcode.CodeBusinessValidationFailed, "Dance data with MAC %s and name '%s' already exists", mac, req.DanceName)
}
_, err = dao.DeviceDance.Ctx(ctx).TX(tx).Data(do.DeviceDance{
Mac: mac,
DanceData: req.DanceData,
DanceName: req.DanceName,
MusicUrl: req.MusicUrl,
}).Insert()
if err != nil {
return gerror.NewCode(gcode.CodeInternalError, "Failed to insert dance data: %v", err.Error())
}
return nil
})
if err != nil {
return nil, err
}
return new(v2.CreateRes("Dance data saved successfully")), nil
}
server/internal/controller/dance/dance_v2_delete.go
+18
View File
@@ -0,0 +1,18 @@
/*
SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
SPDX-License-Identifier: MIT
*/
package dance
import (
"context"
"stackChan/internal/dao"
"stackChan/api/dance/v2"
)
func (c *ControllerV2) Delete(ctx context.Context, req *v2.DeleteReq) (res *v2.DeleteRes, err error) {
_, err = dao.DeviceDance.Ctx(ctx).Where("id=", req.Id).Delete()
return
}
server/internal/controller/dance/dance_v2_get_dance_info.go
+29
View File
@@ -0,0 +1,29 @@
/*
SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
SPDX-License-Identifier: MIT
*/
package dance
import (
"context"
"stackChan/internal/dao"
"stackChan/internal/model"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"stackChan/api/dance/v2"
)
func (c *ControllerV2) GetDanceInfo(ctx context.Context, req *v2.GetDanceInfoReq) (res *v2.GetDanceInfoRes, err error) {
if req.Id == 0 {
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "The dance ID cannot be left blank.")
}
var dance model.Dance
err = dao.DeviceDance.Ctx(ctx).Where("id=?", req.Id).Scan(&dance)
if err != nil {
return nil, gerror.NewCode(gcode.CodeInternalError)
}
return new(v2.GetDanceInfoRes(dance)), nil
}
server/internal/controller/dance/dance_v2_get_list.go
+50
View File
@@ -0,0 +1,50 @@
/*
SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
SPDX-License-Identifier: MIT
*/
package dance
import (
"context"
"stackChan/api/dance/v2"
"stackChan/internal/dao"
"stackChan/internal/model"
"stackChan/internal/model/do"
)
func (c *ControllerV2) GetList(ctx context.Context, req *v2.GetListReq) (res *v2.GetListRes, err error) {
mac := req.Mac
var danceList []model.Dance
err = dao.DeviceDance.Ctx(ctx).Where(do.DeviceDance{
Mac: mac,
}).Scan(&danceList)
if err != nil {
return nil, err
}
// Core modification: insert default data only when query result is empty
if len(danceList) == 0 {
// Insert single default dance data
defaultDance := do.DeviceDance{
DanceName: "StackChan Dance",
Mac: mac,
MusicUrl: "http://47.113.125.164:12800/file/music/stackchan_music.mp3",
DanceData: model.DefaultDanceData,
}
_, err = dao.DeviceDance.Ctx(ctx).Data(defaultDance).Insert()
if err != nil {
return nil, err
}
// Re-query list (one data exists now)
err = dao.DeviceDance.Ctx(ctx).Where(do.DeviceDance{
Mac: mac,
}).Scan(&danceList)
if err != nil {
return nil, err
}
}
return new(v2.GetListRes(danceList)), nil
}
server/internal/controller/dance/dance_v2_update.go
+44
View File
@@ -0,0 +1,44 @@
/*
SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
SPDX-License-Identifier: MIT
*/
package dance
import (
"context"
"encoding/json"
"stackChan/internal/dao"
"stackChan/internal/model/do"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"stackChan/api/dance/v2"
)
func (c *ControllerV2) Update(ctx context.Context, req *v2.UpdateReq) (res *v2.UpdateRes, err error) {
if req.Id == 0 { // Adjust based on actual type of req.Id (int/string)
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Dance ID cannot be empty")
}
updateData := do.DeviceDance{}
if req.MusicUrl != "" {
updateData.MusicUrl = req.MusicUrl
}
if req.DanceName != "" {
updateData.DanceName = req.DanceName
}
if req.DanceData != nil {
danceJSON, err := json.Marshal(req.DanceData)
if err != nil {
// Wrap serialization error, add business prompt
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "Dance data serialization failed: %v")
}
updateData.DanceData = danceJSON
}
_, err = dao.DeviceDance.Ctx(ctx).Where("id=?", req.Id).Data(updateData).Update()
if err != nil {
return nil, err
}
return new(v2.UpdateRes("Update successful")), nil
}