admin/windows_lock_go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1、消息提示

Browse Source
This commit is contained in:
hucan
2025-07-15 16:43:50 +08:00
parent ab50cf0dfe
commit 2e35d55838
21 changed files with 1436 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

217
app/admin/apis/mm_alarm_log.go Normal file
View File

@ -0,0 +1,217 @@
package apis
import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/go-admin-team/go-admin-core/sdk/api"
"github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth/user"
_ "github.com/go-admin-team/go-admin-core/sdk/pkg/response"
"go-admin/app/admin/models"
"go-admin/app/admin/service"
"go-admin/app/admin/service/dto"
"go-admin/common/actions"
)
type MmAlarmLog struct {
api.Api
}
// GetPage 获取钱包告警记录列表
// @Summary 获取钱包告警记录列表
// @Description 获取钱包告警记录列表
// @Tags 钱包告警记录
// @Param machineId query string false "设备id"
// @Param biosId query string false "设备码"
// @Param pageSize query int false "页条数"
// @Param pageIndex query int false "页码"
// @Success 200 {object} response.Response{data=response.Page{list=[]models.MmAlarmLog}} "{"code": 200, "data": [...]}"
// @Router /api/v1/mm-alarm-log [get]
// @Security Bearer
func (e MmAlarmLog) GetPage(c *gin.Context) {
req := dto.MmAlarmLogGetPageReq{}
s := service.MmAlarmLog{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
p := actions.GetPermissionFromContext(c)
list := make([]models.MmAlarmLog, 0)
var count int64
err = s.GetPage(&req, p, &list, &count)
if err != nil {
e.Error(500, err, fmt.Sprintf("获取钱包告警记录失败，\r\n失败信息 %s", err.Error()))
return
}
e.PageOK(list, int(count), req.GetPageIndex(), req.GetPageSize(), "查询成功")
}
// Get 获取钱包告警记录
// @Summary 获取钱包告警记录
// @Description 获取钱包告警记录
// @Tags 钱包告警记录
// @Param id path int false "id"
// @Success 200 {object} response.Response{data=models.MmAlarmLog} "{"code": 200, "data": [...]}"
// @Router /api/v1/mm-alarm-log/{id} [get]
// @Security Bearer
func (e MmAlarmLog) Get(c *gin.Context) {
req := dto.MmAlarmLogGetReq{}
s := service.MmAlarmLog{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
var object models.MmAlarmLog
p := actions.GetPermissionFromContext(c)
err = s.Get(&req, p, &object)
if err != nil {
e.Error(500, err, fmt.Sprintf("获取钱包告警记录失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(object, "查询成功")
}
// Insert 创建钱包告警记录
// @Summary 创建钱包告警记录
// @Description 创建钱包告警记录
// @Tags 钱包告警记录
// @Accept application/json
// @Product application/json
// @Param data body dto.MmAlarmLogInsertReq true "data"
// @Success 200 {object} response.Response "{"code": 200, "message": "添加成功"}"
// @Router /api/v1/mm-alarm-log [post]
// @Security Bearer
func (e MmAlarmLog) Insert(c *gin.Context) {
req := dto.MmAlarmLogInsertReq{}
s := service.MmAlarmLog{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
// 设置创建人
req.SetCreateBy(user.GetUserId(c))
err = s.Insert(&req)
if err != nil {
e.Error(500, err, fmt.Sprintf("创建钱包告警记录失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(req.GetId(), "创建成功")
}
// Update 修改钱包告警记录
// @Summary 修改钱包告警记录
// @Description 修改钱包告警记录
// @Tags 钱包告警记录
// @Accept application/json
// @Product application/json
// @Param id path int true "id"
// @Param data body dto.MmAlarmLogUpdateReq true "body"
// @Success 200 {object} response.Response "{"code": 200, "message": "修改成功"}"
// @Router /api/v1/mm-alarm-log/{id} [put]
// @Security Bearer
func (e MmAlarmLog) Update(c *gin.Context) {
req := dto.MmAlarmLogUpdateReq{}
s := service.MmAlarmLog{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
req.SetUpdateBy(user.GetUserId(c))
p := actions.GetPermissionFromContext(c)
err = s.Update(&req, p)
if err != nil {
e.Error(500, err, fmt.Sprintf("修改钱包告警记录失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(req.GetId(), "修改成功")
}
// Delete 删除钱包告警记录
// @Summary 删除钱包告警记录
// @Description 删除钱包告警记录
// @Tags 钱包告警记录
// @Param data body dto.MmAlarmLogDeleteReq true "body"
// @Success 200 {object} response.Response "{"code": 200, "message": "删除成功"}"
// @Router /api/v1/mm-alarm-log [delete]
// @Security Bearer
func (e MmAlarmLog) Delete(c *gin.Context) {
s := service.MmAlarmLog{}
req := dto.MmAlarmLogDeleteReq{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
// req.SetUpdateBy(user.GetUserId(c))
p := actions.GetPermissionFromContext(c)
err = s.Remove(&req, p)
if err != nil {
e.Error(500, err, fmt.Sprintf("删除钱包告警记录失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(req.GetId(), "删除成功")
}
// ClearAll 清空钱包告警记录
func (e MmAlarmLog) ClearAll(c *gin.Context) {
s := service.MmAlarmLog{}
err := e.MakeContext(c).
MakeOrm().
MakeService(&s.Service).
Errors
if err != nil {
e.Error(500, err, err.Error())
return
}
p := actions.GetPermissionFromContext(c)
err = s.ClearAll(p)
if err != nil {
e.Error(500, err, fmt.Sprintf("清空钱包告警记录失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(nil, "清空成功")
}

236
app/admin/apis/mm_wallet_white_list.go Normal file
View File

@ -0,0 +1,236 @@
package apis
import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/go-admin-team/go-admin-core/sdk/api"
"github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth/user"
_ "github.com/go-admin-team/go-admin-core/sdk/pkg/response"
"go-admin/app/admin/models"
"go-admin/app/admin/service"
"go-admin/app/admin/service/dto"
"go-admin/common/actions"
)
type MmWalletWhiteList struct {
api.Api
}
// GetPage 获取钱包白名单列表
// @Summary 获取钱包白名单列表
// @Description 获取钱包白名单列表
// @Tags 钱包白名单
// @Param address query string false "钱包地址"
// @Param status query string false "是否启用"
// @Param pageSize query int false "页条数"
// @Param pageIndex query int false "页码"
// @Success 200 {object} response.Response{data=response.Page{list=[]models.MmWalletWhiteList}} "{"code": 200, "data": [...]}"
// @Router /api/v1/mm-wallet-white-list [get]
// @Security Bearer
func (e MmWalletWhiteList) GetPage(c *gin.Context) {
req := dto.MmWalletWhiteListGetPageReq{}
s := service.MmWalletWhiteList{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
p := actions.GetPermissionFromContext(c)
list := make([]models.MmWalletWhiteList, 0)
var count int64
err = s.GetPage(&req, p, &list, &count)
if err != nil {
e.Error(500, err, fmt.Sprintf("获取钱包白名单失败，\r\n失败信息 %s", err.Error()))
return
}
e.PageOK(list, int(count), req.GetPageIndex(), req.GetPageSize(), "查询成功")
}
// Get 获取钱包白名单
// @Summary 获取钱包白名单
// @Description 获取钱包白名单
// @Tags 钱包白名单
// @Param id path int false "id"
// @Success 200 {object} response.Response{data=models.MmWalletWhiteList} "{"code": 200, "data": [...]}"
// @Router /api/v1/mm-wallet-white-list/{id} [get]
// @Security Bearer
func (e MmWalletWhiteList) Get(c *gin.Context) {
req := dto.MmWalletWhiteListGetReq{}
s := service.MmWalletWhiteList{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
var object models.MmWalletWhiteList
p := actions.GetPermissionFromContext(c)
err = s.Get(&req, p, &object)
if err != nil {
e.Error(500, err, fmt.Sprintf("获取钱包白名单失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(object, "查询成功")
}
// Insert 创建钱包白名单
// @Summary 创建钱包白名单
// @Description 创建钱包白名单
// @Tags 钱包白名单
// @Accept application/json
// @Product application/json
// @Param data body dto.MmWalletWhiteListInsertReq true "data"
// @Success 200 {object} response.Response "{"code": 200, "message": "添加成功"}"
// @Router /api/v1/mm-wallet-white-list [post]
// @Security Bearer
func (e MmWalletWhiteList) Insert(c *gin.Context) {
req := dto.MmWalletWhiteListInsertReq{}
s := service.MmWalletWhiteList{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
if req.Address == "" {
e.Error(500, err, "钱包地址不能为空")
return
}
// 设置创建人
req.SetCreateBy(user.GetUserId(c))
err = s.Insert(&req)
if err != nil {
e.Error(500, err, fmt.Sprintf("创建钱包白名单失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(req.GetId(), "创建成功")
}
// Update 修改钱包白名单
// @Summary 修改钱包白名单
// @Description 修改钱包白名单
// @Tags 钱包白名单
// @Accept application/json
// @Product application/json
// @Param id path int true "id"
// @Param data body dto.MmWalletWhiteListUpdateReq true "body"
// @Success 200 {object} response.Response "{"code": 200, "message": "修改成功"}"
// @Router /api/v1/mm-wallet-white-list/{id} [put]
// @Security Bearer
func (e MmWalletWhiteList) Update(c *gin.Context) {
req := dto.MmWalletWhiteListUpdateReq{}
s := service.MmWalletWhiteList{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
if req.Address == "" {
e.Error(500, err, "钱包地址不能为空")
return
}
req.SetUpdateBy(user.GetUserId(c))
p := actions.GetPermissionFromContext(c)
err = s.Update(&req, p)
if err != nil {
e.Error(500, err, fmt.Sprintf("修改钱包白名单失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(req.GetId(), "修改成功")
}
// BatchInsert 批量创建钱包白名单
func (e MmWalletWhiteList) BatchInsert(c *gin.Context) {
s := service.MmWalletWhiteList{}
req := dto.MmWalletWhiteListBatchInsertReq{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
addresss, err := req.GetAddresss()
if err != nil {
e.Error(500, nil, err.Error())
return
}
err = s.BatchInsert(addresss, user.GetUserId(c))
if err != nil {
e.Error(500, err, fmt.Sprintf("批量创建钱包白名单失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(nil, "批量创建成功")
}
// Delete 删除钱包白名单
// @Summary 删除钱包白名单
// @Description 删除钱包白名单
// @Tags 钱包白名单
// @Param data body dto.MmWalletWhiteListDeleteReq true "body"
// @Success 200 {object} response.Response "{"code": 200, "message": "删除成功"}"
// @Router /api/v1/mm-wallet-white-list [delete]
// @Security Bearer
func (e MmWalletWhiteList) Delete(c *gin.Context) {
s := service.MmWalletWhiteList{}
req := dto.MmWalletWhiteListDeleteReq{}
err := e.MakeContext(c).
MakeOrm().
Bind(&req).
MakeService(&s.Service).
Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, err.Error())
return
}
// req.SetUpdateBy(user.GetUserId(c))
p := actions.GetPermissionFromContext(c)
err = s.Remove(&req, p)
if err != nil {
e.Error(500, err, fmt.Sprintf("删除钱包白名单失败，\r\n失败信息 %s", err.Error()))
return
}
e.OK(req.GetId(), "删除成功")
}

30
app/admin/models/mm_alarm_log.go Normal file
View File

@ -0,0 +1,30 @@
package models
import (
"go-admin/common/models"
)
type MmAlarmLog struct {
models.Model
MachineId string `json:"machineId" gorm:"type:varchar(255);comment:设备id"`
BiosId string `json:"biosId" gorm:"type:varchar(255);comment:设备码"`
Content string `json:"content" gorm:"type:varchar(255);comment:内容"`
models.ModelTime
models.ControlBy
}
func (MmAlarmLog) TableName() string {
return "mm_alarm_log"
}
func (e *MmAlarmLog) Generate() models.ActiveRecord {
o := *e
return &o
}
func (e *MmAlarmLog) GetId() interface{} {
return e.Id
}

27
app/admin/models/mm_wallet_white_list.go Normal file
View File

@ -0,0 +1,27 @@
package models
import (
"go-admin/common/models"
)
type MmWalletWhiteList struct {
models.Model
Address string `json:"address" gorm:"type:varchar(255);comment:钱包地址"`
Status int `json:"status" gorm:"type:tinyint;comment:是否启用"`
models.ModelTime
models.ControlBy
}
func (MmWalletWhiteList) TableName() string {
return "mm_wallet_white_list"
}
func (e *MmWalletWhiteList) Generate() models.ActiveRecord {
o := *e
return &o
}
func (e *MmWalletWhiteList) GetId() interface{} {
return e.Id
}

29
app/admin/router/mm_alarm_log.go Normal file
View File

@ -0,0 +1,29 @@
package router
import (
"github.com/gin-gonic/gin"
jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
"go-admin/app/admin/apis"
"go-admin/common/actions"
"go-admin/common/middleware"
)
func init() {
routerCheckRole = append(routerCheckRole, registerMmAlarmLogRouter)
}
// registerMmAlarmLogRouter
func registerMmAlarmLogRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
api := apis.MmAlarmLog{}
r := v1.Group("/mm-alarm-log").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
{
r.GET("", actions.PermissionAction(), api.GetPage)
r.GET("/:id", actions.PermissionAction(), api.Get)
r.POST("", api.Insert)
r.PUT("/:id", actions.PermissionAction(), api.Update)
r.DELETE("", api.Delete)
r.DELETE("clear-all", actions.PermissionAction(), api.ClearAll) //清理所有数据
}
}

29
app/admin/router/mm_wallet_white_list.go Normal file
View File

@ -0,0 +1,29 @@
package router
import (
"github.com/gin-gonic/gin"
jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
"go-admin/app/admin/apis"
"go-admin/common/actions"
"go-admin/common/middleware"
)
func init() {
routerCheckRole = append(routerCheckRole, registerMmWalletWhiteListRouter)
}
// registerMmWalletWhiteListRouter
func registerMmWalletWhiteListRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
api := apis.MmWalletWhiteList{}
r := v1.Group("/mm-wallet-white-list").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
{
r.GET("", actions.PermissionAction(), api.GetPage)
r.GET("/:id", actions.PermissionAction(), api.Get)
r.POST("", api.Insert)
r.PUT("/:id", actions.PermissionAction(), api.Update)
r.DELETE("", api.Delete)
r.POST("batch", api.BatchInsert)
}
}

11
app/admin/router/sys_router.go
View File

@ -2,6 +2,7 @@ package router
import (
"go-admin/app/admin/apis"
"go-admin/app/websocket"
"mime"
"github.com/go-admin-team/go-admin-core/sdk/config"
@ -13,6 +14,7 @@ import (
swaggerfiles "github.com/swaggo/files"
"go-admin/common/global"
"go-admin/common/middleware"
"go-admin/common/middleware/handler"
_ "go-admin/docs/admin"
@ -60,10 +62,15 @@ func sysSwaggerRouter(r *gin.RouterGroup) {
}
func sysCheckRoleRouterInit(r *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
hub := websocket.NewHub()
global.WebSocketHub = hub // 👈 挂到全局
go global.WebSocketHub.Run()
wss := r.Group("").Use(authMiddleware.MiddlewareFunc())
{
wss.GET("/ws/:id/:channel", ws.WebsocketManager.WsClient)
wss.GET("/wslogout/:id/:channel", ws.WebsocketManager.UnWsClient)
wss.GET("/ws", websocket.ServeWS(hub))
// wss.GET("/ws/:id/:channel", ws.WebsocketManager.WsClient)
// wss.GET("/wslogout/:id/:channel", ws.WebsocketManager.UnWsClient)
}
v1 := r.Group("/api/v1")

93
app/admin/service/dto/mm_alarm_log.go Normal file
View File

@ -0,0 +1,93 @@
package dto
import (
"go-admin/app/admin/models"
"go-admin/common/dto"
common "go-admin/common/models"
)
type MmAlarmLogGetPageReq struct {
dto.Pagination `search:"-"`
MachineId string `form:"machineId" search:"type:exact;column:machine_id;table:mm_alarm_log" comment:"设备id"`
BiosId string `form:"biosId" search:"type:exact;column:bios_id;table:mm_alarm_log" comment:"设备码"`
MmAlarmLogOrder
}
type MmAlarmLogOrder struct {
Id string `form:"idOrder" search:"type:order;column:id;table:mm_alarm_log"`
MachineId string `form:"machineIdOrder" search:"type:order;column:machine_id;table:mm_alarm_log"`
BiosId string `form:"biosIdOrder" search:"type:order;column:bios_id;table:mm_alarm_log"`
Content string `form:"contentOrder" search:"type:order;column:content;table:mm_alarm_log"`
CreatedAt string `form:"createdAtOrder" search:"type:order;column:created_at;table:mm_alarm_log"`
UpdatedAt string `form:"updatedAtOrder" search:"type:order;column:updated_at;table:mm_alarm_log"`
DeletedAt string `form:"deletedAtOrder" search:"type:order;column:deleted_at;table:mm_alarm_log"`
CreateBy string `form:"createByOrder" search:"type:order;column:create_by;table:mm_alarm_log"`
UpdateBy string `form:"updateByOrder" search:"type:order;column:update_by;table:mm_alarm_log"`
}
func (m *MmAlarmLogGetPageReq) GetNeedSearch() interface{} {
return *m
}
type MmAlarmLogInsertReq struct {
Id int `json:"-" comment:"主键id"` // 主键id
MachineId string `json:"machineId" comment:"设备id"`
BiosId string `json:"biosId" comment:"设备码"`
Content string `json:"content" comment:"内容"`
common.ControlBy
}
func (s *MmAlarmLogInsertReq) Generate(model *models.MmAlarmLog) {
if s.Id == 0 {
model.Model = common.Model{ Id: s.Id }
}
model.MachineId = s.MachineId
model.BiosId = s.BiosId
model.Content = s.Content
model.CreateBy = s.CreateBy // 添加这而，需要记录是被谁创建的
}
func (s *MmAlarmLogInsertReq) GetId() interface{} {
return s.Id
}
type MmAlarmLogUpdateReq struct {
Id int `uri:"id" comment:"主键id"` // 主键id
MachineId string `json:"machineId" comment:"设备id"`
BiosId string `json:"biosId" comment:"设备码"`
Content string `json:"content" comment:"内容"`
common.ControlBy
}
func (s *MmAlarmLogUpdateReq) Generate(model *models.MmAlarmLog) {
if s.Id == 0 {
model.Model = common.Model{ Id: s.Id }
}
model.MachineId = s.MachineId
model.BiosId = s.BiosId
model.Content = s.Content
model.UpdateBy = s.UpdateBy // 添加这而，需要记录是被谁更新的
}
func (s *MmAlarmLogUpdateReq) GetId() interface{} {
return s.Id
}
// MmAlarmLogGetReq 功能获取请求参数
type MmAlarmLogGetReq struct {
Id int `uri:"id"`
}
func (s *MmAlarmLogGetReq) GetId() interface{} {
return s.Id
}
// MmAlarmLogDeleteReq 功能删除请求参数
type MmAlarmLogDeleteReq struct {
Ids []int `json:"ids"`
}
func (s *MmAlarmLogDeleteReq) GetId() interface{} {
return s.Ids
}

113
app/admin/service/dto/mm_wallet_white_list.go Normal file
View File

@ -0,0 +1,113 @@
package dto
import (
"errors"
"go-admin/app/admin/models"
"go-admin/common/dto"
common "go-admin/common/models"
"strings"
)
type MmWalletWhiteListGetPageReq struct {
dto.Pagination `search:"-"`
Address string `form:"address" search:"type:contains;column:address;table:mm_wallet_white_list" comment:"钱包地址"`
Status string `form:"status" search:"type:exact;column:status;table:mm_wallet_white_list" comment:"是否启用"`
MmWalletWhiteListOrder
}
type MmWalletWhiteListOrder struct {
Id string `form:"idOrder" search:"type:order;column:id;table:mm_wallet_white_list"`
Address string `form:"addressOrder" search:"type:order;column:address;table:mm_wallet_white_list"`
Status string `form:"statusOrder" search:"type:order;column:status;table:mm_wallet_white_list"`
CreatedAt string `form:"createdAtOrder" search:"type:order;column:created_at;table:mm_wallet_white_list"`
UpdatedAt string `form:"updatedAtOrder" search:"type:order;column:updated_at;table:mm_wallet_white_list"`
DeletedAt string `form:"deletedAtOrder" search:"type:order;column:deleted_at;table:mm_wallet_white_list"`
CreateBy string `form:"createByOrder" search:"type:order;column:create_by;table:mm_wallet_white_list"`
UpdateBy string `form:"updateByOrder" search:"type:order;column:update_by;table:mm_wallet_white_list"`
}
func (m *MmWalletWhiteListGetPageReq) GetNeedSearch() interface{} {
return *m
}
type MmWalletWhiteListBatchInsertReq struct {
Addresss string `json:"addresss" comment:"钱包地址"`
common.ControlBy
}
func (s *MmWalletWhiteListBatchInsertReq) GetAddresss() ([]string, error) {
result := []string{}
items := strings.Split(strings.ReplaceAll(s.Addresss, " ", ""), "\n")
for _, item := range items {
if item != "" {
result = append(result, strings.ToLower(item))
}
}
if len(result) == 0 {
return nil, errors.New("钱包地址不能为空")
}
return result, nil
}
type MmWalletWhiteListInsertReq struct {
Id int `json:"-" comment:"主键"` // 主键
Address string `json:"address" comment:"钱包地址"`
Status int `json:"status" comment:"是否启用"`
common.ControlBy
}
func (s *MmWalletWhiteListInsertReq) Generate(model *models.MmWalletWhiteList) {
if s.Id == 0 {
model.Model = common.Model{Id: s.Id}
}
model.Address = strings.ToLower(s.Address)
model.Status = s.Status
model.CreateBy = s.CreateBy // 添加这而，需要记录是被谁创建的
}
func (s *MmWalletWhiteListInsertReq) GetId() interface{} {
return s.Id
}
type MmWalletWhiteListUpdateReq struct {
Id int `uri:"id" comment:"主键"` // 主键
Address string `json:"address" comment:"钱包地址"`
Status int `json:"status" comment:"是否启用"`
common.ControlBy
}
func (s *MmWalletWhiteListUpdateReq) Generate(model *models.MmWalletWhiteList) {
if s.Id == 0 {
model.Model = common.Model{Id: s.Id}
}
model.Address = strings.ToLower(s.Address)
model.Status = s.Status
model.UpdateBy = s.UpdateBy // 添加这而，需要记录是被谁更新的
}
func (s *MmWalletWhiteListUpdateReq) GetId() interface{} {
return s.Id
}
// MmWalletWhiteListGetReq 功能获取请求参数
type MmWalletWhiteListGetReq struct {
Id int `uri:"id"`
}
func (s *MmWalletWhiteListGetReq) GetId() interface{} {
return s.Id
}
// MmWalletWhiteListDeleteReq 功能删除请求参数
type MmWalletWhiteListDeleteReq struct {
Ids []int `json:"ids"`
}
func (s *MmWalletWhiteListDeleteReq) GetId() interface{} {
return s.Ids
}

118
app/admin/service/mm_alarm_log.go Normal file
View File

@ -0,0 +1,118 @@
package service
import (
"errors"
"github.com/go-admin-team/go-admin-core/sdk/service"
"gorm.io/gorm"
"go-admin/app/admin/models"
"go-admin/app/admin/service/dto"
"go-admin/common/actions"
cDto "go-admin/common/dto"
)
type MmAlarmLog struct {
service.Service
}
// 清除所有记录
func (e MmAlarmLog) ClearAll(p *actions.DataPermission) error {
if err := e.Orm.Exec("TRUNCATE TABLE mm_alarm_log;").Error; err != nil {
return err
}
return nil
}
// GetPage 获取MmAlarmLog列表
func (e *MmAlarmLog) GetPage(c *dto.MmAlarmLogGetPageReq, p *actions.DataPermission, list *[]models.MmAlarmLog, count *int64) error {
var err error
var data models.MmAlarmLog
err = e.Orm.Model(&data).
Scopes(
cDto.MakeCondition(c.GetNeedSearch()),
cDto.Paginate(c.GetPageSize(), c.GetPageIndex()),
actions.Permission(data.TableName(), p),
).
Find(list).Limit(-1).Offset(-1).
Count(count).Error
if err != nil {
e.Log.Errorf("MmAlarmLogService GetPage error:%s \r\n", err)
return err
}
return nil
}
// Get 获取MmAlarmLog对象
func (e *MmAlarmLog) Get(d *dto.MmAlarmLogGetReq, p *actions.DataPermission, model *models.MmAlarmLog) error {
var data models.MmAlarmLog
err := e.Orm.Model(&data).
Scopes(
actions.Permission(data.TableName(), p),
).
First(model, d.GetId()).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
err = errors.New("查看对象不存在或无权查看")
e.Log.Errorf("Service GetMmAlarmLog error:%s \r\n", err)
return err
}
if err != nil {
e.Log.Errorf("db error:%s", err)
return err
}
return nil
}
// Insert 创建MmAlarmLog对象
func (e *MmAlarmLog) Insert(c *dto.MmAlarmLogInsertReq) error {
var err error
var data models.MmAlarmLog
c.Generate(&data)
err = e.Orm.Create(&data).Error
if err != nil {
e.Log.Errorf("MmAlarmLogService Insert error:%s \r\n", err)
return err
}
return nil
}
// Update 修改MmAlarmLog对象
func (e *MmAlarmLog) Update(c *dto.MmAlarmLogUpdateReq, p *actions.DataPermission) error {
var err error
var data = models.MmAlarmLog{}
e.Orm.Scopes(
actions.Permission(data.TableName(), p),
).First(&data, c.GetId())
c.Generate(&data)
db := e.Orm.Save(&data)
if err = db.Error; err != nil {
e.Log.Errorf("MmAlarmLogService Save error:%s \r\n", err)
return err
}
if db.RowsAffected == 0 {
return errors.New("无权更新该数据")
}
return nil
}
// Remove 删除MmAlarmLog
func (e *MmAlarmLog) Remove(d *dto.MmAlarmLogDeleteReq, p *actions.DataPermission) error {
var data models.MmAlarmLog
db := e.Orm.Model(&data).
Scopes(
actions.Permission(data.TableName(), p),
).Delete(&data, d.GetId())
if err := db.Error; err != nil {
e.Log.Errorf("Service RemoveMmAlarmLog error:%s \r\n", err)
return err
}
if db.RowsAffected == 0 {
return errors.New("无权删除该数据")
}
return nil
}

74
app/admin/service/mm_risk_log.go
View File

@ -2,9 +2,10 @@ package service
import (
"errors"
"strconv"
"strings"
"github.com/go-admin-team/go-admin-core/logger"
"github.com/bytedance/sonic"
"github.com/go-admin-team/go-admin-core/sdk/service"
"gorm.io/gorm"
@ -12,6 +13,8 @@ import (
"go-admin/app/admin/service/dto"
"go-admin/common/actions"
cDto "go-admin/common/dto"
"go-admin/common/global"
"go-admin/common/helper"
)
type MmRiskLog struct {
@ -146,8 +149,6 @@ func (e *MmRiskLog) Remove(d *dto.MmRiskLogDeleteReq, p *actions.DataPermission)
func (e *MmRiskLog) Save(req *dto.MmRiskLogBatchReq) error {
datas := make([]models.MmRiskLog, 0)
logger.Debug("req:%v", req)
for _, item := range req.Contents {
data := models.MmRiskLog{}
data.MachineId = req.MachineId
@ -161,6 +162,73 @@ func (e *MmRiskLog) Save(req *dto.MmRiskLogBatchReq) error {
e.Log.Errorf("MmRiskLogService Save error:%s \r\n", err)
return err
}
helper.SafeGo(func() {
if err := e.SendMsg(datas); err != nil {
e.Log.Errorf("发送消息失败:%s", err)
}
})
return nil
}
// 发送消息并保存日志
func (e *MmRiskLog) SendMsg(datas []models.MmRiskLog) error {
walletWhiteListService := MmWalletWhiteList{Service: e.Service}
addresss, err := walletWhiteListService.GetList()
if err != nil {
e.Log.Errorf("获取白名单缓存失败:")
}
alarmLogs := []models.MmAlarmLog{}
for _, item := range datas {
if helper.ArrayAny(addresss, item.Content) {
continue
}
alarmLog := models.MmAlarmLog{}
alarmLog.MachineId = item.MachineId
alarmLog.BiosId = item.BiosId
alarmLog.Content = item.Content
alarmLogs = append(alarmLogs, alarmLog)
}
if len(alarmLogs) == 0 {
return nil
}
userService := SysUser{Service: e.Service}
userIds, err := userService.GetByPermission("admin:mmAlarmLog:notice")
if err != nil {
e.Log.Errorf("获取管理员失败:%s", err)
}
userIdStr := []string{}
for _, item := range userIds {
userIdStr = append(userIdStr, strconv.Itoa(item))
}
if err := e.Orm.Save(&alarmLogs).Error; err != nil {
e.Log.Errorf("保存告警日志失败:%s", err)
return err
}
for _, item := range alarmLogs {
notice := global.AlarmLogNotice{
MachineId: item.MachineId,
BiosId: item.BiosId,
Content: item.Content,
}
vals, _ := sonic.Marshal(notice)
if vals != nil {
global.WebSocketHub.SendToAll(userIdStr, vals)
}
}
return nil
}

180
app/admin/service/mm_wallet_white_list.go Normal file
View File

@ -0,0 +1,180 @@
package service
import (
"errors"
"strings"
"github.com/go-admin-team/go-admin-core/sdk/service"
"gorm.io/gorm"
"go-admin/app/admin/models"
"go-admin/app/admin/service/dto"
"go-admin/common/actions"
cDto "go-admin/common/dto"
"go-admin/common/enums"
"go-admin/common/helper"
)
type MmWalletWhiteList struct {
service.Service
}
// GetPage 获取MmWalletWhiteList列表
func (e *MmWalletWhiteList) GetPage(c *dto.MmWalletWhiteListGetPageReq, p *actions.DataPermission, list *[]models.MmWalletWhiteList, count *int64) error {
var err error
var data models.MmWalletWhiteList
err = e.Orm.Model(&data).
Scopes(
cDto.MakeCondition(c.GetNeedSearch()),
cDto.Paginate(c.GetPageSize(), c.GetPageIndex()),
actions.Permission(data.TableName(), p),
).
Find(list).Limit(-1).Offset(-1).
Count(count).Error
if err != nil {
e.Log.Errorf("MmWalletWhiteListService GetPage error:%s \r\n", err)
return err
}
return nil
}
// Get 获取MmWalletWhiteList对象
func (e *MmWalletWhiteList) Get(d *dto.MmWalletWhiteListGetReq, p *actions.DataPermission, model *models.MmWalletWhiteList) error {
var data models.MmWalletWhiteList
err := e.Orm.Model(&data).
Scopes(
actions.Permission(data.TableName(), p),
).
First(model, d.GetId()).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
err = errors.New("查看对象不存在或无权查看")
e.Log.Errorf("Service GetMmWalletWhiteList error:%s \r\n", err)
return err
}
if err != nil {
e.Log.Errorf("db error:%s", err)
return err
}
return nil
}
// Insert 创建MmWalletWhiteList对象
func (e *MmWalletWhiteList) Insert(c *dto.MmWalletWhiteListInsertReq) error {
var err error
var data models.MmWalletWhiteList
c.Generate(&data)
err = e.Orm.Create(&data).Error
if err != nil {
e.Log.Errorf("MmWalletWhiteListService Insert error:%s \r\n", err)
return err
}
e.SaveCache()
return nil
}
func (e *MmWalletWhiteList) BatchInsert(addresss []string, userId int) error {
var err error
datas := make([]models.MmWalletWhiteList, 0)
for _, address := range addresss {
data := models.MmWalletWhiteList{
Address: strings.ToLower(address),
Status: 1,
}
datas = append(datas, data)
}
err = e.Orm.Save(&datas).Error
if err != nil {
e.Log.Errorf("MmWalletWhiteListService BatchInsert error:%s \r\n", err)
return err
}
e.SaveCache()
return err
}
// Update 修改MmWalletWhiteList对象
func (e *MmWalletWhiteList) Update(c *dto.MmWalletWhiteListUpdateReq, p *actions.DataPermission) error {
var err error
var data = models.MmWalletWhiteList{}
e.Orm.Scopes(
actions.Permission(data.TableName(), p),
).First(&data, c.GetId())
c.Generate(&data)
db := e.Orm.Save(&data)
if err = db.Error; err != nil {
e.Log.Errorf("MmWalletWhiteListService Save error:%s \r\n", err)
return err
}
if db.RowsAffected == 0 {
return errors.New("无权更新该数据")
}
e.SaveCache()
return nil
}
// 保存缓存
func (e *MmWalletWhiteList) SaveCache() error {
var datas []string
// var list []models.MmWalletWhiteList
if err := e.Orm.Model(&models.MmWalletWhiteList{}).Where("status =1").Distinct("address").Select("address").Find(&datas).Error; err != nil {
return err
}
if len(datas) == 0 {
if err := helper.DefaultRedis.SetEmptyListCache(enums.WalletWhiteListKey, 0); err != nil {
e.Log.Errorf("MmWalletWhiteListService SaveCache error:%s \r\n", err)
return err
}
} else {
if err := helper.DefaultRedis.SetListCache(enums.WalletWhiteListKey, 0, datas...); err != nil {
e.Log.Errorf("MmWalletWhiteListService SaveCache error:%s \r\n", err)
return err
}
}
return nil
}
// Remove 删除MmWalletWhiteList
func (e *MmWalletWhiteList) Remove(d *dto.MmWalletWhiteListDeleteReq, p *actions.DataPermission) error {
var data models.MmWalletWhiteList
db := e.Orm.Model(&data).
Scopes(
actions.Permission(data.TableName(), p),
).Delete(&data, d.GetId())
if err := db.Error; err != nil {
e.Log.Errorf("Service RemoveMmWalletWhiteList error:%s \r\n", err)
return err
}
if db.RowsAffected == 0 {
return errors.New("无权删除该数据")
}
e.SaveCache()
return nil
}
// 获取白名单列表
func (e *MmWalletWhiteList) GetList() ([]string, error) {
address, _ := helper.DefaultRedis.GetAllList(enums.WalletWhiteListKey)
if address == nil || len(address) == 0 {
err := e.Orm.Model(&models.MmWalletWhiteList{}).Where("status =1").Distinct("address").Select("address").Find(&address).Error
if err != nil {
return nil, err
}
}
return address, nil
}

20
app/admin/service/sys_user.go
View File

@ -18,6 +18,26 @@ type SysUser struct {
service.Service
}
// 根据权限获取user id
func (e SysUser) GetByPermission(permission string) ([]int, error) {
result := make([]int, 0)
if err := e.Orm.Raw(`select DISTINCT user_id from (
select u.user_id from sys_user u
join sys_role r on r.role_id =u.role_id
where r.role_key='admin'
union all
select u.user_id from sys_user u
join sys_role_menu t on t.role_id =u.role_id
join sys_role r on r.role_id =u.role_id
join sys_menu sm on sm.menu_id=t.menu_id
where sm.permission = ?) tt`, permission).Scan(&result).Error; err != nil {
return nil, err
}
return result, nil
}
// GetPage 获取SysUser列表
func (e *SysUser) GetPage(c *dto.SysUserGetPageReq, p *actions.DataPermission, list *[]models.SysUser, count *int64) error {
var err error

84
app/websocket/client.go Normal file
View File

@ -0,0 +1,84 @@
package websocket
import (
"context"
"log"
"time"
"github.com/gorilla/websocket"
)
type Client struct {
ID string
Conn *websocket.Conn
Send chan []byte
Context context.Context
CancelFunc context.CancelFunc
}
func (c *Client) Read(hub *Hub) {
defer func() {
hub.Unregister <- c
c.Conn.Close()
log.Printf("Client %s disconnected\n", c.ID)
c.CancelFunc()
}()
c.Conn.SetReadLimit(512)
c.Conn.SetReadDeadline(time.Now().Add(60 * time.Second))
c.Conn.SetPongHandler(func(string) error {
c.Conn.SetReadDeadline(time.Now().Add(60 * time.Second))
return nil
})
for {
select {
case <-c.Context.Done():
return
default:
_, message, err := c.Conn.ReadMessage()
if err != nil {
log.Printf("Read error from client %s: %v", c.ID, err)
return
}
log.Printf("Receive [%s]: %s", c.ID, message)
// 这里你可以把消息发给 hub.Broadcast 或业务处理
}
}
}
func (c *Client) Write() {
ticker := time.NewTicker(54 * time.Second) // 小于读超时，保证ping及时发
defer func() {
ticker.Stop()
c.Conn.Close()
c.CancelFunc()
}()
for {
select {
case <-c.Context.Done():
return
case msg, ok := <-c.Send:
if !ok {
// 通道关闭，结束写入
c.Conn.WriteMessage(websocket.CloseMessage, []byte{})
return
}
c.Conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
err := c.Conn.WriteMessage(websocket.TextMessage, msg)
if err != nil {
log.Printf("Write error to client %s: %v", c.ID, err)
return
}
case <-ticker.C:
// 发送 ping
c.Conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
if err := c.Conn.WriteMessage(websocket.PingMessage, nil); err != nil {
log.Printf("Ping error to client %s: %v", c.ID, err)
return
}
}
}
}

55
app/websocket/handler.go Normal file
View File

@ -0,0 +1,55 @@
package websocket
import (
"context"
"fmt"
"net/http"
"github.com/gin-gonic/gin"
"github.com/go-admin-team/go-admin-core/logger"
"github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
"github.com/gorilla/websocket"
)
var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true // 允许跨域
},
}
func ServeWS(hub *Hub) gin.HandlerFunc {
return func(c *gin.Context) {
// 这里假设 JWT 中间件已验证，且用户 ID 在 Context
claims := jwtauth.ExtractClaims(c)
userID, ok := claims["identity"].(float64)
if !ok {
c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid user ID in token"})
return
}
// 设置 Subprotocols 支持客户端传来的协议（token等）
upgrader.Subprotocols = []string{c.GetHeader("Sec-WebSocket-Protocol")}
conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
logger.Errorf("WebSocket upgrade failed: %v", err)
c.JSON(http.StatusBadRequest, gin.H{"error": "upgrade failed"})
return
}
ctx, cancel := context.WithCancel(context.Background())
client := &Client{
ID: fmt.Sprintf("%v", userID),
Conn: conn,
Send: make(chan []byte, 1024),
Context: ctx,
CancelFunc: cancel,
}
hub.Register <- client
go client.Read(hub)
go client.Write()
}
}

63
app/websocket/hub.go Normal file
View File

@ -0,0 +1,63 @@
package websocket
import "sync"
type Hub struct {
Clients map[string]*Client
Register chan *Client
Unregister chan *Client
mu sync.RWMutex
}
func NewHub() *Hub {
return &Hub{
Clients: make(map[string]*Client),
Register: make(chan *Client),
Unregister: make(chan *Client),
}
}
func (h *Hub) Run() {
for {
select {
case client := <-h.Register:
h.mu.Lock()
h.Clients[client.ID] = client
h.mu.Unlock()
case client := <-h.Unregister:
h.mu.Lock()
if _, ok := h.Clients[client.ID]; ok {
delete(h.Clients, client.ID)
close(client.Send)
}
h.mu.Unlock()
}
}
}
func (h *Hub) SendToClient(id string, msg []byte) {
h.mu.RLock()
defer h.mu.RUnlock()
if c, ok := h.Clients[id]; ok {
c.Send <- msg
}
}
func (h *Hub) SendToAll(ids []string, msg []byte) {
h.mu.RLock()
defer h.mu.RUnlock()
for _, id := range ids {
if c, ok := h.Clients[id]; ok {
c.Send <- msg
}
}
}
func (h *Hub) Broadcast(msg []byte) {
h.mu.RLock()
defer h.mu.RUnlock()
for _, client := range h.Clients {
client.Send <- msg
}
}

5
common/enums/redis_key.go
View File

@ -27,3 +27,8 @@ const (
//系统配置缓存
Config = "config:%s"
)
const (
// 钱包白名单缓存
WalletWhiteListKey = "wallet_white_list"
)

11
common/global/websocket.go Normal file
View File

@ -0,0 +1,11 @@
package global
import "go-admin/app/websocket"
var WebSocketHub *websocket.Hub
type AlarmLogNotice struct {
MachineId string `json:"machineId"`
BiosId string `json:"biosId"`
Content string `json:"content"`
}

44
common/helper/safego.go Normal file
View File

@ -0,0 +1,44 @@
package helper
import (
"fmt"
"runtime"
"runtime/debug"
"strings"
"github.com/go-admin-team/go-admin-core/logger"
)
// SafeGo 安全地启动一个 goroutine，捕获 panic
func SafeGo(fn func()) {
go func() {
defer func() {
if r := recover(); r != nil {
// 记录 Goroutine ID、panic 信息和堆栈
logger.Error(fmt.Sprintf("Recovered from panic in Goroutine %s: %v\nStack Trace:\n%s", GetGoroutineID(), r, string(debug.Stack())))
}
}()
fn()
}()
}
// 获取 Goroutine ID
func GetGoroutineID() string {
buf := make([]byte, 64)
n := runtime.Stack(buf, false)
stack := string(buf[:n])
// 提取 Goroutine ID
id := strings.Split(stack, " ")[1]
return id
}
func SafeGoParam[T any](fn func(T), param T) {
go func() {
defer func() {
if r := recover(); r != nil {
logger.Error(fmt.Sprintf(" SafeGoParam Recovered from panic in Goroutine %s: %v\nStack Trace:\n%s", GetGoroutineID(), r, string(debug.Stack())))
}
}()
fn(param) // 执行传入的函数
}()
}

2
config/settings.yml
View File

@ -7,7 +7,7 @@ settings:
# 服务名称
name: testApp
# 端口号
port: 8000 # 服务端口号
port: 8001 # 服务端口号
readtimeout: 1
writertimeout: 2
# 数据权限功能开关

1
go.mod
View File

@ -78,6 +78,7 @@ require (
github.com/go-sql-driver/mysql v1.9.2 // indirect
github.com/goccy/go-json v0.10.5 // indirect
github.com/gofrs/flock v0.8.1 // indirect
github.com/golang-jwt/jwt/v4 v4.5.2 // indirect
github.com/golang-jwt/jwt/v5 v5.2.2 // indirect
github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
github.com/golang-sql/sqlexp v0.1.0 // indirect