pro/olons_admin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add Go backend

Browse Source
This commit is contained in:
richjohnrambo
2026-10-10 20:56:17 +08:00
parent 50fcfd2d3d
commit f6024f0964
1040 changed files with 107169 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/internal/controller/admin/admin/cash.go
+60
View File
@@ -0,0 +1,60 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/api/admin/cash"
"hotgo/internal/library/contexts"
"hotgo/internal/model/input/adminin"
"hotgo/internal/service"
)
var (
Cash = cCash{}
)
type cCash struct{}
// View 获取指定信息
func (c *cCash) View(ctx context.Context, req *cash.ViewReq) (res *cash.ViewRes, err error) {
data, err := service.AdminCash().View(ctx, &req.CashViewInp)
if err != nil {
return
}
res = new(cash.ViewRes)
res.CashViewModel = data
return
}
// List 查看列表
func (c *cCash) List(ctx context.Context, req *cash.ListReq) (res *cash.ListRes, err error) {
list, totalCount, err := service.AdminCash().List(ctx, &req.CashListInp)
if err != nil {
return
}
res = new(cash.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Apply 申请提现
func (c *cCash) Apply(ctx context.Context, req *cash.ApplyReq) (res *cash.ApplyRes, err error) {
err = service.AdminCash().Apply(ctx, &adminin.CashApplyInp{
Money: req.Money,
MemberId: contexts.GetUserId(ctx),
})
return
}
// Payment 提现打款处理
func (c *cCash) Payment(ctx context.Context, req *cash.PaymentReq) (res *cash.PaymentRes, err error) {
err = service.AdminCash().Payment(ctx, &req.CashPaymentInp)
return
}
server/internal/controller/admin/admin/credits_log.go
+39
View File
@@ -0,0 +1,39 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.5.3
// @AutoGenerate Date 2023-04-15 15:59:58
package admin
import (
"context"
"hotgo/api/admin/creditslog"
"hotgo/internal/service"
)
var (
CreditsLog = cCreditsLog{}
)
type cCreditsLog struct{}
// List 查看资产变动列表
func (c *cCreditsLog) List(ctx context.Context, req *creditslog.ListReq) (res *creditslog.ListRes, err error) {
list, totalCount, err := service.AdminCreditsLog().List(ctx, &req.CreditsLogListInp)
if err != nil {
return
}
res = new(creditslog.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Export 导出资产变动列表
func (c *cCreditsLog) Export(ctx context.Context, req *creditslog.ExportReq) (res *creditslog.ExportRes, err error) {
err = service.AdminCreditsLog().Export(ctx, &req.CreditsLogListInp)
return
}
server/internal/controller/admin/admin/dept.go
+75
View File
@@ -0,0 +1,75 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/api/admin/dept"
"hotgo/internal/service"
)
var (
Dept = cDept{}
)
type cDept struct{}
// Delete 删除
func (c *cDept) Delete(ctx context.Context, req *dept.DeleteReq) (res *dept.DeleteRes, err error) {
err = service.AdminDept().Delete(ctx, &req.DeptDeleteInp)
return
}
// Edit 更新
func (c *cDept) Edit(ctx context.Context, req *dept.EditReq) (res *dept.EditRes, err error) {
err = service.AdminDept().Edit(ctx, &req.DeptEditInp)
return
}
// MaxSort 最大排序
func (c *cDept) MaxSort(ctx context.Context, req *dept.MaxSortReq) (res *dept.MaxSortRes, err error) {
res = new(dept.MaxSortRes)
res.DeptMaxSortModel, err = service.AdminDept().MaxSort(ctx, &req.DeptMaxSortInp)
return
}
// View 获取指定信息
func (c *cDept) View(ctx context.Context, req *dept.ViewReq) (res *dept.ViewRes, err error) {
res = new(dept.ViewRes)
res.DeptViewModel, err = service.AdminDept().View(ctx, &req.DeptViewInp)
return
}
// List 查看列表
func (c *cDept) List(ctx context.Context, req *dept.ListReq) (res *dept.ListRes, err error) {
data, err := service.AdminDept().List(ctx, &req.DeptListInp)
if err != nil || data == nil {
return
}
res = (*dept.ListRes)(&data)
return
}
// Option 获取部门选项树
func (c *cDept) Option(ctx context.Context, req *dept.OptionReq) (res *dept.OptionRes, err error) {
list, totalCount, err := service.AdminDept().Option(ctx, &req.DeptOptionInp)
if err != nil {
return
}
res = new(dept.OptionRes)
res.DeptOptionModel = list
res.PageRes.Pack(req, totalCount)
return
}
// TreeOption 获取部门管理关系树选项
func (c *cDept) TreeOption(ctx context.Context, req *dept.TreeOptionReq) (res *dept.TreeOptionRes, err error) {
data, err := service.AdminDept().TreeOption(ctx)
res = (*dept.TreeOptionRes)(&data)
return
}
server/internal/controller/admin/admin/member.go
+145
View File
@@ -0,0 +1,145 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"hotgo/api/admin/member"
"hotgo/internal/library/contexts"
"hotgo/internal/model/input/adminin"
"hotgo/internal/service"
)
var (
Member = cMember{}
)
type cMember struct{}
// UpdateCash 修改代理商提现信息
func (c *cMember) UpdateCash(ctx context.Context, req *member.UpdateCashReq) (res *member.UpdateCashRes, err error) {
err = service.AdminMember().UpdateCash(ctx, &req.MemberUpdateCashInp)
return
}
// UpdateEmail 换绑邮箱
func (c *cMember) UpdateEmail(ctx context.Context, req *member.UpdateEmailReq) (res *member.UpdateEmailRes, err error) {
err = service.AdminMember().UpdateEmail(ctx, &req.MemberUpdateEmailInp)
return
}
// UpdateMobile 换绑手机号
func (c *cMember) UpdateMobile(ctx context.Context, req *member.UpdateMobileReq) (res *member.UpdateMobileRes, err error) {
err = service.AdminMember().UpdateMobile(ctx, &req.MemberUpdateMobileInp)
return
}
// UpdateProfile 更新用户资料
func (c *cMember) UpdateProfile(ctx context.Context, req *member.UpdateProfileReq) (res *member.UpdateProfileRes, err error) {
err = service.AdminMember().UpdateProfile(ctx, &req.MemberUpdateProfileInp)
return
}
// UpdatePwd 修改登录密码
func (c *cMember) UpdatePwd(ctx context.Context, req *member.UpdatePwdReq) (res *member.UpdatePwdRes, err error) {
var memberId = contexts.Get(ctx).User.Id
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
err = service.AdminMember().UpdatePwd(ctx, &adminin.MemberUpdatePwdInp{
Id: memberId,
OldPassword: req.OldPassword,
NewPassword: req.NewPassword,
})
return
}
// ResetPwd 重置密码
func (c *cMember) ResetPwd(ctx context.Context, req *member.ResetPwdReq) (res *member.ResetPwdRes, err error) {
err = service.AdminMember().ResetPwd(ctx, &req.MemberResetPwdInp)
return
}
// MemberInfo 登录用户信息
func (c *cMember) MemberInfo(ctx context.Context, _ *member.InfoReq) (res *member.InfoRes, err error) {
data, err := service.AdminMember().LoginMemberInfo(ctx)
if err != nil {
return
}
res = new(member.InfoRes)
res.LoginMemberInfoModel = data
return
}
// Delete 删除用户
func (c *cMember) Delete(ctx context.Context, req *member.DeleteReq) (res *member.DeleteRes, err error) {
err = service.AdminMember().Delete(ctx, &req.MemberDeleteInp)
return
}
// Edit 修改/新增用户
func (c *cMember) Edit(ctx context.Context, req *member.EditReq) (res *member.EditRes, err error) {
err = service.AdminMember().Edit(ctx, &req.MemberEditInp)
return
}
// View 获取指定用户信息
func (c *cMember) View(ctx context.Context, req *member.ViewReq) (res *member.ViewRes, err error) {
data, err := service.AdminMember().View(ctx, &req.MemberViewInp)
if err != nil {
return
}
res = new(member.ViewRes)
res.MemberViewModel = data
return
}
// List 查看用户列表
func (c *cMember) List(ctx context.Context, req *member.ListReq) (res *member.ListRes, err error) {
list, totalCount, err := service.AdminMember().List(ctx, &req.MemberListInp)
if err != nil {
return
}
res = new(member.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新用户状态
func (c *cMember) Status(ctx context.Context, req *member.StatusReq) (res *member.StatusRes, err error) {
err = service.AdminMember().Status(ctx, &req.MemberStatusInp)
return
}
// Select 获取可选的后台用户选项
func (c *cMember) Select(ctx context.Context, req *member.SelectReq) (res *member.SelectRes, err error) {
data, err := service.AdminMember().Select(ctx, &req.MemberSelectInp)
if err != nil {
return
}
res = (*member.SelectRes)(&data)
return
}
// AddBalance 增加用户余额
func (c *cMember) AddBalance(ctx context.Context, req *member.AddBalanceReq) (res *member.AddBalanceRes, err error) {
err = service.AdminMember().AddBalance(ctx, &req.MemberAddBalanceInp)
return
}
// AddIntegral 增加用户积分
func (c *cMember) AddIntegral(ctx context.Context, req *member.AddIntegralReq) (res *member.AddIntegralRes, err error) {
err = service.AdminMember().AddIntegral(ctx, &req.MemberAddIntegralInp)
return
}
server/internal/controller/admin/admin/menu.go
+37
View File
@@ -0,0 +1,37 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/api/admin/menu"
"hotgo/internal/service"
)
// Menu 菜单
var (
Menu = cMenu{}
)
type cMenu struct{}
// Delete 删除
func (c *cMenu) Delete(ctx context.Context, req *menu.DeleteReq) (res *menu.DeleteRes, err error) {
err = service.AdminMenu().Delete(ctx, &req.MenuDeleteInp)
return
}
// Edit 更新
func (c *cMenu) Edit(ctx context.Context, req *menu.EditReq) (res *menu.EditRes, err error) {
err = service.AdminMenu().Edit(ctx, &req.MenuEditInp)
return
}
// List 获取列表
func (c *cMenu) List(ctx context.Context, req *menu.ListReq) (res menu.ListRes, err error) {
res.MenuListModel, err = service.AdminMenu().List(ctx, &req.MenuListInp)
return
}
server/internal/controller/admin/admin/monitor.go
+243
View File
@@ -0,0 +1,243 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/text/gstr"
"hotgo/api/admin/monitor"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/form"
"hotgo/internal/service"
"hotgo/internal/websocket"
"hotgo/utility/simple"
"hotgo/utility/useragent"
"sort"
)
// Monitor 监控
var Monitor = cMonitor{
wsManager: websocket.Manager(),
}
type cMonitor struct {
wsManager *websocket.ClientManager
}
// UserOffline 下线用户
func (c *cMonitor) UserOffline(ctx context.Context, req *monitor.UserOfflineReq) (res *monitor.UserOfflineRes, err error) {
client := c.wsManager.GetClient(req.Id)
if client == nil {
err = gerror.New("客户端已离线")
return
}
simple.SafeGo(ctx, func(ctx context.Context) {
websocket.SendSuccess(client, "kick")
websocket.Close(client)
})
return
}
// UserOnlineList 获取用户在线列表
func (c *cMonitor) UserOnlineList(ctx context.Context, req *monitor.UserOnlineListReq) (res *monitor.UserOnlineListRes, err error) {
var (
clients []*monitor.UserOnlineModel
i int
)
if c.wsManager.GetClientsLen() == 0 {
return
}
for conn := range c.wsManager.GetClients() {
if conn.SendClose || conn.User == nil {
continue
}
if req.UserId > 0 && req.UserId != conn.User.Id {
continue
}
if req.Username != "" && req.Username != conn.User.Username {
continue
}
if req.IP != "" && !gstr.Contains(conn.IP, req.IP) {
continue
}
if len(req.FirstTime) == 2 && (conn.User.LoginAt.Before(req.FirstTime[0]) || conn.User.LoginAt.After(req.FirstTime[1])) {
continue
}
clients = append(clients, &monitor.UserOnlineModel{
ID: conn.ID,
IP: conn.IP,
Os: useragent.GetOs(conn.UserAgent),
Browser: useragent.GetBrowser(conn.UserAgent),
FirstTime: conn.User.LoginAt.Unix(),
HeartbeatTime: conn.HeartbeatTime,
App: conn.User.App,
UserId: conn.User.Id,
Username: conn.User.Username,
Avatar: conn.User.Avatar,
})
}
res = new(monitor.UserOnlineListRes)
res.PageRes.Pack(req, len(clients))
sort.Slice(clients, func(i, j int) bool {
if clients[i].FirstTime == clients[j].FirstTime {
return clients[i].ID < clients[j].ID
}
return clients[i].FirstTime < clients[j].FirstTime
})
_, perPage, offset := form.CalPage(req.Page, req.PerPage)
for k, v := range clients {
if k >= offset && i <= perPage {
if simple.IsDemo(ctx) {
v.IP = consts.DemoTips
}
res.List = append(res.List, v)
i++
}
}
return
}
// NetOnlineList 获取服务在线列表
func (c *cMonitor) NetOnlineList(ctx context.Context, req *monitor.NetOnlineListReq) (res *monitor.NetOnlineListRes, err error) {
var (
clients []*monitor.NetOnlineModel
i int
cols = dao.SysServeLicense.Columns()
serv = service.TCPServer().Instance()
models *entity.SysServeLicense
)
conns := serv.GetClients()
if len(conns) == 0 {
res = new(monitor.NetOnlineListRes)
res.PageRes.Pack(req, 0)
return
}
for _, conn := range conns {
v := &monitor.NetOnlineModel{
AuthMeta: conn.Auth,
Id: conn.CID,
IsAuth: conn.Auth != nil,
Addr: conn.RemoteAddr().String(),
Port: gstr.SubStrFromEx(conn.LocalAddr().String(), `:`),
FirstTime: conn.FirstTime,
HeartbeatTime: conn.Heartbeat,
Proto: "TCP",
}
if v.IsAuth {
if err = dao.SysServeLicense.Ctx(ctx).Where(cols.Appid, conn.Auth.AppId).Where(cols.Group, conn.Auth.Group).Scan(&models); err != nil {
return
}
if models == nil {
continue
}
v.LicenseId = models.Id
v.LicenseName = models.Name
v.LoginTimes = models.LoginTimes
v.Online = serv.GetAppIdOnline(models.Appid)
v.OnlineLimit = models.OnlineLimit
}
if req.Addr != "" && !gstr.Contains(v.Addr, req.Addr) {
continue
}
if req.Name != "" && !gstr.Contains(v.Name, req.Name) {
continue
}
if req.Group != "" && (!v.IsAuth || v.Group != req.Group) {
continue
}
if req.AppId != "" && (!v.IsAuth || v.AppId != req.AppId) {
continue
}
ft := gtime.New(conn.FirstTime)
if len(req.FirstTime) == 2 && (ft.Before(req.FirstTime[0]) || ft.After(req.FirstTime[1])) {
continue
}
clients = append(clients, v)
}
res = new(monitor.NetOnlineListRes)
res.PageRes.Pack(req, len(clients))
sort.Slice(clients, func(i, j int) bool {
return clients[i].Id > clients[j].Id
})
_, perPage, offset := form.CalPage(req.Page, req.PerPage)
for k, v := range clients {
if k >= offset && i <= perPage {
res.List = append(res.List, v)
i++
}
}
return
}
// NetOption 获取服务选项
func (c *cMonitor) NetOption(ctx context.Context, req *monitor.NetOptionReq) (res *monitor.NetOptionRes, err error) {
res = new(monitor.NetOptionRes)
for _, v := range service.TCPServer().Instance().GetRoutes() {
// 无需勾选的路由
disabled := false
if v.Id == "ServerLoginReq" || v.Id == "ServerHeartbeatReq" {
disabled = true
}
res.Routes = append(res.Routes, &monitor.RouteSelect{
Value: v.Id,
Label: v.Id,
Disabled: disabled,
IsRPC: v.IsRPC,
})
}
sort.Slice(res.Routes, func(i, j int) bool {
if res.Routes[i].IsRPC && !res.Routes[j].IsRPC {
return true
} else if !res.Routes[i].IsRPC && res.Routes[j].IsRPC {
return false
}
return res.Routes[i].Label < res.Routes[j].Label
})
return
}
// NetOffline 下线服务
func (c *cMonitor) NetOffline(ctx context.Context, req *monitor.NetOfflineReq) (res *monitor.NetOfflineRes, err error) {
conn := service.TCPServer().Instance().GetClientById(req.Id)
if conn == nil {
err = gerror.New("客户端不在线")
return
}
// 关闭连接
conn.Close()
return
}
server/internal/controller/admin/admin/notice.go
+127
View File
@@ -0,0 +1,127 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/api/admin/notice"
"hotgo/internal/consts"
"hotgo/internal/service"
)
var (
Notice = cNotice{}
)
type cNotice struct{}
// Delete 删除
func (c *cNotice) Delete(ctx context.Context, req *notice.DeleteReq) (res *notice.DeleteRes, err error) {
err = service.AdminNotice().Delete(ctx, &req.NoticeDeleteInp)
return
}
// Edit 更新
func (c *cNotice) Edit(ctx context.Context, req *notice.EditReq) (res *notice.EditRes, err error) {
err = service.AdminNotice().Edit(ctx, &req.NoticeEditInp)
return
}
// MaxSort 最大排序
func (c *cNotice) MaxSort(ctx context.Context, req *notice.MaxSortReq) (res *notice.MaxSortRes, err error) {
res = new(notice.MaxSortRes)
res.NoticeMaxSortModel, err = service.AdminNotice().MaxSort(ctx, &req.NoticeMaxSortInp)
return
}
// View 获取指定信息
func (c *cNotice) View(ctx context.Context, req *notice.ViewReq) (res *notice.ViewRes, err error) {
data, err := service.AdminNotice().View(ctx, &req.NoticeViewInp)
if err != nil {
return
}
res = new(notice.ViewRes)
res.NoticeViewModel = data
return
}
// List 查看列表
func (c *cNotice) List(ctx context.Context, req *notice.ListReq) (res *notice.ListRes, err error) {
list, totalCount, err := service.AdminNotice().List(ctx, &req.NoticeListInp)
if err != nil {
return nil, err
}
res = new(notice.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新状态
func (c *cNotice) Status(ctx context.Context, req *notice.StatusReq) (res *notice.StatusRes, err error) {
err = service.AdminNotice().Status(ctx, &req.NoticeStatusInp)
return
}
// Notify 更新通知
func (c *cNotice) Notify(ctx context.Context, req *notice.EditNotifyReq) (res *notice.EditNotifyRes, err error) {
req.Type = consts.NoticeTypeNotify
err = service.AdminNotice().Edit(ctx, &req.NoticeEditInp)
return
}
// Notice 更新公告
func (c *cNotice) Notice(ctx context.Context, req *notice.EditNoticeReq) (res *notice.EditNoticeRes, err error) {
req.Type = consts.NoticeTypeNotice
err = service.AdminNotice().Edit(ctx, &req.NoticeEditInp)
return
}
// Letter 更新私信
func (c *cNotice) Letter(ctx context.Context, req *notice.EditLetterReq) (res *notice.EditLetterRes, err error) {
req.Type = consts.NoticeTypeLetter
err = service.AdminNotice().Edit(ctx, &req.NoticeEditInp)
return
}
// UpRead 更新已读
func (c *cNotice) UpRead(ctx context.Context, req *notice.UpReadReq) (res *notice.UpReadRes, err error) {
err = service.AdminNotice().UpRead(ctx, &req.NoticeUpReadInp)
return
}
// PullMessages 拉取未读消息列表
func (c *cNotice) PullMessages(ctx context.Context, req *notice.PullMessagesReq) (res *notice.PullMessagesRes, err error) {
data, err := service.AdminNotice().PullMessages(ctx, &req.PullMessagesInp)
if err != nil {
return
}
res = new(notice.PullMessagesRes)
res.PullMessagesModel = data
return
}
// ReadAll 全部已读
func (c *cNotice) ReadAll(ctx context.Context, req *notice.ReadAllReq) (res *notice.ReadAllRes, err error) {
err = service.AdminNotice().ReadAll(ctx, &req.NoticeReadAllInp)
return
}
// MessageList 我的消息列表
func (c *cNotice) MessageList(ctx context.Context, req *notice.MessageListReq) (res *notice.MessageListRes, err error) {
list, totalCount, err := service.AdminNotice().MessageList(ctx, &req.NoticeMessageListInp)
if err != nil {
return
}
res = new(notice.MessageListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
server/internal/controller/admin/admin/order.go
+91
View File
@@ -0,0 +1,91 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/api/admin/order"
"hotgo/internal/service"
)
var (
Order = cOrder{}
)
type cOrder struct{}
// AcceptRefund 受理申请退款
func (c *cOrder) AcceptRefund(ctx context.Context, req *order.AcceptRefundReq) (res *order.AcceptRefundRes, err error) {
err = service.AdminOrder().AcceptRefund(ctx, &req.OrderAcceptRefundInp)
return
}
// ApplyRefund 申请退款
func (c *cOrder) ApplyRefund(ctx context.Context, req *order.ApplyRefundReq) (res *order.ApplyRefundRes, err error) {
err = service.AdminOrder().ApplyRefund(ctx, &req.OrderApplyRefundInp)
return
}
// Create 创建充值订单
func (c *cOrder) Create(ctx context.Context, req *order.CreateReq) (res *order.CreateRes, err error) {
data, err := service.AdminOrder().Create(ctx, &req.OrderCreateInp)
if err != nil {
return
}
res = new(order.CreateRes)
res.OrderCreateModel = data
return
}
// List 查看充值订单列表
func (c *cOrder) List(ctx context.Context, req *order.ListReq) (res *order.ListRes, err error) {
list, totalCount, err := service.AdminOrder().List(ctx, &req.OrderListInp)
if err != nil {
return
}
res = new(order.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Export 导出充值订单列表
func (c *cOrder) Export(ctx context.Context, req *order.ExportReq) (res *order.ExportRes, err error) {
err = service.AdminOrder().Export(ctx, &req.OrderListInp)
return
}
// Edit 更新充值订单
func (c *cOrder) Edit(ctx context.Context, req *order.EditReq) (res *order.EditRes, err error) {
err = service.AdminOrder().Edit(ctx, &req.OrderEditInp)
return
}
// View 获取指定充值订单信息
func (c *cOrder) View(ctx context.Context, req *order.ViewReq) (res *order.ViewRes, err error) {
data, err := service.AdminOrder().View(ctx, &req.OrderViewInp)
if err != nil {
return
}
res = new(order.ViewRes)
res.OrderViewModel = data
return
}
// Delete 删除充值订单
func (c *cOrder) Delete(ctx context.Context, req *order.DeleteReq) (res *order.DeleteRes, err error) {
err = service.AdminOrder().Delete(ctx, &req.OrderDeleteInp)
return
}
// Status 更新充值订单状态
func (c *cOrder) Status(ctx context.Context, req *order.StatusReq) (res *order.StatusRes, err error) {
err = service.AdminOrder().Status(ctx, &req.OrderStatusInp)
return
}
server/internal/controller/admin/admin/post.go
+67
View File
@@ -0,0 +1,67 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/api/admin/post"
"hotgo/internal/service"
)
// Post 岗位
var Post = cPost{}
type cPost struct{}
// Delete 删除
func (c *cPost) Delete(ctx context.Context, req *post.DeleteReq) (res *post.DeleteRes, err error) {
err = service.AdminPost().Delete(ctx, &req.PostDeleteInp)
return
}
// Edit 修改/新增
func (c *cPost) Edit(ctx context.Context, req *post.EditReq) (res *post.EditRes, err error) {
err = service.AdminPost().Edit(ctx, &req.PostEditInp)
return
}
// MaxSort 最大排序
func (c *cPost) MaxSort(ctx context.Context, req *post.MaxSortReq) (res *post.MaxSortRes, err error) {
res = new(post.MaxSortRes)
res.PostMaxSortModel, err = service.AdminPost().MaxSort(ctx, &req.PostMaxSortInp)
return
}
// View 获取指定信息
func (c *cPost) View(ctx context.Context, req *post.ViewReq) (res *post.ViewRes, err error) {
data, err := service.AdminPost().View(ctx, &req.PostViewInp)
if err != nil {
return
}
res = new(post.ViewRes)
res.PostViewModel = data
return
}
// List 获取列表
func (c *cPost) List(ctx context.Context, req *post.ListReq) (res *post.ListRes, err error) {
list, totalCount, err := service.AdminPost().List(ctx, &req.PostListInp)
if err != nil {
return
}
res = new(post.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新状态
func (c *cPost) Status(ctx context.Context, req *post.StatusReq) (res *post.StatusRes, err error) {
err = service.AdminPost().Status(ctx, &req.PostStatusInp)
return
}
server/internal/controller/admin/admin/role.go
+81
View File
@@ -0,0 +1,81 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/api/admin/role"
"hotgo/internal/consts"
"hotgo/internal/library/contexts"
"hotgo/internal/service"
)
var (
Role = cRole{}
)
type cRole struct{}
// List 获取列表
func (c *cRole) List(ctx context.Context, req *role.ListReq) (res *role.ListRes, err error) {
list, totalCount, err := service.AdminRole().List(ctx, &req.RoleListInp)
if err != nil {
return
}
res = new(role.ListRes)
res.RoleListModel = list
res.PageRes.Pack(req, totalCount)
return
}
// Edit 修改角色
func (c *cRole) Edit(ctx context.Context, req *role.EditReq) (res *role.EditRes, err error) {
err = service.AdminRole().Edit(ctx, &req.RoleEditInp)
return
}
// Delete 删除
func (c *cRole) Delete(ctx context.Context, req *role.DeleteReq) (res *role.DeleteRes, err error) {
err = service.AdminRole().Delete(ctx, &req.RoleDeleteInp)
return
}
// Dynamic 动态路由
func (c *cRole) Dynamic(ctx context.Context, _ *role.DynamicReq) (res *role.DynamicRes, err error) {
return service.AdminMenu().GetMenuList(ctx, contexts.GetUserId(ctx))
}
// GetPermissions 获取指定角色权限
func (c *cRole) GetPermissions(ctx context.Context, req *role.GetPermissionsReq) (res *role.GetPermissionsRes, err error) {
data, err := service.AdminRole().GetPermissions(ctx, &req.GetPermissionsInp)
if err != nil {
return
}
res = new(role.GetPermissionsRes)
res.GetPermissionsModel = data
return
}
// UpdatePermissions 修改角色菜单权限
func (c *cRole) UpdatePermissions(ctx context.Context, req *role.UpdatePermissionsReq) (res *role.UpdatePermissionsRes, err error) {
err = service.AdminRole().UpdatePermissions(ctx, &req.UpdatePermissionsInp)
return
}
// DataScopeSelect 获取数据权限选项
func (c *cRole) DataScopeSelect(_ context.Context, _ *role.DataScopeSelectReq) (res *role.DataScopeSelectRes, err error) {
res = new(role.DataScopeSelectRes)
res.List = consts.DataScopeSelect
return
}
// DataScopeEdit 获取数据权限选项
func (c *cRole) DataScopeEdit(ctx context.Context, req *role.DataScopeEditReq) (res *role.DataScopeEditRes, err error) {
err = service.AdminRole().DataScopeEdit(ctx, &req.DataScopeEditInp)
return
}
server/internal/controller/admin/common/console.go
+51
View File
@@ -0,0 +1,51 @@
// Package common
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package common
import (
"context"
"hotgo/api/admin/common"
"hotgo/internal/service"
)
var Console = cConsole{}
type cConsole struct{}
// Stat 综合数据统计
func (c *cConsole) Stat(_ context.Context, _ *common.ConsoleStatReq) (res *common.ConsoleStatRes, err error) {
res = new(common.ConsoleStatRes)
// 此处均为模拟数据，可以根据实际业务情况替换成真实数据
res.Visits.DayVisits = 12010
res.Visits.Rise = 13501
res.Visits.Decline = 10502
res.Visits.Amount = 10403
res.Saleroom.WeekSaleroom = 20501
res.Saleroom.Amount = 21002
res.Saleroom.Degree = 83.66
res.OrderLarge.WeekLarge = 39901
res.OrderLarge.Rise = 31012
res.OrderLarge.Decline = 30603
res.OrderLarge.Amount = 36084
res.Volume.WeekLarge = 40021
res.Volume.Rise = 40202
res.Volume.Decline = 45003
res.Volume.Amount = 49004
return
}
func (c *cConsole) Summary(ctx context.Context, req *common.DashboardSummaryReq) (res *common.DashboardSummaryRes, err error) {
data, err := service.SysDashboard().Summary(ctx, &req.DashboardSummaryInp)
if err != nil {
return nil, err
}
return &common.DashboardSummaryRes{DashboardSummaryModel: data}, nil
}
server/internal/controller/admin/common/ems.go
+75
View File
@@ -0,0 +1,75 @@
// Package common
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package common
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"hotgo/api/admin/common"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/contexts"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var Ems = new(cEms)
type cEms struct{}
// SendTest 发送测试邮件
func (c *cEms) SendTest(ctx context.Context, req *common.SendTestEmailReq) (res *common.SendTestEmailRes, err error) {
err = service.SysEmsLog().Send(ctx, &sysin.SendEmsInp{
Event: consts.EmsTemplateText,
Email: req.To,
Content: `
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="iso-8859-15">
<title>这是一封来自HotGo的测试邮件</title>
</head>
<body>
这是您通过HotGo后台发送的测试邮件。当你收到这封邮件的时候，说明已经联调成功了，恭喜你！
</body>
</html>`,
})
return
}
// SendBindEms 发送换绑邮件
func (c *cEms) SendBindEms(ctx context.Context, _ *common.SendBindEmsReq) (res *common.SendBindEmsRes, err error) {
var (
memberId = contexts.GetUserId(ctx)
models *entity.AdminMember
)
if memberId <= 0 {
err = gerror.New("用户身份异常，请重新登录！")
return
}
if err = dao.AdminMember.Ctx(ctx).Fields(dao.AdminMember.Columns().Email).Where(dao.AdminMember.Columns().Id, memberId).Scan(&models); err != nil {
return
}
if models == nil {
err = gerror.New("用户信息不存在")
return
}
if models.Email == "" {
err = gerror.New("未绑定邮箱无需发送")
return
}
err = service.SysEmsLog().Send(ctx, &sysin.SendEmsInp{
Event: consts.EmsTemplateBind,
Email: models.Email,
})
return
}
server/internal/controller/admin/common/site.go
+155
View File
@@ -0,0 +1,155 @@
// Package common
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package common
import (
"context"
"hotgo/api/admin/common"
"hotgo/internal/consts"
"hotgo/internal/library/captcha"
"hotgo/internal/library/token"
"hotgo/internal/service"
"hotgo/utility/validate"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/net/ghttp"
"github.com/gogf/gf/v2/text/gstr"
"github.com/gogf/gf/v2/util/gconv"
"github.com/gogf/gf/v2/util/gmode"
)
var Site = cSite{}
type cSite struct{}
// Ping ping
func (c *cSite) Ping(_ context.Context, _ *common.SitePingReq) (res *common.SitePingRes, err error) {
return
}
// Config 获取配置
func (c *cSite) Config(ctx context.Context, _ *common.SiteConfigReq) (res *common.SiteConfigRes, err error) {
request := ghttp.RequestFromCtx(ctx)
res = &common.SiteConfigRes{
Version: consts.VersionApp,
WsAddr: c.getWsAddr(ctx, request),
Domain: c.getDomain(ctx, request),
Mode: gmode.Mode(),
}
return
}
func (c *cSite) getWsAddr(ctx context.Context, request *ghttp.Request) string {
// 如果是本地IP访问，则认为是调试模式，走实际请求地址，否则走配置中的地址
// 尝试读取hostname，兼容本地运行模式
ip := ghttp.RequestFromCtx(ctx).GetHeader("hostname")
if len(ip) == 0 {
ip = ghttp.RequestFromCtx(ctx).GetHost()
}
if validate.IsLocalIPAddr(ip) {
return "ws://" + ip + ":" + gstr.StrEx(request.Host, ":") + g.Cfg().MustGet(ctx, "router.websocket.prefix").String()
}
basic, err := service.SysConfig().GetBasic(ctx)
if err != nil || basic == nil {
return ""
}
return basic.WsAddr
}
func (c *cSite) getDomain(ctx context.Context, request *ghttp.Request) string {
// 如果是本地IP访问，则认为是调试模式，走实际请求地址，否则走配置中的地址
// 尝试读取hostname，兼容本地运行模式
ip := ghttp.RequestFromCtx(ctx).GetHeader("hostname")
if len(ip) == 0 {
ip = ghttp.RequestFromCtx(ctx).GetHost()
}
if validate.IsLocalIPAddr(ip) {
return "http://" + ip + ":" + gstr.StrEx(request.Host, ":")
}
basic, err := service.SysConfig().GetBasic(ctx)
if err != nil || basic == nil {
return ""
}
return basic.Domain
}
// LoginConfig 登录配置
func (c *cSite) LoginConfig(ctx context.Context, _ *common.SiteLoginConfigReq) (res *common.SiteLoginConfigRes, err error) {
res = new(common.SiteLoginConfigRes)
login, err := service.SysConfig().GetLogin(ctx)
if err != nil {
return
}
res.LoginConfig = login
res.I18nSwitch = g.Cfg().MustGet(ctx, "system.i18n.switch", true).Bool()
res.DefaultLanguage = g.Cfg().MustGet(ctx, "system.i18n.defaultLanguage", consts.SysDefaultLanguage).String()
res.ProjectName = "企业办公管理系统"
return
}
// Captcha 登录验证码
func (c *cSite) Captcha(ctx context.Context, _ *common.LoginCaptchaReq) (res *common.LoginCaptchaRes, err error) {
loginConf, err := service.SysConfig().GetLogin(ctx)
if err != nil {
return
}
cid, base64 := captcha.Generate(ctx, loginConf.CaptchaType)
res = &common.LoginCaptchaRes{Cid: cid, Base64: base64}
return
}
// Register 账号注册
func (c *cSite) Register(ctx context.Context, req *common.RegisterReq) (res *common.RegisterRes, err error) {
err = service.AdminSite().Register(ctx, &req.RegisterInp)
return
}
// AccountLogin 账号登录
func (c *cSite) AccountLogin(ctx context.Context, req *common.AccountLoginReq) (res *common.AccountLoginRes, err error) {
login, err := service.SysConfig().GetLogin(ctx)
if err != nil {
return
}
if !req.IsLock && login.CaptchaSwitch == consts.StatusEnabled {
// 校验 验证码
if !captcha.Verify(req.Cid, req.Code) {
err = gerror.New("验证码错误")
return
}
}
model, err := service.AdminSite().AccountLogin(ctx, &req.AccountLoginInp)
if err != nil {
return
}
err = gconv.Scan(model, &res)
return
}
// MobileLogin 手机号登录
func (c *cSite) MobileLogin(ctx context.Context, req *common.MobileLoginReq) (res *common.MobileLoginRes, err error) {
model, err := service.AdminSite().MobileLogin(ctx, &req.MobileLoginInp)
if err != nil {
return
}
err = gconv.Scan(model, &res)
return
}
// Logout 注销登录
func (c *cSite) Logout(ctx context.Context, _ *common.LoginLogoutReq) (res *common.LoginLogoutRes, err error) {
err = token.Logout(ghttp.RequestFromCtx(ctx))
return
}
server/internal/controller/admin/common/sms.go
+67
View File
@@ -0,0 +1,67 @@
// Package common
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package common
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"hotgo/api/admin/common"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/contexts"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var Sms = new(cSms)
type cSms struct{}
// SendTest 发送测试短信
func (c *cSms) SendTest(ctx context.Context, req *common.SendTestSmsReq) (res *common.SendTestSmsRes, err error) {
err = service.SysSmsLog().SendCode(ctx, &req.SendCodeInp)
return
}
// SendBindSms 发送换绑短信
func (c *cSms) SendBindSms(ctx context.Context, _ *common.SendBindSmsReq) (res *common.SendBindSmsRes, err error) {
var (
memberId = contexts.GetUserId(ctx)
models *entity.AdminMember
)
if memberId <= 0 {
err = gerror.New("用户身份异常，请重新登录！")
return
}
if err = dao.AdminMember.Ctx(ctx).Fields(dao.AdminMember.Columns().Mobile).Where(dao.AdminMember.Columns().Id, memberId).Scan(&models); err != nil {
return
}
if models == nil {
err = gerror.New("用户信息不存在")
return
}
if models.Mobile == "" {
err = gerror.New("未绑定手机号无需发送")
return
}
err = service.SysSmsLog().SendCode(ctx, &sysin.SendCodeInp{
Event: consts.SmsTemplateBind,
Mobile: models.Mobile,
})
return
}
// SendSms 发送短信
func (c *cSms) SendSms(ctx context.Context, req *common.SendSmsReq) (res *common.SendSmsRes, err error) {
err = service.SysSmsLog().SendCode(ctx, &req.SendCodeInp)
return
}
server/internal/controller/admin/common/upload.go
+66
View File
@@ -0,0 +1,66 @@
// Package common
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package common
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"hotgo/api/admin/common"
"hotgo/internal/library/storager"
"hotgo/internal/service"
"hotgo/utility/validate"
)
var Upload = new(cUpload)
type cUpload struct{}
// UploadFile 上传文件
func (c *cUpload) UploadFile(ctx context.Context, _ *common.UploadFileReq) (res common.UploadFileRes, err error) {
r := g.RequestFromCtx(ctx)
uploadType := r.Header.Get("uploadType")
if uploadType != "default" && !validate.InSlice(storager.KindSlice, uploadType) {
err = gerror.New("上传类型是无效的")
return
}
file := r.GetUploadFile("file")
if file == nil {
err = gerror.New("没有找到上传的文件")
return
}
return service.CommonUpload().UploadFile(ctx, uploadType, file)
}
// CheckMultipart 检查文件分片
func (c *cUpload) CheckMultipart(ctx context.Context, req *common.CheckMultipartReq) (res *common.CheckMultipartRes, err error) {
data, err := service.CommonUpload().CheckMultipart(ctx, &req.CheckMultipartInp)
if err != nil {
return nil, err
}
res = new(common.CheckMultipartRes)
res.CheckMultipartModel = data
return
}
// UploadPart 上传分片
func (c *cUpload) UploadPart(ctx context.Context, req *common.UploadPartReq) (res *common.UploadPartRes, err error) {
data, err := service.CommonUpload().UploadPart(ctx, &req.UploadPartInp)
if err != nil {
return nil, err
}
res = new(common.UploadPartRes)
res.UploadPartModel = data
return
}
// ImageTransferStorage 图片链接转存
func (c *cUpload) ImageTransferStorage(ctx context.Context, req *common.ImageTransferStorageReq) (res *common.ImageTransferStorageRes, err error) {
res = new(common.ImageTransferStorageRes)
res.ImageTransferStorageModel, err = service.CommonUpload().ImageTransferStorage(ctx, &req.ImageTransferStorageInp)
return
}
server/internal/controller/admin/common/wechat.go
+28
View File
@@ -0,0 +1,28 @@
// Package common
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package common
import (
"context"
"hotgo/api/admin/common"
"hotgo/internal/service"
)
var (
Wechat = cWechat{}
)
type cWechat struct{}
func (c *cWechat) Authorize(ctx context.Context, req *common.WechatAuthorizeReq) (res *common.WechatAuthorizeRes, err error) {
_, err = service.CommonWechat().Authorize(ctx, &req.WechatAuthorizeInp)
return
}
func (c *cWechat) AuthorizeCall(ctx context.Context, req *common.WechatAuthorizeCallReq) (res *common.WechatAuthorizeCallRes, err error) {
_, err = service.CommonWechat().AuthorizeCall(ctx, &req.WechatAuthorizeCallInp)
return
}
server/internal/controller/admin/pay/refund.go
+39
View File
@@ -0,0 +1,39 @@
// Package pay
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.5.3
// @AutoGenerate Date 2023-04-15 15:59:58
package pay
import (
"context"
"hotgo/api/admin/pay"
"hotgo/internal/service"
)
var (
Refund = cRefund{}
)
type cRefund struct{}
// List 查看交易退款列表
func (c *cRefund) List(ctx context.Context, req *pay.RefundListReq) (res *pay.RefundListRes, err error) {
list, totalCount, err := service.PayRefund().List(ctx, &req.PayRefundListInp)
if err != nil {
return
}
res = new(pay.RefundListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Export 导出交易退款列表
func (c *cRefund) Export(ctx context.Context, req *pay.RefundExportReq) (res *pay.RefundExportRes, err error) {
err = service.PayRefund().Export(ctx, &req.PayRefundListInp)
return
}
server/internal/controller/admin/sys/addons.go
+61
View File
@@ -0,0 +1,61 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/addons"
"hotgo/internal/service"
)
var (
Addons = cAddons{}
)
type cAddons struct{}
// List 查看列表
func (c *cAddons) List(ctx context.Context, req *addons.ListReq) (res *addons.ListRes, err error) {
list, totalCount, err := service.SysAddons().List(ctx, &req.AddonsListInp)
if err != nil {
return
}
res = new(addons.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Build 生成预览
func (c *cAddons) Build(ctx context.Context, req *addons.BuildReq) (res *addons.BuildRes, err error) {
err = service.SysAddons().Build(ctx, &req.AddonsBuildInp)
return
}
// Install 安装模块
func (c *cAddons) Install(ctx context.Context, req *addons.InstallReq) (res *addons.InstallRes, err error) {
if err = service.SysAddons().Install(ctx, &req.AddonsInstallInp); err != nil {
return
}
return
}
// Upgrade 更新模块
func (c *cAddons) Upgrade(ctx context.Context, req *addons.UpgradeReq) (res *addons.UpgradeRes, err error) {
if err = service.SysAddons().Upgrade(ctx, &req.AddonsUpgradeInp); err != nil {
return
}
return
}
// UnInstall 卸载模块
func (c *cAddons) UnInstall(ctx context.Context, req *addons.UnInstallReq) (res *addons.UnInstallRes, err error) {
if err = service.SysAddons().UnInstall(ctx, &req.AddonsUnInstallInp); err != nil {
return
}
return
}
server/internal/controller/admin/sys/app_member.go
+157
View File
@@ -0,0 +1,157 @@
package sys
import (
"context"
"hotgo/api/admin/appmember"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var AppMember = cAppMember{}
type cAppMember struct{}
func (c *cAppMember) List(ctx context.Context, req *appmember.ListReq) (res *appmember.ListRes, err error) {
list, total, err := service.SysAppMember().List(ctx, &req.AppMemberListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.AppMemberListModel{}
}
res = new(appmember.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cAppMember) View(ctx context.Context, req *appmember.ViewReq) (res *appmember.ViewRes, err error) {
data, err := service.SysAppMember().View(ctx, &req.AppMemberViewInp)
if err != nil {
return
}
res = &appmember.ViewRes{AppMemberViewModel: data}
return
}
func (c *cAppMember) Edit(ctx context.Context, req *appmember.EditReq) (*appmember.EditRes, error) {
return &appmember.EditRes{}, service.SysAppMember().Edit(ctx, &req.AppMemberEditInp)
}
func (c *cAppMember) Delete(ctx context.Context, req *appmember.DeleteReq) (*appmember.DeleteRes, error) {
return &appmember.DeleteRes{}, service.SysAppMember().Delete(ctx, &req.AppMemberDeleteInp)
}
func (c *cAppMember) AutoDispatch(ctx context.Context, req *appmember.AutoDispatchReq) (*appmember.AutoDispatchRes, error) {
return &appmember.AutoDispatchRes{}, service.SysAppMember().AutoDispatch(ctx, &req.AppMemberAutoDispatchInp)
}
func (c *cAppMember) Category(ctx context.Context, req *appmember.CategoryReq) (*appmember.CategoryRes, error) {
return &appmember.CategoryRes{}, service.SysAppMember().Category(ctx, &req.AppMemberCategoryInp)
}
func (c *cAppMember) PaymentList(ctx context.Context, req *appmember.PaymentListReq) (*appmember.PaymentListRes, error) {
list, err := service.SysAppMember().PaymentList(ctx, &req.AppMemberPaymentListInp)
if list == nil {
list = []*sysin.AppMemberPaymentModel{}
}
return &appmember.PaymentListRes{List: list}, err
}
func (c *cAppMember) PaymentEdit(ctx context.Context, req *appmember.PaymentEditReq) (*appmember.PaymentEditRes, error) {
return &appmember.PaymentEditRes{}, service.SysAppMember().PaymentEdit(ctx, &req.AppMemberPaymentEditInp)
}
func (c *cAppMember) PaymentDelete(ctx context.Context, req *appmember.PaymentDeleteReq) (*appmember.PaymentDeleteRes, error) {
return &appmember.PaymentDeleteRes{}, service.SysAppMember().PaymentDelete(ctx, &req.AppMemberPaymentDeleteInp)
}
func (c *cAppMember) AddressList(ctx context.Context, req *appmember.AddressListReq) (*appmember.AddressListRes, error) {
list, err := service.SysAppMember().AddressList(ctx, &req.AppMemberAddressListInp)
if list == nil {
list = []*sysin.AppMemberAddressModel{}
}
return &appmember.AddressListRes{List: list}, err
}
func (c *cAppMember) AddressEdit(ctx context.Context, req *appmember.AddressEditReq) (*appmember.AddressEditRes, error) {
return &appmember.AddressEditRes{}, service.SysAppMember().AddressEdit(ctx, &req.AppMemberAddressEditInp)
}
func (c *cAppMember) AddressDelete(ctx context.Context, req *appmember.AddressDeleteReq) (*appmember.AddressDeleteRes, error) {
return &appmember.AddressDeleteRes{}, service.SysAppMember().AddressDelete(ctx, &req.AppMemberAddressDeleteInp)
}
func (c *cAppMember) Sensitive(ctx context.Context, req *appmember.SensitiveReq) (res *appmember.SensitiveRes, err error) {
data, err := service.SysAppMember().Sensitive(ctx, &req.AppMemberSensitiveInp)
if err != nil {
return
}
return &appmember.SensitiveRes{AppMemberSensitiveModel: data}, nil
}
func (c *cAppMember) Team(ctx context.Context, req *appmember.TeamReq) (res *appmember.TeamRes, err error) {
list, total, err := service.SysAppMember().Team(ctx, &req.AppMemberTeamInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.AppMemberTeamModel{}
}
res = new(appmember.TeamRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cAppMember) StatusRequest(ctx context.Context, req *appmember.StatusRequestReq) (res *appmember.StatusRequestRes, err error) {
data, err := service.SysAppMember().StatusRequest(ctx, &req.AppMemberStatusRequestInp)
if err != nil {
return
}
return &appmember.StatusRequestRes{AppMemberApprovalModel: data}, nil
}
func (c *cAppMember) StatusExecute(ctx context.Context, req *appmember.StatusExecuteReq) (*appmember.StatusExecuteRes, error) {
return &appmember.StatusExecuteRes{}, service.SysAppMember().StatusExecute(ctx, &req.AppMemberStatusExecuteInp)
}
func (c *cAppMember) WalletList(ctx context.Context, req *appmember.WalletListReq) (res *appmember.WalletListRes, err error) {
list, total, err := service.SysAppMember().WalletList(ctx, &req.WalletAdjustmentListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.WalletAdjustmentListModel{}
}
res = new(appmember.WalletListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cAppMember) LedgerList(ctx context.Context, req *appmember.LedgerListReq) (res *appmember.LedgerListRes, err error) {
list, total, err := service.SysAppMember().LedgerList(ctx, &req.WalletLedgerListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.WalletLedgerListModel{}
}
res = new(appmember.LedgerListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cAppMember) WalletRequest(ctx context.Context, req *appmember.WalletRequestReq) (res *appmember.WalletRequestRes, err error) {
data, err := service.SysAppMember().WalletRequest(ctx, &req.WalletAdjustmentRequestInp)
if err != nil {
return
}
return &appmember.WalletRequestRes{AppMemberApprovalModel: data}, nil
}
func (c *cAppMember) WalletExecute(ctx context.Context, req *appmember.WalletExecuteReq) (*appmember.WalletExecuteRes, error) {
return &appmember.WalletExecuteRes{}, service.SysAppMember().WalletExecute(ctx, &req.WalletAdjustmentExecuteInp)
}
func (c *cAppMember) NoticeList(ctx context.Context, req *appmember.NoticeListReq) (res *appmember.NoticeListRes, err error) {
list, total, err := service.SysAppMember().NoticeList(ctx, &req.MemberNoticeListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.MemberNoticeListModel{}
}
res = new(appmember.NoticeListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cAppMember) NoticeEdit(ctx context.Context, req *appmember.NoticeEditReq) (*appmember.NoticeEditRes, error) {
return &appmember.NoticeEditRes{}, service.SysAppMember().NoticeEdit(ctx, &req.MemberNoticeEditInp)
}
func (c *cAppMember) NoticeRevoke(ctx context.Context, req *appmember.NoticeRevokeReq) (*appmember.NoticeRevokeRes, error) {
return &appmember.NoticeRevokeRes{}, service.SysAppMember().NoticeRevoke(ctx, &req.MemberNoticeRevokeInp)
}
server/internal/controller/admin/sys/approval.go
+64
View File
@@ -0,0 +1,64 @@
package sys
import (
"context"
"hotgo/api/admin/approval"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var Approval = cApproval{}
type cApproval struct{}
func (c *cApproval) List(ctx context.Context, req *approval.ListReq) (res *approval.ListRes, err error) {
list, totalCount, err := service.SysApproval().List(ctx, &req.ApprovalListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.ApprovalListModel{}
}
res = new(approval.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
func (c *cApproval) View(ctx context.Context, req *approval.ViewReq) (res *approval.ViewRes, err error) {
data, err := service.SysApproval().View(ctx, &req.ApprovalViewInp)
if err != nil {
return nil, err
}
res = &approval.ViewRes{ApprovalViewModel: data}
return
}
func (c *cApproval) Create(ctx context.Context, req *approval.CreateReq) (res *approval.CreateRes, err error) {
data, err := service.SysApproval().Create(ctx, &req.ApprovalCreateInp)
if err != nil {
return nil, err
}
res = &approval.CreateRes{ApprovalCreateModel: data}
return
}
func (c *cApproval) Submit(ctx context.Context, req *approval.SubmitReq) (res *approval.SubmitRes, err error) {
err = service.SysApproval().Submit(ctx, &req.ApprovalSubmitInp)
return
}
func (c *cApproval) Approve(ctx context.Context, req *approval.ApproveReq) (res *approval.ApproveRes, err error) {
err = service.SysApproval().Approve(ctx, &req.ApprovalDecisionInp)
return
}
func (c *cApproval) Reject(ctx context.Context, req *approval.RejectReq) (res *approval.RejectRes, err error) {
err = service.SysApproval().Reject(ctx, &req.ApprovalDecisionInp)
return
}
func (c *cApproval) Cancel(ctx context.Context, req *approval.CancelReq) (res *approval.CancelRes, err error) {
err = service.SysApproval().Cancel(ctx, &req.ApprovalCancelInp)
return
}
server/internal/controller/admin/sys/attachment.go
+55
View File
@@ -0,0 +1,55 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/attachment"
"hotgo/internal/service"
)
var (
Attachment = cAttachment{}
)
type cAttachment struct{}
// Delete 删除附件
func (c *cAttachment) Delete(ctx context.Context, req *attachment.DeleteReq) (res *attachment.DeleteRes, err error) {
err = service.SysAttachment().Delete(ctx, &req.AttachmentDeleteInp)
return
}
// View 获取指定附件信息
func (c *cAttachment) View(ctx context.Context, req *attachment.ViewReq) (res *attachment.ViewRes, err error) {
data, err := service.SysAttachment().View(ctx, &req.AttachmentViewInp)
if err != nil {
return
}
res = new(attachment.ViewRes)
res.AttachmentViewModel = data
return
}
// List 查看附件列表
func (c *cAttachment) List(ctx context.Context, req *attachment.ListReq) (res *attachment.ListRes, err error) {
list, totalCount, err := service.SysAttachment().List(ctx, &req.AttachmentListInp)
if err != nil {
return
}
res = new(attachment.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// ClearKind 清空上传类型
func (c *cAttachment) ClearKind(ctx context.Context, req *attachment.ClearKindReq) (res *attachment.ClearKindRes, err error) {
err = service.SysAttachment().ClearKind(ctx, &req.AttachmentClearKindInp)
return
}
server/internal/controller/admin/sys/biz_audit.go
+34
View File
@@ -0,0 +1,34 @@
package sys
import (
"context"
"hotgo/api/admin/bizaudit"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var BizAudit = cBizAudit{}
type cBizAudit struct{}
func (c *cBizAudit) List(ctx context.Context, req *bizaudit.ListReq) (res *bizaudit.ListRes, err error) {
list, totalCount, err := service.SysBizAudit().List(ctx, &req.BizAuditListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.BizAuditListModel{}
}
res = new(bizaudit.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
func (c *cBizAudit) View(ctx context.Context, req *bizaudit.ViewReq) (res *bizaudit.ViewRes, err error) {
data, err := service.SysBizAudit().View(ctx, &req.BizAuditViewInp)
if err != nil {
return nil, err
}
return &bizaudit.ViewRes{BizAuditViewModel: data}, nil
}
server/internal/controller/admin/sys/blacklist.go
+61
View File
@@ -0,0 +1,61 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/blacklist"
"hotgo/internal/service"
)
var (
Blacklist = cBlacklist{}
)
type cBlacklist struct{}
// Delete 删除
func (c *cBlacklist) Delete(ctx context.Context, req *blacklist.DeleteReq) (res *blacklist.DeleteRes, err error) {
err = service.SysBlacklist().Delete(ctx, &req.BlacklistDeleteInp)
return
}
// Edit 更新
func (c *cBlacklist) Edit(ctx context.Context, req *blacklist.EditReq) (res *blacklist.EditRes, err error) {
err = service.SysBlacklist().Edit(ctx, &req.BlacklistEditInp)
return
}
// View 获取指定信息
func (c *cBlacklist) View(ctx context.Context, req *blacklist.ViewReq) (res *blacklist.ViewRes, err error) {
data, err := service.SysBlacklist().View(ctx, &req.BlacklistViewInp)
if err != nil {
return
}
res = new(blacklist.ViewRes)
res.BlacklistViewModel = data
return
}
// List 查看列表
func (c *cBlacklist) List(ctx context.Context, req *blacklist.ListReq) (res *blacklist.ListRes, err error) {
list, totalCount, err := service.SysBlacklist().List(ctx, &req.BlacklistListInp)
if err != nil {
return
}
res = new(blacklist.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新黑名单状态
func (c *cBlacklist) Status(ctx context.Context, req *blacklist.StatusReq) (res *blacklist.StatusRes, err error) {
err = service.SysBlacklist().Status(ctx, &req.BlacklistStatusInp)
return
}
server/internal/controller/admin/sys/config.go
+53
View File
@@ -0,0 +1,53 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/config"
"hotgo/internal/consts"
"hotgo/internal/model/input/form"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var (
Config = cConfig{}
)
type cConfig struct{}
// GetConfig 获取指定分组的配置
func (c *cConfig) GetConfig(ctx context.Context, req *config.GetReq) (res *config.GetRes, err error) {
res = new(config.GetRes)
res.GetConfigModel, err = service.SysConfig().GetConfigByGroup(ctx, &req.GetConfigInp)
return
}
// UpdateConfig 更新指定分组的配置
func (c *cConfig) UpdateConfig(ctx context.Context, req *config.UpdateReq) (res *config.UpdateRes, err error) {
err = service.SysConfig().UpdateConfigByGroup(ctx, &req.UpdateConfigInp)
return
}
// TypeSelect 数据类型选项
func (c *cConfig) TypeSelect(_ context.Context, _ *config.TypeSelectReq) (res config.TypeSelectRes, err error) {
for _, v := range consts.ConfigTypes {
res = append(res, form.Select{
Value: v,
Name: v,
Label: v,
})
}
return
}
// GetCash 获取提现的配置
func (c *cConfig) GetCash(ctx context.Context, _ *config.GetCashReq) (res *config.GetCashRes, err error) {
res = new(config.GetCashRes)
res.GetConfigModel, err = service.SysConfig().GetConfigByGroup(ctx, &sysin.GetConfigInp{Group: "cash"})
return
}
server/internal/controller/admin/sys/cron.go
+97
View File
@@ -0,0 +1,97 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"hotgo/api/admin/cron"
"hotgo/api/servmsg"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var (
Cron = cCron{}
)
type cCron struct{}
// Delete 删除
func (c *cCron) Delete(ctx context.Context, req *cron.DeleteReq) (res *cron.DeleteRes, err error) {
err = service.TCPServer().CronDelete(ctx, &servmsg.CronDeleteReq{CronDeleteInp: &req.CronDeleteInp})
return
}
// Edit 更新
func (c *cCron) Edit(ctx context.Context, req *cron.EditReq) (res *cron.EditRes, err error) {
err = service.TCPServer().CronEdit(ctx, &servmsg.CronEditReq{CronEditInp: &req.CronEditInp})
return
}
// MaxSort 最大排序
func (c *cCron) MaxSort(ctx context.Context, req *cron.MaxSortReq) (res *cron.MaxSortRes, err error) {
res = new(cron.MaxSortRes)
res.CronMaxSortModel, err = service.SysCron().MaxSort(ctx, &req.CronMaxSortInp)
return
}
// View 获取指定信息
func (c *cCron) View(ctx context.Context, req *cron.ViewReq) (res *cron.ViewRes, err error) {
data, err := service.SysCron().View(ctx, &req.CronViewInp)
if err != nil {
return
}
res = new(cron.ViewRes)
res.CronViewModel = data
return
}
// List 查看列表
func (c *cCron) List(ctx context.Context, req *cron.ListReq) (res *cron.ListRes, err error) {
list, totalCount, err := service.SysCron().List(ctx, &req.CronListInp)
if err != nil {
return
}
res = new(cron.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新状态
func (c *cCron) Status(ctx context.Context, req *cron.StatusReq) (res *cron.StatusRes, err error) {
if req.Id <= 0 {
return nil, gerror.New("定时任务ID不能为空")
}
err = service.TCPServer().CronStatus(ctx, &servmsg.CronStatusReq{CronStatusInp: &req.CronStatusInp})
return
}
// OnlineExec 在线执行
func (c *cCron) OnlineExec(ctx context.Context, req *cron.OnlineExecReq) (res *cron.OnlineExecRes, err error) {
if req.Id <= 0 {
return nil, gerror.New("定时任务ID不能为空")
}
err = service.TCPServer().CronOnlineExec(ctx, &servmsg.CronOnlineExecReq{OnlineExecInp: &req.OnlineExecInp})
return
}
// DispatchLog 调度日志
func (c *cCron) DispatchLog(ctx context.Context, req *cron.DispatchLogReq) (res *cron.DispatchLogRes, err error) {
if req.Id <= 0 {
return nil, gerror.New("定时任务ID不能为空")
}
res = new(cron.DispatchLogRes)
res.DispatchLogModel = new(sysin.DispatchLogModel)
res.Log, err = service.TCPServer().DispatchLog(ctx, &servmsg.CronDispatchLogReq{DispatchLogInp: &req.DispatchLogInp})
return
}
server/internal/controller/admin/sys/cron_group.go
+80
View File
@@ -0,0 +1,80 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/cron"
"hotgo/internal/service"
)
var (
CronGroup = cCronGroup{}
)
type cCronGroup struct{}
// Delete 删除
func (c *cCronGroup) Delete(ctx context.Context, req *cron.GroupDeleteReq) (res *cron.GroupDeleteRes, err error) {
err = service.SysCronGroup().Delete(ctx, &req.CronGroupDeleteInp)
return
}
// Edit 更新
func (c *cCronGroup) Edit(ctx context.Context, req *cron.GroupEditReq) (res *cron.GroupEditRes, err error) {
err = service.SysCronGroup().Edit(ctx, &req.CronGroupEditInp)
return
}
// MaxSort 最大排序
func (c *cCronGroup) MaxSort(ctx context.Context, req *cron.GroupMaxSortReq) (res *cron.GroupMaxSortRes, err error) {
res = new(cron.GroupMaxSortRes)
res.CronGroupMaxSortModel, err = service.SysCronGroup().MaxSort(ctx, &req.CronGroupMaxSortInp)
return
}
// View 获取指定信息
func (c *cCronGroup) View(ctx context.Context, req *cron.GroupViewReq) (res *cron.GroupViewRes, err error) {
data, err := service.SysCronGroup().View(ctx, &req.CronGroupViewInp)
if err != nil {
return
}
res = new(cron.GroupViewRes)
res.CronGroupViewModel = data
return
}
// List 查看列表
func (c *cCronGroup) List(ctx context.Context, req *cron.GroupListReq) (res *cron.GroupListRes, err error) {
list, totalCount, err := service.SysCronGroup().List(ctx, &req.CronGroupListInp)
if err != nil {
return
}
res = new(cron.GroupListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新状态
func (c *cCronGroup) Status(ctx context.Context, req *cron.GroupStatusReq) (res *cron.GroupStatusRes, err error) {
err = service.SysCronGroup().Status(ctx, &req.CronGroupStatusInp)
return
}
// Select 选项
func (c *cCronGroup) Select(ctx context.Context, req *cron.GroupSelectReq) (res *cron.GroupSelectRes, err error) {
data, err := service.SysCronGroup().Select(ctx, &req.CronGroupSelectInp)
if err != nil {
return
}
res = new(cron.GroupSelectRes)
res.CronGroupSelectModel = data
return
}
server/internal/controller/admin/sys/curd_demo.go
+91
View File
@@ -0,0 +1,91 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2025 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.18.6
package sys
import (
"context"
"hotgo/api/admin/curddemo"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var (
CurdDemo = cCurdDemo{}
)
type cCurdDemo struct{}
// List 查看CURD列表列表
func (c *cCurdDemo) List(ctx context.Context, req *curddemo.ListReq) (res *curddemo.ListRes, err error) {
list, totalCount, err := service.SysCurdDemo().List(ctx, &req.CurdDemoListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.CurdDemoListModel{}
}
res = new(curddemo.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Export 导出CURD列表列表
func (c *cCurdDemo) Export(ctx context.Context, req *curddemo.ExportReq) (res *curddemo.ExportRes, err error) {
err = service.SysCurdDemo().Export(ctx, &req.CurdDemoListInp)
return
}
// Edit 更新CURD列表
func (c *cCurdDemo) Edit(ctx context.Context, req *curddemo.EditReq) (res *curddemo.EditRes, err error) {
err = service.SysCurdDemo().Edit(ctx, &req.CurdDemoEditInp)
return
}
// MaxSort 获取CURD列表最大排序
func (c *cCurdDemo) MaxSort(ctx context.Context, req *curddemo.MaxSortReq) (res *curddemo.MaxSortRes, err error) {
data, err := service.SysCurdDemo().MaxSort(ctx, &req.CurdDemoMaxSortInp)
if err != nil {
return
}
res = new(curddemo.MaxSortRes)
res.CurdDemoMaxSortModel = data
return
}
// View 获取指定CURD列表信息
func (c *cCurdDemo) View(ctx context.Context, req *curddemo.ViewReq) (res *curddemo.ViewRes, err error) {
data, err := service.SysCurdDemo().View(ctx, &req.CurdDemoViewInp)
if err != nil {
return
}
res = new(curddemo.ViewRes)
res.CurdDemoViewModel = data
return
}
// Delete 删除CURD列表
func (c *cCurdDemo) Delete(ctx context.Context, req *curddemo.DeleteReq) (res *curddemo.DeleteRes, err error) {
err = service.SysCurdDemo().Delete(ctx, &req.CurdDemoDeleteInp)
return
}
// Status 更新CURD列表状态
func (c *cCurdDemo) Status(ctx context.Context, req *curddemo.StatusReq) (res *curddemo.StatusRes, err error) {
err = service.SysCurdDemo().Status(ctx, &req.CurdDemoStatusInp)
return
}
// Switch 更新CURD列表开关状态
func (c *cCurdDemo) Switch(ctx context.Context, req *curddemo.SwitchReq) (res *curddemo.SwitchRes, err error) {
err = service.SysCurdDemo().Switch(ctx, &req.CurdDemoSwitchInp)
return
}
server/internal/controller/admin/sys/customer_service.go
+40
View File
@@ -0,0 +1,40 @@
package sys
import (
"context"
"hotgo/api/admin/customerservice"
"hotgo/internal/model/entity"
"hotgo/internal/service"
)
var CustomerService = cCustomerService{}
type cCustomerService struct{}
func (c *cCustomerService) List(ctx context.Context, req *customerservice.ListReq) (res *customerservice.ListRes, err error) {
list, total, err := service.SysCustomerService().List(ctx, &req.CustomerServiceListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*entity.CustomerService{}
}
res = new(customerservice.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cCustomerService) View(ctx context.Context, req *customerservice.ViewReq) (*customerservice.ViewRes, error) {
v, err := service.SysCustomerService().View(ctx, &req.CustomerServiceViewInp)
return &customerservice.ViewRes{CustomerService: v}, err
}
func (c *cCustomerService) Edit(ctx context.Context, req *customerservice.EditReq) (*customerservice.EditRes, error) {
return &customerservice.EditRes{}, service.SysCustomerService().Edit(ctx, &req.CustomerServiceEditInp)
}
func (c *cCustomerService) Status(ctx context.Context, req *customerservice.StatusReq) (*customerservice.StatusRes, error) {
return &customerservice.StatusRes{}, service.SysCustomerService().Status(ctx, &req.CustomerServiceStatusInp)
}
func (c *cCustomerService) Delete(ctx context.Context, req *customerservice.DeleteReq) (*customerservice.DeleteRes, error) {
return &customerservice.DeleteRes{}, service.SysCustomerService().Delete(ctx, &req.CustomerServiceDeleteInp)
}
server/internal/controller/admin/sys/dict_data.go
+68
View File
@@ -0,0 +1,68 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/dict"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var (
DictData = cDictData{}
)
type cDictData struct{}
// Delete 删除
func (c *cDictData) Delete(ctx context.Context, req *dict.DataDeleteReq) (res *dict.DataDeleteRes, err error) {
err = service.SysDictData().Delete(ctx, &req.DictDataDeleteInp)
return
}
// Edit 更新
func (c *cDictData) Edit(ctx context.Context, req *dict.DataEditReq) (res *dict.DataEditRes, err error) {
err = service.SysDictData().Edit(ctx, &req.DictDataEditInp)
return
}
// List 查看列表
func (c *cDictData) List(ctx context.Context, req *dict.DataListReq) (res *dict.DataListRes, err error) {
list, totalCount, err := service.SysDictData().List(ctx, &req.DictDataListInp)
if err != nil {
return
}
res = new(dict.DataListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Select 指定选项
func (c *cDictData) Select(ctx context.Context, req *dict.DataSelectReq) (res dict.DataSelectRes, err error) {
list, err := service.SysDictData().Select(ctx, &req.DataSelectInp)
if err != nil {
return
}
res = dict.DataSelectRes(list)
return
}
// Selects 多个选项
func (c *cDictData) Selects(ctx context.Context, req *dict.DataSelectsReq) (res dict.DataSelectsRes, err error) {
res = make(dict.DataSelectsRes)
for _, v := range req.Types {
option, err := service.SysDictData().Select(ctx, &sysin.DataSelectInp{Type: v})
if err != nil {
return nil, err
}
res[v] = option
}
return
}
server/internal/controller/admin/sys/dict_type.go
+37
View File
@@ -0,0 +1,37 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/dict"
"hotgo/internal/service"
)
var (
DictType = cDictType{}
)
type cDictType struct{}
// Tree 树
func (c *cDictType) Tree(ctx context.Context, _ *dict.TypeTreeReq) (res *dict.TypeTreeRes, err error) {
res = new(dict.TypeTreeRes)
res.List, err = service.SysDictType().Tree(ctx)
return
}
// Delete 删除
func (c *cDictType) Delete(ctx context.Context, req *dict.TypeDeleteReq) (res *dict.TypeDeleteRes, err error) {
err = service.SysDictType().Delete(ctx, &req.DictTypeDeleteInp)
return
}
// Edit 更新
func (c *cDictType) Edit(ctx context.Context, req *dict.TypeEditReq) (res *dict.TypeEditRes, err error) {
err = service.SysDictType().Edit(ctx, &req.DictTypeEditInp)
return
}
server/internal/controller/admin/sys/ems_log.go
+61
View File
@@ -0,0 +1,61 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/emslog"
"hotgo/internal/service"
)
var (
EmsLog = cEmsLog{}
)
type cEmsLog struct{}
// Delete 删除
func (c *cEmsLog) Delete(ctx context.Context, req *emslog.DeleteReq) (res *emslog.DeleteRes, err error) {
err = service.SysEmsLog().Delete(ctx, &req.EmsLogDeleteInp)
return
}
// Edit 更新
func (c *cEmsLog) Edit(ctx context.Context, req *emslog.EditReq) (res *emslog.EditRes, err error) {
err = service.SysEmsLog().Edit(ctx, &req.EmsLogEditInp)
return
}
// View 获取指定信息
func (c *cEmsLog) View(ctx context.Context, req *emslog.ViewReq) (res *emslog.ViewRes, err error) {
data, err := service.SysEmsLog().View(ctx, &req.EmsLogViewInp)
if err != nil {
return
}
res = new(emslog.ViewRes)
res.EmsLogViewModel = data
return
}
// List 查看列表
func (c *cEmsLog) List(ctx context.Context, req *emslog.ListReq) (res *emslog.ListRes, err error) {
list, totalCount, err := service.SysEmsLog().List(ctx, &req.EmsLogListInp)
if err != nil {
return
}
res = new(emslog.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新状态
func (c *cEmsLog) Status(ctx context.Context, req *emslog.StatusReq) (res *emslog.StatusRes, err error) {
err = service.SysEmsLog().Status(ctx, &req.EmsLogStatusInp)
return
}
server/internal/controller/admin/sys/gen_codes.go
+137
View File
@@ -0,0 +1,137 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/gencodes"
"hotgo/internal/service"
)
var (
GenCodes = cGenCodes{}
)
type cGenCodes struct{}
// Delete 删除
func (c *cGenCodes) Delete(ctx context.Context, req *gencodes.DeleteReq) (res *gencodes.DeleteRes, err error) {
err = service.SysGenCodes().Delete(ctx, &req.GenCodesDeleteInp)
return
}
// Edit 更新
func (c *cGenCodes) Edit(ctx context.Context, req *gencodes.EditReq) (res *gencodes.EditRes, err error) {
data, err := service.SysGenCodes().Edit(ctx, &req.GenCodesEditInp)
if err != nil {
return
}
res = new(gencodes.EditRes)
res.GenCodesEditModel = data
return
}
// MaxSort 最大排序
func (c *cGenCodes) MaxSort(ctx context.Context, req *gencodes.MaxSortReq) (res *gencodes.MaxSortRes, err error) {
res = new(gencodes.MaxSortRes)
res.GenCodesMaxSortModel, err = service.SysGenCodes().MaxSort(ctx, &req.GenCodesMaxSortInp)
return
}
// View 获取指定信息
func (c *cGenCodes) View(ctx context.Context, req *gencodes.ViewReq) (res *gencodes.ViewRes, err error) {
data, err := service.SysGenCodes().View(ctx, &req.GenCodesViewInp)
if err != nil {
return
}
res = new(gencodes.ViewRes)
res.GenCodesViewModel = data
return
}
// List 查看列表
func (c *cGenCodes) List(ctx context.Context, req *gencodes.ListReq) (res *gencodes.ListRes, err error) {
list, totalCount, err := service.SysGenCodes().List(ctx, &req.GenCodesListInp)
if err != nil {
return
}
res = new(gencodes.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新状态
func (c *cGenCodes) Status(ctx context.Context, req *gencodes.StatusReq) (res *gencodes.StatusRes, err error) {
err = service.SysGenCodes().Status(ctx, &req.GenCodesStatusInp)
return
}
// Selects 获取指定信息
func (c *cGenCodes) Selects(ctx context.Context, req *gencodes.SelectsReq) (res *gencodes.SelectsRes, err error) {
data, err := service.SysGenCodes().Selects(ctx, &req.GenCodesSelectsInp)
if err != nil {
return
}
res = new(gencodes.SelectsRes)
res.GenCodesSelectsModel = data
return
}
// TableSelect 数据库表选项
func (c *cGenCodes) TableSelect(ctx context.Context, req *gencodes.TableSelectReq) (res *gencodes.TableSelectRes, err error) {
data, err := service.SysGenCodes().TableSelect(ctx, &req.GenCodesTableSelectInp)
if err != nil {
return
}
res = (*gencodes.TableSelectRes)(&data)
return
}
// ColumnSelect 表字段选项
func (c *cGenCodes) ColumnSelect(ctx context.Context, req *gencodes.ColumnSelectReq) (res *gencodes.ColumnSelectRes, err error) {
data, err := service.SysGenCodes().ColumnSelect(ctx, &req.GenCodesColumnSelectInp)
if err != nil {
return
}
res = (*gencodes.ColumnSelectRes)(&data)
return
}
// ColumnList 表字段列表
func (c *cGenCodes) ColumnList(ctx context.Context, req *gencodes.ColumnListReq) (res *gencodes.ColumnListRes, err error) {
data, err := service.SysGenCodes().ColumnList(ctx, &req.GenCodesColumnListInp)
if err != nil {
return
}
res = (*gencodes.ColumnListRes)(&data)
return
}
// Preview 生成预览
func (c *cGenCodes) Preview(ctx context.Context, req *gencodes.PreviewReq) (res *gencodes.PreviewRes, err error) {
data, err := service.SysGenCodes().Preview(ctx, &req.GenCodesPreviewInp)
if err != nil {
return
}
res = new(gencodes.PreviewRes)
res.GenCodesPreviewModel = data
return
}
// Build 生成预览
func (c *cGenCodes) Build(ctx context.Context, req *gencodes.BuildReq) (res *gencodes.BuildRes, err error) {
err = service.SysGenCodes().Build(ctx, &req.GenCodesBuildInp)
return
}
server/internal/controller/admin/sys/log.go
+56
View File
@@ -0,0 +1,56 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"hotgo/api/admin/log"
"hotgo/internal/service"
)
// Log 日志
var Log = sLog{}
type sLog struct{}
// Clear 清空日志
func (c *sLog) Clear(ctx context.Context, _ *log.ClearReq) (res *log.ClearRes, err error) {
err = gerror.New("暂时考虑到安全问题，请到数据库清空")
return
}
// Export 导出
func (c *sLog) Export(ctx context.Context, req *log.ExportReq) (res *log.ExportRes, err error) {
err = service.SysLog().Export(ctx, &req.LogListInp)
return
}
// List 获取访问日志列表
func (c *sLog) List(ctx context.Context, req *log.ListReq) (res *log.ListRes, err error) {
list, totalCount, err := service.SysLog().List(ctx, &req.LogListInp)
if err != nil {
return
}
res = new(log.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// View 获取指定信息
func (c *sLog) View(ctx context.Context, req *log.ViewReq) (res *log.ViewRes, err error) {
res = new(log.ViewRes)
res.LogViewModel, err = service.SysLog().View(ctx, &req.LogViewInp)
return
}
// Delete 删除
func (c *sLog) Delete(ctx context.Context, req *log.DeleteReq) (res *log.DeleteRes, err error) {
err = service.SysLog().Delete(ctx, &req.LogDeleteInp)
return
}
server/internal/controller/admin/sys/login_log.go
+45
View File
@@ -0,0 +1,45 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.1.1
// @AutoGenerate Date 2023-01-19 16:57:33
package sys
import (
"context"
"hotgo/api/admin/loginlog"
"hotgo/internal/service"
)
var (
LoginLog = cLoginLog{}
)
type cLoginLog struct{}
// List 查看登录日志列表
func (c *cLoginLog) List(ctx context.Context, req *loginlog.ListReq) (res *loginlog.ListRes, err error) {
list, totalCount, err := service.SysLoginLog().List(ctx, &req.LoginLogListInp)
if err != nil {
return
}
res = new(loginlog.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Export 导出登录日志列表
func (c *cLoginLog) Export(ctx context.Context, req *loginlog.ExportReq) (res *loginlog.ExportRes, err error) {
err = service.SysLoginLog().Export(ctx, &req.LoginLogListInp)
return
}
// Delete 删除登录日志
func (c *cLoginLog) Delete(ctx context.Context, req *loginlog.DeleteReq) (res *loginlog.DeleteRes, err error) {
err = service.SysLoginLog().Delete(ctx, &req.LoginLogDeleteInp)
return
}
server/internal/controller/admin/sys/member_level.go
+71
View File
@@ -0,0 +1,71 @@
package sys
import (
"context"
"hotgo/api/admin/memberlevel"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var MemberLevel = cMemberLevel{}
type cMemberLevel struct{}
func (c *cMemberLevel) List(ctx context.Context, req *memberlevel.ListReq) (res *memberlevel.ListRes, err error) {
list, total, err := service.SysMemberLevel().List(ctx, &req.MemberLevelListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.MemberLevelListModel{}
}
res = new(memberlevel.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cMemberLevel) View(ctx context.Context, req *memberlevel.ViewReq) (res *memberlevel.ViewRes, err error) {
v, err := service.SysMemberLevel().View(ctx, &req.MemberLevelViewInp)
if err != nil {
return
}
return &memberlevel.ViewRes{MemberLevelViewModel: v}, nil
}
func (c *cMemberLevel) Save(ctx context.Context, req *memberlevel.SaveReq) (res *memberlevel.SaveRes, err error) {
id, vid, err := service.SysMemberLevel().Save(ctx, &req.MemberLevelSaveInp)
return &memberlevel.SaveRes{Id: id, VersionId: vid}, err
}
func (c *cMemberLevel) Submit(ctx context.Context, req *memberlevel.SubmitReq) (res *memberlevel.SubmitRes, err error) {
v, err := service.SysMemberLevel().Submit(ctx, &req.MemberLevelSubmitInp)
if err != nil {
return
}
return &memberlevel.SubmitRes{MemberLevelApprovalModel: v}, nil
}
func (c *cMemberLevel) Publish(ctx context.Context, req *memberlevel.PublishReq) (*memberlevel.PublishRes, error) {
return &memberlevel.PublishRes{}, service.SysMemberLevel().Publish(ctx, &req.MemberLevelPublishInp)
}
func (c *cMemberLevel) Rollback(ctx context.Context, req *memberlevel.RollbackReq) (*memberlevel.RollbackRes, error) {
id, err := service.SysMemberLevel().Rollback(ctx, &req.MemberLevelRollbackInp)
return &memberlevel.RollbackRes{VersionId: id}, err
}
func (c *cMemberLevel) History(ctx context.Context, req *memberlevel.HistoryReq) (res *memberlevel.HistoryRes, err error) {
list, total, err := service.SysMemberLevel().History(ctx, &req.MemberLevelHistoryInp)
if err != nil {
return
}
if list == nil {
list = []*entity.AppMemberLevelVersion{}
}
res = new(memberlevel.HistoryRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cMemberLevel) Status(ctx context.Context, req *memberlevel.StatusReq) (*memberlevel.StatusRes, error) {
return &memberlevel.StatusRes{}, service.SysMemberLevel().Status(ctx, &req.MemberLevelStatusInp)
}
func (c *cMemberLevel) Delete(ctx context.Context, req *memberlevel.DeleteReq) (*memberlevel.DeleteRes, error) {
return &memberlevel.DeleteRes{}, service.SysMemberLevel().Delete(ctx, &req.MemberLevelDeleteInp)
}
server/internal/controller/admin/sys/normal_tree_demo.go
+89
View File
@@ -0,0 +1,89 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2024 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.15.7
package sys
import (
"context"
"hotgo/api/admin/normaltreedemo"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var (
NormalTreeDemo = cNormalTreeDemo{}
)
type cNormalTreeDemo struct{}
// List 查看普通树表列表
func (c *cNormalTreeDemo) List(ctx context.Context, req *normaltreedemo.ListReq) (res *normaltreedemo.ListRes, err error) {
list, totalCount, err := service.SysNormalTreeDemo().List(ctx, &req.NormalTreeDemoListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.NormalTreeDemoListModel{}
}
res = new(normaltreedemo.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Edit 更新普通树表
func (c *cNormalTreeDemo) Edit(ctx context.Context, req *normaltreedemo.EditReq) (res *normaltreedemo.EditRes, err error) {
err = service.SysNormalTreeDemo().Edit(ctx, &req.NormalTreeDemoEditInp)
return
}
// MaxSort 获取普通树表最大排序
func (c *cNormalTreeDemo) MaxSort(ctx context.Context, req *normaltreedemo.MaxSortReq) (res *normaltreedemo.MaxSortRes, err error) {
data, err := service.SysNormalTreeDemo().MaxSort(ctx, &req.NormalTreeDemoMaxSortInp)
if err != nil {
return
}
res = new(normaltreedemo.MaxSortRes)
res.NormalTreeDemoMaxSortModel = data
return
}
// View 获取指定普通树表信息
func (c *cNormalTreeDemo) View(ctx context.Context, req *normaltreedemo.ViewReq) (res *normaltreedemo.ViewRes, err error) {
data, err := service.SysNormalTreeDemo().View(ctx, &req.NormalTreeDemoViewInp)
if err != nil {
return
}
res = new(normaltreedemo.ViewRes)
res.NormalTreeDemoViewModel = data
return
}
// Delete 删除普通树表
func (c *cNormalTreeDemo) Delete(ctx context.Context, req *normaltreedemo.DeleteReq) (res *normaltreedemo.DeleteRes, err error) {
err = service.SysNormalTreeDemo().Delete(ctx, &req.NormalTreeDemoDeleteInp)
return
}
// TreeOption 获取普通树表关系树选项
func (c *cNormalTreeDemo) TreeOption(ctx context.Context, req *normaltreedemo.TreeOptionReq) (res *normaltreedemo.TreeOptionRes, err error) {
data, err := service.SysNormalTreeDemo().TreeOption(ctx)
if err != nil {
return nil, err
}
if len(data) > 0 {
res = (*normaltreedemo.TreeOptionRes)(&data)
} else {
temp := make(normaltreedemo.TreeOptionRes, 0)
res = &temp
}
return
}
server/internal/controller/admin/sys/option_tree_demo.go
+89
View File
@@ -0,0 +1,89 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2025 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.17.8
package sys
import (
"context"
"hotgo/api/admin/optiontreedemo"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var (
OptionTreeDemo = cOptionTreeDemo{}
)
type cOptionTreeDemo struct{}
// List 查看选项树表列表
func (c *cOptionTreeDemo) List(ctx context.Context, req *optiontreedemo.ListReq) (res *optiontreedemo.ListRes, err error) {
list, totalCount, err := service.SysOptionTreeDemo().List(ctx, &req.OptionTreeDemoListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.OptionTreeDemoListModel{}
}
res = new(optiontreedemo.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Edit 更新选项树表
func (c *cOptionTreeDemo) Edit(ctx context.Context, req *optiontreedemo.EditReq) (res *optiontreedemo.EditRes, err error) {
err = service.SysOptionTreeDemo().Edit(ctx, &req.OptionTreeDemoEditInp)
return
}
// MaxSort 获取选项树表最大排序
func (c *cOptionTreeDemo) MaxSort(ctx context.Context, req *optiontreedemo.MaxSortReq) (res *optiontreedemo.MaxSortRes, err error) {
data, err := service.SysOptionTreeDemo().MaxSort(ctx, &req.OptionTreeDemoMaxSortInp)
if err != nil {
return
}
res = new(optiontreedemo.MaxSortRes)
res.OptionTreeDemoMaxSortModel = data
return
}
// View 获取指定选项树表信息
func (c *cOptionTreeDemo) View(ctx context.Context, req *optiontreedemo.ViewReq) (res *optiontreedemo.ViewRes, err error) {
data, err := service.SysOptionTreeDemo().View(ctx, &req.OptionTreeDemoViewInp)
if err != nil {
return
}
res = new(optiontreedemo.ViewRes)
res.OptionTreeDemoViewModel = data
return
}
// Delete 删除选项树表
func (c *cOptionTreeDemo) Delete(ctx context.Context, req *optiontreedemo.DeleteReq) (res *optiontreedemo.DeleteRes, err error) {
err = service.SysOptionTreeDemo().Delete(ctx, &req.OptionTreeDemoDeleteInp)
return
}
// TreeOption 获取选项树表关系树选项
func (c *cOptionTreeDemo) TreeOption(ctx context.Context, req *optiontreedemo.TreeOptionReq) (res *optiontreedemo.TreeOptionRes, err error) {
data, err := service.SysOptionTreeDemo().TreeOption(ctx)
if err != nil {
return nil, err
}
if len(data) > 0 {
res = (*optiontreedemo.TreeOptionRes)(&data)
} else {
temp := make(optiontreedemo.TreeOptionRes, 0)
res = &temp
}
return
}
server/internal/controller/admin/sys/portal.go
+168
View File
@@ -0,0 +1,168 @@
package sys
import (
"context"
"hotgo/api/admin/portal"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var Portal = cPortal{}
type cPortal struct{}
func (c *cPortal) SiteConfigCurrent(ctx context.Context, req *portal.SiteConfigCurrentReq) (res *portal.SiteConfigCurrentRes, err error) {
data, err := service.SysPortal().SiteConfigCurrent(ctx, &req.SiteConfigCurrentInp)
if err != nil {
return
}
res = &portal.SiteConfigCurrentRes{SiteConfigCurrentModel: data}
return
}
func (c *cPortal) SiteConfigHistory(ctx context.Context, req *portal.SiteConfigHistoryReq) (res *portal.SiteConfigHistoryRes, err error) {
list, total, err := service.SysPortal().SiteConfigHistory(ctx, &req.SiteConfigHistoryInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.SiteConfigHistoryModel{}
}
res = new(portal.SiteConfigHistoryRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cPortal) SiteConfigSave(ctx context.Context, req *portal.SiteConfigSaveReq) (res *portal.SiteConfigSaveRes, err error) {
id, err := service.SysPortal().SiteConfigSave(ctx, &req.SiteConfigSaveInp)
if err == nil {
res = &portal.SiteConfigSaveRes{Id: id}
}
return
}
func (c *cPortal) SiteConfigSubmit(ctx context.Context, req *portal.SiteConfigSubmitReq) (res *portal.SiteConfigSubmitRes, err error) {
data, err := service.SysPortal().SiteConfigSubmit(ctx, &req.SiteConfigSubmitInp)
if err == nil {
res = &portal.SiteConfigSubmitRes{PortalApprovalModel: data}
}
return
}
func (c *cPortal) SiteConfigPublish(ctx context.Context, req *portal.SiteConfigPublishReq) (res *portal.SiteConfigPublishRes, err error) {
err = service.SysPortal().SiteConfigPublish(ctx, &req.SiteConfigPublishInp)
return
}
func (c *cPortal) SiteConfigRollback(ctx context.Context, req *portal.SiteConfigRollbackReq) (res *portal.SiteConfigRollbackRes, err error) {
id, err := service.SysPortal().SiteConfigRollback(ctx, &req.SiteConfigRollbackInp)
if err == nil {
res = &portal.SiteConfigRollbackRes{Id: id}
}
return
}
func (c *cPortal) ContentList(ctx context.Context, req *portal.ContentListReq) (res *portal.ContentListRes, err error) {
list, total, err := service.SysPortal().ContentList(ctx, &req.ContentListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.ContentListModel{}
}
res = new(portal.ContentListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cPortal) ContentView(ctx context.Context, req *portal.ContentViewReq) (res *portal.ContentViewRes, err error) {
data, err := service.SysPortal().ContentView(ctx, &req.ContentViewInp)
if err == nil {
res = &portal.ContentViewRes{ContentViewModel: data}
}
return
}
func (c *cPortal) ContentEdit(ctx context.Context, req *portal.ContentEditReq) (res *portal.ContentEditRes, err error) {
id, err := service.SysPortal().ContentEdit(ctx, &req.ContentEditInp)
if err == nil {
res = &portal.ContentEditRes{Id: id}
}
return
}
func (c *cPortal) ContentDelete(ctx context.Context, req *portal.ContentDeleteReq) (res *portal.ContentDeleteRes, err error) {
err = service.SysPortal().ContentDelete(ctx, &req.ContentDeleteInp)
return
}
func (c *cPortal) ContentPublish(ctx context.Context, req *portal.ContentPublishReq) (res *portal.ContentPublishRes, err error) {
err = service.SysPortal().ContentPublish(ctx, &req.ContentPublishInp)
return
}
func (c *cPortal) ContentOffline(ctx context.Context, req *portal.ContentOfflineReq) (res *portal.ContentOfflineRes, err error) {
err = service.SysPortal().ContentOffline(ctx, &req.ContentOfflineInp)
return
}
func (c *cPortal) BannerList(ctx context.Context, req *portal.BannerListReq) (res *portal.BannerListRes, err error) {
list, total, err := service.SysPortal().BannerList(ctx, &req.BannerListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.BannerListModel{}
}
res = new(portal.BannerListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cPortal) BannerView(ctx context.Context, req *portal.BannerViewReq) (res *portal.BannerViewRes, err error) {
data, err := service.SysPortal().BannerView(ctx, &req.BannerViewInp)
if err == nil {
res = &portal.BannerViewRes{Banner: data}
}
return
}
func (c *cPortal) BannerEdit(ctx context.Context, req *portal.BannerEditReq) (res *portal.BannerEditRes, err error) {
id, err := service.SysPortal().BannerEdit(ctx, &req.BannerEditInp)
if err == nil {
res = &portal.BannerEditRes{Id: id}
}
return
}
func (c *cPortal) BannerDelete(ctx context.Context, req *portal.BannerDeleteReq) (res *portal.BannerDeleteRes, err error) {
err = service.SysPortal().BannerDelete(ctx, &req.BannerDeleteInp)
return
}
func (c *cPortal) BannerStatus(ctx context.Context, req *portal.BannerStatusReq) (res *portal.BannerStatusRes, err error) {
err = service.SysPortal().BannerStatus(ctx, &req.BannerStatusInp)
return
}
func (c *cPortal) ManualProductList(ctx context.Context, req *portal.ManualProductListReq) (res *portal.ManualProductListRes, err error) {
list, total, err := service.SysPortal().ManualProductList(ctx, &req.ManualProductListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.ManualProductListModel{}
}
res = new(portal.ManualProductListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cPortal) ManualProductView(ctx context.Context, req *portal.ManualProductViewReq) (res *portal.ManualProductViewRes, err error) {
data, err := service.SysPortal().ManualProductView(ctx, &req.ManualProductViewInp)
if err == nil {
res = &portal.ManualProductViewRes{ManualProductViewModel: data}
}
return
}
func (c *cPortal) ManualProductEdit(ctx context.Context, req *portal.ManualProductEditReq) (res *portal.ManualProductEditRes, err error) {
id, err := service.SysPortal().ManualProductEdit(ctx, &req.ManualProductEditInp)
if err == nil {
res = &portal.ManualProductEditRes{Id: id}
}
return
}
func (c *cPortal) ManualProductDelete(ctx context.Context, req *portal.ManualProductDeleteReq) (res *portal.ManualProductDeleteRes, err error) {
err = service.SysPortal().ManualProductDelete(ctx, &req.ManualProductDeleteInp)
return
}
func (c *cPortal) ManualProductStatus(ctx context.Context, req *portal.ManualProductStatusReq) (res *portal.ManualProductStatusRes, err error) {
err = service.SysPortal().ManualProductStatus(ctx, &req.ManualProductStatusInp)
return
}
server/internal/controller/admin/sys/product.go
+52
View File
@@ -0,0 +1,52 @@
package sys
import (
"context"
"hotgo/api/admin/product"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var Product = cProduct{}
type cProduct struct{}
func (c *cProduct) List(ctx context.Context, req *product.ListReq) (res *product.ListRes, err error) {
list, total, err := service.SysProduct().List(ctx, &req.ProductListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.ProductListModel{}
}
res = new(product.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cProduct) View(ctx context.Context, req *product.ViewReq) (res *product.ViewRes, err error) {
data, err := service.SysProduct().View(ctx, &req.ProductViewInp)
if err == nil {
res = &product.ViewRes{ProductListModel: data}
}
return res, err
}
func (c *cProduct) Edit(ctx context.Context, req *product.EditReq) (res *product.EditRes, err error) {
id, err := service.SysProduct().Edit(ctx, &req.ProductEditInp)
if err == nil {
res = &product.EditRes{Id: id}
}
return res, err
}
func (c *cProduct) Status(ctx context.Context, req *product.StatusReq) (res *product.StatusRes, err error) {
err = service.SysProduct().Status(ctx, &req.ProductStatusInp)
return
}
func (c *cProduct) Recommend(ctx context.Context, req *product.RecommendReq) (res *product.RecommendRes, err error) {
err = service.SysProduct().Recommend(ctx, &req.ProductRecommendInp)
return
}
func (c *cProduct) Delete(ctx context.Context, req *product.DeleteReq) (res *product.DeleteRes, err error) {
err = service.SysProduct().Delete(ctx, &req.ProductDeleteInp)
return
}
server/internal/controller/admin/sys/provinces.go
+129
View File
@@ -0,0 +1,129 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/provinces"
"hotgo/internal/library/location"
"hotgo/internal/service"
)
var (
Provinces = cProvinces{}
)
type cProvinces struct{}
// Tree 关系树选项列表
func (c *cProvinces) Tree(ctx context.Context, _ *provinces.TreeReq) (res *provinces.TreeRes, err error) {
res = new(provinces.TreeRes)
res.List, err = service.SysProvinces().Tree(ctx)
return
}
// Delete 删除
func (c *cProvinces) Delete(ctx context.Context, req *provinces.DeleteReq) (res *provinces.DeleteRes, err error) {
err = service.SysProvinces().Delete(ctx, &req.ProvincesDeleteInp)
return
}
// Edit 更新
func (c *cProvinces) Edit(ctx context.Context, req *provinces.EditReq) (res *provinces.EditRes, err error) {
err = service.SysProvinces().Edit(ctx, &req.ProvincesEditInp)
return
}
// MaxSort 最大排序
func (c *cProvinces) MaxSort(ctx context.Context, req *provinces.MaxSortReq) (res *provinces.MaxSortRes, err error) {
data, err := service.SysProvinces().MaxSort(ctx, &req.ProvincesMaxSortInp)
if err != nil {
return
}
res = new(provinces.MaxSortRes)
res.ProvincesMaxSortModel = data
return
}
// View 获取指定信息
func (c *cProvinces) View(ctx context.Context, req *provinces.ViewReq) (res *provinces.ViewRes, err error) {
data, err := service.SysProvinces().View(ctx, &req.ProvincesViewInp)
if err != nil {
return
}
res = new(provinces.ViewRes)
res.ProvincesViewModel = data
return
}
// List 查看列表
func (c *cProvinces) List(ctx context.Context, req *provinces.ListReq) (res *provinces.ListRes, err error) {
list, totalCount, err := service.SysProvinces().List(ctx, &req.ProvincesListInp)
if err != nil {
return
}
res = new(provinces.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Status 更新省市区状态
func (c *cProvinces) Status(ctx context.Context, req *provinces.StatusReq) (res *provinces.StatusRes, err error) {
err = service.SysProvinces().Status(ctx, &req.ProvincesStatusInp)
return
}
// ChildrenList 获取省市区下级列表
func (c *cProvinces) ChildrenList(ctx context.Context, req *provinces.ChildrenListReq) (res *provinces.ChildrenListRes, err error) {
list, totalCount, err := service.SysProvinces().ChildrenList(ctx, &req.ProvincesChildrenListInp)
if err != nil {
return
}
res = new(provinces.ChildrenListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// UniqueId 地区ID是否唯一
func (c *cProvinces) UniqueId(ctx context.Context, req *provinces.UniqueIdReq) (res *provinces.UniqueIdRes, err error) {
data, err := service.SysProvinces().UniqueId(ctx, &req.ProvincesUniqueIdInp)
if err != nil {
return
}
res = new(provinces.UniqueIdRes)
res.ProvincesUniqueIdModel = data
return
}
// Select 省市区选项
func (c *cProvinces) Select(ctx context.Context, req *provinces.SelectReq) (res *provinces.SelectRes, err error) {
data, err := service.SysProvinces().Select(ctx, &req.ProvincesSelectInp)
if err != nil {
return
}
res = new(provinces.SelectRes)
res.ProvincesSelectModel = data
return
}
// CityLabel 省市区选项
func (c *cProvinces) CityLabel(ctx context.Context, req *provinces.CityLabelReq) (res *provinces.CityLabelRes, err error) {
cityLabel, err := location.ParseSimpleRegion(ctx, req.Id, req.Spilt)
if err != nil {
return
}
res = (*provinces.CityLabelRes)(&cityLabel)
return
}
server/internal/controller/admin/sys/recharge_order.go
+42
View File
@@ -0,0 +1,42 @@
package sys
import (
"context"
"hotgo/api/admin/rechargeorder"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var RechargeOrder = cRechargeOrder{}
type cRechargeOrder struct{}
func (c *cRechargeOrder) List(ctx context.Context, req *rechargeorder.ListReq) (res *rechargeorder.ListRes, err error) {
list, total, err := service.SysRechargeOrder().List(ctx, &req.RechargeOrderListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.RechargeOrderListModel{}
}
res = new(rechargeorder.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cRechargeOrder) Summary(ctx context.Context, req *rechargeorder.SummaryReq) (*rechargeorder.SummaryRes, error) {
v, err := service.SysRechargeOrder().Summary(ctx, &req.RechargeOrderListInp)
return &rechargeorder.SummaryRes{RechargeSummaryModel: v}, err
}
func (c *cRechargeOrder) View(ctx context.Context, req *rechargeorder.ViewReq) (*rechargeorder.ViewRes, error) {
v, err := service.SysRechargeOrder().View(ctx, &req.RechargeOrderViewInp)
return &rechargeorder.ViewRes{RechargeOrderListModel: v}, err
}
func (c *cRechargeOrder) Review(ctx context.Context, req *rechargeorder.ReviewReq) (*rechargeorder.ReviewRes, error) {
v, err := service.SysRechargeOrder().Review(ctx, &req.RechargeReviewInp)
return &rechargeorder.ReviewRes{FinanceApprovalModel: v}, err
}
func (c *cRechargeOrder) Execute(ctx context.Context, req *rechargeorder.ExecuteReq) (*rechargeorder.ExecuteRes, error) {
return &rechargeorder.ExecuteRes{}, service.SysRechargeOrder().Execute(ctx, &req.FinanceExecuteInp)
}
server/internal/controller/admin/sys/serve_license.go
+74
View File
@@ -0,0 +1,74 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.7.6
package sys
import (
"context"
"hotgo/api/admin/servelicense"
"hotgo/internal/service"
)
var (
ServeLicense = cServeLicense{}
)
type cServeLicense struct{}
// List 查看服务授权许可列表
func (c *cServeLicense) List(ctx context.Context, req *servelicense.ListReq) (res *servelicense.ListRes, err error) {
list, totalCount, err := service.SysServeLicense().List(ctx, &req.ServeLicenseListInp)
if err != nil {
return
}
res = new(servelicense.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Export 导出服务授权许可列表
func (c *cServeLicense) Export(ctx context.Context, req *servelicense.ExportReq) (res *servelicense.ExportRes, err error) {
err = service.SysServeLicense().Export(ctx, &req.ServeLicenseListInp)
return
}
// Edit 更新服务授权许可
func (c *cServeLicense) Edit(ctx context.Context, req *servelicense.EditReq) (res *servelicense.EditRes, err error) {
err = service.SysServeLicense().Edit(ctx, &req.ServeLicenseEditInp)
return
}
// View 获取指定服务授权许可信息
func (c *cServeLicense) View(ctx context.Context, req *servelicense.ViewReq) (res *servelicense.ViewRes, err error) {
data, err := service.SysServeLicense().View(ctx, &req.ServeLicenseViewInp)
if err != nil {
return
}
res = new(servelicense.ViewRes)
res.ServeLicenseViewModel = data
return
}
// Delete 删除服务授权许可
func (c *cServeLicense) Delete(ctx context.Context, req *servelicense.DeleteReq) (res *servelicense.DeleteRes, err error) {
err = service.SysServeLicense().Delete(ctx, &req.ServeLicenseDeleteInp)
return
}
// Status 更新服务授权许可状态
func (c *cServeLicense) Status(ctx context.Context, req *servelicense.StatusReq) (res *servelicense.StatusRes, err error) {
err = service.SysServeLicense().Status(ctx, &req.ServeLicenseStatusInp)
return
}
// AssignRouter 分配服务授权许可路由
func (c *cServeLicense) AssignRouter(ctx context.Context, req *servelicense.AssignRouterReq) (res *servelicense.AssignRouterRes, err error) {
err = service.SysServeLicense().AssignRouter(ctx, &req.ServeLicenseAssignRouterInp)
return
}
server/internal/controller/admin/sys/serve_log.go
+55
View File
@@ -0,0 +1,55 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/servelog"
"hotgo/internal/service"
)
var (
ServeLog = cServeLog{}
)
type cServeLog struct{}
// List 查看服务日志列表
func (c *cServeLog) List(ctx context.Context, req *servelog.ListReq) (res *servelog.ListRes, err error) {
list, totalCount, err := service.SysServeLog().List(ctx, &req.ServeLogListInp)
if err != nil {
return
}
res = new(servelog.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Export 导出服务日志列表
func (c *cServeLog) Export(ctx context.Context, req *servelog.ExportReq) (res *servelog.ExportRes, err error) {
err = service.SysServeLog().Export(ctx, &req.ServeLogListInp)
return
}
// View 获取指定服务日志信息
func (c *cServeLog) View(ctx context.Context, req *servelog.ViewReq) (res *servelog.ViewRes, err error) {
data, err := service.SysServeLog().View(ctx, &req.ServeLogViewInp)
if err != nil {
return
}
res = new(servelog.ViewRes)
res.ServeLogViewModel = data
return
}
// Delete 删除服务日志
func (c *cServeLog) Delete(ctx context.Context, req *servelog.DeleteReq) (res *servelog.DeleteRes, err error) {
err = service.SysServeLog().Delete(ctx, &req.ServeLogDeleteInp)
return
}
server/internal/controller/admin/sys/sms_log.go
+49
View File
@@ -0,0 +1,49 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys
import (
"context"
"hotgo/api/admin/smslog"
"hotgo/internal/service"
)
var (
SmsLog = cSmsLog{}
)
type cSmsLog struct{}
// Delete 删除
func (c *cSmsLog) Delete(ctx context.Context, req *smslog.DeleteReq) (res *smslog.DeleteRes, err error) {
err = service.SysSmsLog().Delete(ctx, &req.SmsLogDeleteInp)
return
}
// View 获取指定信息
func (c *cSmsLog) View(ctx context.Context, req *smslog.ViewReq) (res *smslog.ViewRes, err error) {
data, err := service.SysSmsLog().View(ctx, &req.SmsLogViewInp)
if err != nil {
return
}
res = new(smslog.ViewRes)
res.SmsLogViewModel = data
return
}
// List 查看列表
func (c *cSmsLog) List(ctx context.Context, req *smslog.ListReq) (res *smslog.ListRes, err error) {
list, totalCount, err := service.SysSmsLog().List(ctx, &req.SmsLogListInp)
if err != nil {
return
}
res = new(smslog.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
server/internal/controller/admin/sys/task.go
+48
View File
@@ -0,0 +1,48 @@
package sys
import (
"context"
"hotgo/api/admin/task"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var Task = cTask{}
type cTask struct{}
func (c *cTask) List(ctx context.Context, req *task.ListReq) (res *task.ListRes, err error) {
list, total, err := service.SysTask().List(ctx, &req.TaskListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.TaskListModel{}
}
res = new(task.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cTask) View(ctx context.Context, req *task.ViewReq) (res *task.ViewRes, err error) {
data, err := service.SysTask().View(ctx, &req.TaskViewInp)
if err == nil {
res = &task.ViewRes{TaskListModel: data}
}
return res, err
}
func (c *cTask) Edit(ctx context.Context, req *task.EditReq) (res *task.EditRes, err error) {
id, err := service.SysTask().Edit(ctx, &req.TaskEditInp)
if err == nil {
res = &task.EditRes{Id: id}
}
return res, err
}
func (c *cTask) Status(ctx context.Context, req *task.StatusReq) (res *task.StatusRes, err error) {
err = service.SysTask().Status(ctx, &req.TaskStatusInp)
return
}
func (c *cTask) Delete(ctx context.Context, req *task.DeleteReq) (res *task.DeleteRes, err error) {
err = service.SysTask().Delete(ctx, &req.TaskDeleteInp)
return
}
server/internal/controller/admin/sys/task_hall.go
+42
View File
@@ -0,0 +1,42 @@
package sys
import (
"context"
"hotgo/api/admin/taskhall"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var TaskHall = cTaskHall{}
type cTaskHall struct{}
func (c *cTaskHall) List(ctx context.Context, req *taskhall.ListReq) (res *taskhall.ListRes, err error) {
list, total, err := service.SysTaskHall().List(ctx, &req.TaskHallListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.TaskHallListModel{}
}
res = new(taskhall.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cTaskHall) View(ctx context.Context, req *taskhall.ViewReq) (res *taskhall.ViewRes, err error) {
v, err := service.SysTaskHall().View(ctx, &req.TaskHallViewInp)
if err != nil {
return
}
return &taskhall.ViewRes{TaskHallListModel: v}, nil
}
func (c *cTaskHall) Edit(ctx context.Context, req *taskhall.EditReq) (*taskhall.EditRes, error) {
return &taskhall.EditRes{}, service.SysTaskHall().Edit(ctx, &req.TaskHallEditInp)
}
func (c *cTaskHall) Status(ctx context.Context, req *taskhall.StatusReq) (*taskhall.StatusRes, error) {
return &taskhall.StatusRes{}, service.SysTaskHall().Status(ctx, &req.TaskHallStatusInp)
}
func (c *cTaskHall) Delete(ctx context.Context, req *taskhall.DeleteReq) (*taskhall.DeleteRes, error) {
return &taskhall.DeleteRes{}, service.SysTaskHall().Delete(ctx, &req.TaskHallDeleteInp)
}
server/internal/controller/admin/sys/task_submission.go
+37
View File
@@ -0,0 +1,37 @@
package sys
import (
"context"
"hotgo/api/admin/tasksubmission"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var TaskSubmission = cTaskSubmission{}
type cTaskSubmission struct{}
func (c *cTaskSubmission) List(ctx context.Context, req *tasksubmission.ListReq) (res *tasksubmission.ListRes, err error) {
list, total, err := service.SysTaskSubmission().List(ctx, &req.TaskSubmissionListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.TaskSubmissionListModel{}
}
res = new(tasksubmission.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cTaskSubmission) View(ctx context.Context, req *tasksubmission.ViewReq) (res *tasksubmission.ViewRes, err error) {
data, err := service.SysTaskSubmission().View(ctx, &req.TaskSubmissionViewInp)
if err == nil {
res = &tasksubmission.ViewRes{TaskSubmissionListModel: data}
}
return res, err
}
func (c *cTaskSubmission) Review(ctx context.Context, req *tasksubmission.ReviewReq) (res *tasksubmission.ReviewRes, err error) {
err = service.SysTaskSubmission().Review(ctx, &req.TaskSubmissionReviewInp)
return
}
server/internal/controller/admin/sys/test_category.go
+79
View File
@@ -0,0 +1,79 @@
// Package sys
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2024 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.15.7
package sys
import (
"context"
"hotgo/api/admin/testcategory"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var (
TestCategory = cTestCategory{}
)
type cTestCategory struct{}
// List 查看测试分类列表
func (c *cTestCategory) List(ctx context.Context, req *testcategory.ListReq) (res *testcategory.ListRes, err error) {
list, totalCount, err := service.SysTestCategory().List(ctx, &req.TestCategoryListInp)
if err != nil {
return
}
if list == nil {
list = []*sysin.TestCategoryListModel{}
}
res = new(testcategory.ListRes)
res.List = list
res.PageRes.Pack(req, totalCount)
return
}
// Edit 更新测试分类
func (c *cTestCategory) Edit(ctx context.Context, req *testcategory.EditReq) (res *testcategory.EditRes, err error) {
err = service.SysTestCategory().Edit(ctx, &req.TestCategoryEditInp)
return
}
// MaxSort 获取测试分类最大排序
func (c *cTestCategory) MaxSort(ctx context.Context, req *testcategory.MaxSortReq) (res *testcategory.MaxSortRes, err error) {
data, err := service.SysTestCategory().MaxSort(ctx, &req.TestCategoryMaxSortInp)
if err != nil {
return
}
res = new(testcategory.MaxSortRes)
res.TestCategoryMaxSortModel = data
return
}
// View 获取指定测试分类信息
func (c *cTestCategory) View(ctx context.Context, req *testcategory.ViewReq) (res *testcategory.ViewRes, err error) {
data, err := service.SysTestCategory().View(ctx, &req.TestCategoryViewInp)
if err != nil {
return
}
res = new(testcategory.ViewRes)
res.TestCategoryViewModel = data
return
}
// Delete 删除测试分类
func (c *cTestCategory) Delete(ctx context.Context, req *testcategory.DeleteReq) (res *testcategory.DeleteRes, err error) {
err = service.SysTestCategory().Delete(ctx, &req.TestCategoryDeleteInp)
return
}
// Status 更新测试分类状态
func (c *cTestCategory) Status(ctx context.Context, req *testcategory.StatusReq) (res *testcategory.StatusRes, err error) {
err = service.SysTestCategory().Status(ctx, &req.TestCategoryStatusInp)
return
}
server/internal/controller/admin/sys/trade_order.go
+54
View File
@@ -0,0 +1,54 @@
package sys
import (
"context"
"hotgo/api/admin/tradeorder"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var TradeOrder = cTradeOrder{}
type cTradeOrder struct{}
func (c *cTradeOrder) List(ctx context.Context, req *tradeorder.ListReq) (res *tradeorder.ListRes, err error) {
list, total, err := service.SysTradeOrder().List(ctx, &req.TradeOrderListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.TradeOrderListModel{}
}
res = new(tradeorder.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cTradeOrder) View(ctx context.Context, req *tradeorder.ViewReq) (*tradeorder.ViewRes, error) {
v, err := service.SysTradeOrder().View(ctx, &req.TradeOrderViewInp)
return &tradeorder.ViewRes{TradeOrderViewModel: v}, err
}
func (c *cTradeOrder) MatchProducts(ctx context.Context, req *tradeorder.MatchProductsReq) (res *tradeorder.MatchProductsRes, err error) {
list, total, err := service.SysTradeOrder().MatchProducts(ctx, &req.TradeOrderMatchProductListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.TradeOrderMatchProductModel{}
}
res = new(tradeorder.MatchProductsRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cTradeOrder) Match(ctx context.Context, req *tradeorder.MatchReq) (*tradeorder.MatchRes, error) {
return &tradeorder.MatchRes{}, service.SysTradeOrder().Match(ctx, &req.TradeOrderMatchInp)
}
func (c *cTradeOrder) Apply(ctx context.Context, req *tradeorder.ApplyReq) (*tradeorder.ApplyRes, error) {
v, err := service.SysTradeOrder().Apply(ctx, &req.TradeOrderApplyInp)
return &tradeorder.ApplyRes{FinanceApprovalModel: v}, err
}
func (c *cTradeOrder) Execute(ctx context.Context, req *tradeorder.ExecuteReq) (*tradeorder.ExecuteRes, error) {
return &tradeorder.ExecuteRes{}, service.SysTradeOrder().Execute(ctx, &req.TradeOrderExecuteInp)
}
server/internal/controller/admin/sys/withdrawal_order.go
+41
View File
@@ -0,0 +1,41 @@
package sys
import (
"context"
"hotgo/api/admin/withdrawalorder"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
var WithdrawalOrder = cWithdrawalOrder{}
type cWithdrawalOrder struct{}
func (c *cWithdrawalOrder) List(ctx context.Context, req *withdrawalorder.ListReq) (res *withdrawalorder.ListRes, err error) {
list, total, err := service.SysWithdrawalOrder().List(ctx, &req.WithdrawalOrderListInp)
if err != nil {
return nil, err
}
if list == nil {
list = []*sysin.WithdrawalOrderListModel{}
}
res = new(withdrawalorder.ListRes)
res.List = list
res.PageRes.Pack(req, total)
return
}
func (c *cWithdrawalOrder) View(ctx context.Context, req *withdrawalorder.ViewReq) (*withdrawalorder.ViewRes, error) {
v, err := service.SysWithdrawalOrder().View(ctx, &req.WithdrawalOrderViewInp)
return &withdrawalorder.ViewRes{WithdrawalOrderListModel: v}, err
}
func (c *cWithdrawalOrder) Review(ctx context.Context, req *withdrawalorder.ReviewReq) (*withdrawalorder.ReviewRes, error) {
v, err := service.SysWithdrawalOrder().Review(ctx, &req.WithdrawalReviewInp)
return &withdrawalorder.ReviewRes{FinanceApprovalModel: v}, err
}
func (c *cWithdrawalOrder) Execute(ctx context.Context, req *withdrawalorder.ExecuteReq) (*withdrawalorder.ExecuteRes, error) {
return &withdrawalorder.ExecuteRes{}, service.SysWithdrawalOrder().Execute(ctx, &req.FinanceExecuteInp)
}
func (c *cWithdrawalOrder) Complete(ctx context.Context, req *withdrawalorder.CompleteReq) (*withdrawalorder.CompleteRes, error) {
return &withdrawalorder.CompleteRes{}, service.SysWithdrawalOrder().Complete(ctx, &req.WithdrawalCompleteInp)
}
server/internal/controller/api/member/member.go
+5
View File
@@ -0,0 +1,5 @@
// =================================================================================
// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
// =================================================================================
package member
server/internal/controller/api/member/member_new.go
+15
View File
@@ -0,0 +1,15 @@
// =================================================================================
// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
// =================================================================================
package member
import (
"hotgo/api/api/member"
)
type ControllerV1 struct{}
func NewV1() member.IMemberV1 {
return &ControllerV1{}
}
server/internal/controller/api/member/member_v1_get_id_by_code.go
+14
View File
@@ -0,0 +1,14 @@
package member
import (
"context"
v1 "hotgo/api/api/member/v1"
"github.com/gogf/gf/v2/frame/g"
)
func (c *ControllerV1) GetIdByCode(ctx context.Context, req *v1.GetIdByCodeReq) (res *v1.GetIdByCodeRes, err error) {
g.RequestFromCtx(ctx).Response.Writeln("Hello World api member!")
return
}
server/internal/controller/api/pay/pay.go
+5
View File
@@ -0,0 +1,5 @@
// =================================================================================
// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
// =================================================================================
package pay
server/internal/controller/api/pay/pay_new.go
+15
View File
@@ -0,0 +1,15 @@
// =================================================================================
// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
// =================================================================================
package pay
import (
"hotgo/api/api/pay"
)
type ControllerV1 struct{}
func NewV1() pay.IPayV1 {
return &ControllerV1{}
}
server/internal/controller/api/pay/pay_v1_notify_ali_pay.go
+22
View File
@@ -0,0 +1,22 @@
package pay
import (
"context"
v1 "hotgo/api/api/pay/v1"
"hotgo/internal/consts"
"hotgo/internal/library/response"
"hotgo/internal/model/input/payin"
"hotgo/internal/service"
"github.com/gogf/gf/v2/frame/g"
)
func (c *ControllerV1) NotifyAliPay(ctx context.Context, req *v1.NotifyAliPayReq) (res *v1.NotifyAliPayRes, err error) {
if _, err = service.Pay().Notify(ctx, &payin.PayNotifyInp{PayType: consts.PayTypeAliPay}); err != nil {
return nil, err
}
response.RText(g.RequestFromCtx(ctx), "success")
return
}
server/internal/controller/api/pay/pay_v1_notify_qq_pay.go
+26
View File
@@ -0,0 +1,26 @@
package pay
import (
"context"
v1 "hotgo/api/api/pay/v1"
"hotgo/internal/consts"
"hotgo/internal/model/input/payin"
"hotgo/internal/service"
"github.com/gogf/gf/v2/frame/g"
)
func (c *ControllerV1) NotifyQQPay(ctx context.Context, req *v1.NotifyQQPayReq) (res *v1.NotifyQQPayRes, err error) {
if _, err = service.Pay().Notify(ctx, &payin.PayNotifyInp{PayType: consts.PayTypeQQPay}); err != nil {
return
}
r := g.RequestFromCtx(ctx)
r.Response.ClearBuffer()
r.Response.Write(`<?xml version="1.0" encoding="UTF-8"?>`)
r.Response.WriteXml(g.Map{
"return_code": "SUCCESS",
})
return
}
server/internal/controller/api/pay/pay_v1_notify_wx_pay.go
+22
View File
@@ -0,0 +1,22 @@
package pay
import (
"context"
v1 "hotgo/api/api/pay/v1"
"hotgo/internal/consts"
"hotgo/internal/library/response"
"hotgo/internal/model/input/payin"
"hotgo/internal/service"
"github.com/gogf/gf/v2/frame/g"
)
func (c *ControllerV1) NotifyWxPay(ctx context.Context, req *v1.NotifyWxPayReq) (res *v1.NotifyWxPayRes, err error) {
if _, err = service.Pay().Notify(ctx, &payin.PayNotifyInp{PayType: consts.PayTypeWxPay}); err != nil {
return
}
response.CustomJson(g.RequestFromCtx(ctx), `{"code": "SUCCESS","message": "收单成功"}`)
return
}
server/internal/controller/home/base/site.go
+38
View File
@@ -0,0 +1,38 @@
// Package base
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package base
import (
"context"
"github.com/gogf/gf/v2/frame/g"
"hotgo/api/home/base"
"hotgo/internal/consts"
"hotgo/internal/model"
"hotgo/internal/service"
"hotgo/utility/simple"
)
// Site 基础
var Site = cSite{}
type cSite struct{}
func (a *cSite) Index(ctx context.Context, _ *base.SiteIndexReq) (res *base.SiteIndexRes, err error) {
service.View().Render(ctx, model.View{Data: g.Map{
"name": simple.AppName(ctx),
"version": consts.VersionApp,
}})
// err = gerror.New("这是一个测试错误")
// return
// err = gerror.NewCode(gcode.New(10000, "这是一个测试自定义错误码错误", nil))
// return
// service.View().Error(ctx, gerror.New("这是一个允许被自定义格式的错误，默认和通用错误格式一致，你可以修改它"))
// return
return
}
server/internal/controller/websocket/handler/admin/monitor.go
+198
View File
@@ -0,0 +1,198 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"fmt"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/util/gconv"
"github.com/shirou/gopsutil/v3/cpu"
"github.com/shirou/gopsutil/v3/disk"
"github.com/shirou/gopsutil/v3/host"
"github.com/shirou/gopsutil/v3/mem"
"github.com/shirou/gopsutil/v3/process"
"hotgo/internal/consts"
"hotgo/internal/model"
"hotgo/internal/service"
"hotgo/internal/websocket"
"hotgo/utility/file"
"hotgo/utility/format"
"hotgo/utility/simple"
"os"
"runtime"
"time"
)
var (
Monitor = cMonitor{}
)
type cMonitor struct{}
type MonitorHeadExtra struct {
Data interface{} `json:"data"`
Data1 string `json:"data1,omitempty"`
}
type MonitorHead struct {
Title string `json:"title"`
Data string `json:"data"`
BottomTitle string `json:"bottomTitle"`
TotalSum string `json:"totalSum"`
IconClass string `json:"iconClass"`
Extra MonitorHeadExtra `json:"extra"`
}
// RunInfo 运行信息
func (c *cMonitor) RunInfo(client *websocket.Client, req *websocket.WRequest) {
var (
meta = service.AdminMonitor().GetMeta(client.Context())
mHost, _ = host.Info()
pwd, _ = os.Getwd()
gm runtime.MemStats
)
runtime.ReadMemStats(&gm)
data := g.Map{
// 服务器信息
"hostname": mHost.Hostname,
"os": mHost.OS,
"arch": mHost.KernelArch,
"intranet_ip": meta.IntranetIP,
"public_ip": meta.PublicIP,
// 运行信息
"version": runtime.Version(), // GO 版本
"hgVersion": consts.VersionApp, // HG 版本
"startTime": gtime.New(meta.STartTime),
"runTime": gtime.Now().Timestamp() - meta.STartTime,
"rootPath": runtime.GOROOT(),
"pwd": pwd,
"goroutine": runtime.NumGoroutine(),
"goMem": format.FileSize(int64(gm.Sys)),
"goSize": file.DirSize(pwd),
}
if simple.IsDemo(client.Context()) {
data["rootPath"] = consts.DemoTips
data["pwd"] = consts.DemoTips
data["intranet_ip"] = consts.DemoTips
data["public_ip"] = consts.DemoTips
}
websocket.SendSuccess(client, req.Event, data)
}
// Trends 实时数据
func (c *cMonitor) Trends(client *websocket.Client, req *websocket.WRequest) {
type NetC struct {
Time *gtime.Time `json:"time"`
BytesSent string `json:"bytesSent"` // number of bytes sent
BytesRecv string `json:"bytesRecv"` // number of bytes received
Down float64 `json:"down"`
UP float64 `json:"up"`
}
var (
mCpu, cpuErr = cpu.Info()
mCpuUsed float64
mMem, memErr = mem.VirtualMemory()
mMemUsed float64
mDisk, diskErr = disk.Usage("/")
mProcess, processErr = process.Pids()
mLoadAvg = new(model.LoadAvgStats)
monitorHeads []MonitorHead
nets []NetC
meta = service.AdminMonitor().GetMeta(client.Context())
)
if cpuErr != nil {
g.Log().Infof(client.Context(), "read CPU info fail:%+v", cpuErr)
mCpu = []cpu.InfoStat{{VendorID: "", ModelName: ""}}
}
if memErr != nil {
g.Log().Infof(client.Context(), "read mem info fail:%+v", memErr)
mMem = new(mem.VirtualMemoryStat)
}
if diskErr != nil {
g.Log().Infof(client.Context(), "read disk info fail:%+v", diskErr)
mDisk = new(disk.UsageStat)
}
if processErr != nil {
g.Log().Infof(client.Context(), "read process.Pids fail:%+v", processErr)
}
// cpu使用率
cu, err := cpu.Percent(time.Second, false)
if err == nil {
mCpuUsed = gconv.Float64(fmt.Sprintf("%.2f", cu[0]))
}
// 内存使用率
mMemUsed = gconv.Float64(fmt.Sprintf("%.2f", mMem.UsedPercent))
// 负载
if len(meta.LoadAvg) > 0 {
mLoadAvg = meta.LoadAvg[len(meta.LoadAvg)-1]
}
monitorHeads = append(monitorHeads, MonitorHead{
Title: "CPU",
Data: "使用率 " + format.Round2String(mCpuUsed) + "%",
BottomTitle: "CPU数量",
TotalSum: gconv.String(runtime.NumCPU()) + "核心",
IconClass: "HardwareChip",
Extra: MonitorHeadExtra{
Data: mCpu[0].VendorID,
Data1: mCpu[0].ModelName,
}},
MonitorHead{
Title: "内存",
Data: "使用率 " + format.Round2String(mMemUsed) + "%",
BottomTitle: "总内存",
TotalSum: format.FileSize(int64(mMem.Total)),
IconClass: "AppsSharp",
Extra: MonitorHeadExtra{
Data: format.FileSize(int64(mMem.Used)),
Data1: format.FileSize(int64(mMem.Total - mMem.Used)),
}},
MonitorHead{
Title: "磁盘",
Data: "已用 " + format.FileSize(int64(mDisk.Used)),
BottomTitle: "总容量",
TotalSum: format.FileSize(int64(mDisk.Total)),
IconClass: "PieChart",
Extra: MonitorHeadExtra{
Data: format.Round2String(mDisk.UsedPercent),
}},
MonitorHead{
Title: "负载",
Data: format.Round2String(mLoadAvg.Ratio) + "%",
BottomTitle: "总进程数",
TotalSum: gconv.String(len(mProcess)) + "个",
IconClass: "Analytics",
})
for _, v := range meta.NetIO {
nets = append(nets, NetC{
Time: v.Time,
BytesSent: format.FileSize(int64(v.BytesSent)), // 转换为最大整数单位
BytesRecv: format.FileSize(int64(v.BytesRecv)),
Down: format.Round2Float64(v.Down / 1024), // 转换为kb
UP: format.Round2Float64(v.UP / 1024),
})
}
websocket.SendSuccess(client, req.Event, g.Map{
"head": monitorHeads,
"load": meta.LoadAvg,
"net": nets,
})
}
server/internal/controller/websocket/handler/common/site.go
+39
View File
@@ -0,0 +1,39 @@
// Package common
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package common
import (
"github.com/gogf/gf/v2/util/gconv"
"hotgo/internal/websocket"
)
var (
Site = cSite{}
)
type cSite struct{}
func (c *cSite) Join(client *websocket.Client, req *websocket.WRequest) {
name := gconv.String(req.Data["id"])
if !client.Tags.Contains(name) {
client.Tags.Append(name)
}
websocket.SendSuccess(client, req.Event, client.Tags.Slice())
}
func (c *cSite) Quit(client *websocket.Client, req *websocket.WRequest) {
name := gconv.String(req.Data["id"])
if client.Tags.Contains(name) {
client.Tags.RemoveValue(name)
}
websocket.SendSuccess(client, req.Event, client.Tags.Slice())
}
func (c *cSite) Ping(client *websocket.Client, req *websocket.WRequest) {
websocket.SendSuccess(client, req.Event)
}
server/internal/controller/websocket/send.go
+29
View File
@@ -0,0 +1,29 @@
// Package websocket
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package websocket
import (
"context"
"hotgo/api/websocket/base"
"hotgo/internal/websocket"
"hotgo/utility/simple"
)
// Send 通过http发送ws消息
var Send = send{}
type send struct{}
// SendToTag 发送标签消息
func (c *send) SendToTag(ctx context.Context, req *base.SendToTagReq) (res *base.SendToTagRes, err error) {
simple.SafeGo(ctx, func(ctx context.Context) {
websocket.SendToTag(req.Tag, &websocket.WResponse{
Event: req.Response.Event,
Data: req.Response,
})
})
return
}