新中控接口第一次提交

api/v1/enter.go

@@ -7,6 +7,7 @@ import (
 	"log-server/api/v1/fileManager"
 	"log-server/api/v1/levelMonitor"
 	"log-server/api/v1/log"
+	"log-server/api/v1/newCentralControl"
 	"log-server/api/v1/rentComputer"
 	"log-server/api/v1/system"
 	"log-server/api/v1/task"
@@ -14,17 +15,18 @@ import (
 )
 
 type ApiGroup struct {
-	SystemApiGroup       system.ApiGroup
-	ExampleApiGroup      example.ApiGroup
-	GameTaskApiGroup     task.GameTaskApi
-	LogApiGroup          log.GroupLog
-	TypeApiGroup         typeManage.ApiGroup
-	GroupTask            task.GroupTask
-	RentComputerApiGroup rentComputer.ApiGroup
-	DataStatisticsGroup  dataStatistics.ApiGroup
-	FileManagerGroup     fileManager.ApiGroup
-	IdCardGroup          card.ApiGroup
-	LevelMonitorGroup    levelMonitor.ApiGroup
+	SystemApiGroup         system.ApiGroup
+	ExampleApiGroup        example.ApiGroup
+	GameTaskApiGroup       task.GameTaskApi
+	LogApiGroup            log.GroupLog
+	TypeApiGroup           typeManage.ApiGroup
+	GroupTask              task.GroupTask
+	NewCentralControlGroup newCentralControl.GroupNewCentralControl
+	RentComputerApiGroup   rentComputer.ApiGroup
+	DataStatisticsGroup    dataStatistics.ApiGroup
+	FileManagerGroup       fileManager.ApiGroup
+	IdCardGroup            card.ApiGroup
+	LevelMonitorGroup      levelMonitor.ApiGroup
 }
 
 var ApiGroupApp = new(ApiGroup)

api/v1/newCentralControl/computer_task.go

@@ -0,0 +1,177 @@
+package newCentralControl
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"log-server/global"
+	"log-server/model/common/request"
+	"log-server/model/common/response"
+	"log-server/model/newCentralControl"
+	newCentralControlRequest "log-server/model/newCentralControl/request"
+	"log-server/utils"
+)
+
+type ComputerTaskApi struct {
+}
+
+//创建电脑任务
+func (a *ComputerTaskApi) CreateComputerTask (c *gin.Context) {
+	var task newCentralControl.ComputerTask
+	_ = c.ShouldBindJSON(&task)
+	if err := utils.Verify(task, utils.ComputerTaskVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := computerTaskService.CreateComputerTask(task); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Error(err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+//删除电脑任务列表
+func (a *ComputerTaskApi) DeleteComputerTask (c *gin.Context) {
+	var task newCentralControl.ComputerTask
+	_ = c.ShouldBindJSON(&task)
+	//数据校验
+	if err := utils.Verify(task, utils.ComputerTaskVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := computerTaskService.DeleteComputerTask(task); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+
+}
+
+//更新电脑任务列表
+func (a *ComputerTaskApi) UpdateComputerTask (c *gin.Context) {
+	var task newCentralControl.ComputerTask
+	_ = c.ShouldBindJSON(&task)
+	//数据校验
+	if err := utils.Verify(task, utils.ComputerTaskVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := computerTaskService.UpdateComputerTask(task); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Error(err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+//通过id单独获取电脑任务
+func (a *ComputerTaskApi) GetComputerTaskById (c *gin.Context)  {
+	var id request.GetById
+	_ = c.ShouldBindJSON(&id)
+	if err := utils.Verify(id, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if task, err := computerTaskService.GetComputerTaskById(id.ID); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	}else {
+		response.OkWithDetailed(task, "获取成功", c)
+	}
+}
+
+//更改任务状态
+func (a *ComputerTaskApi) StatusChange (c *gin.Context)  {
+	var paramsInfo newCentralControlRequest.UpdateTaskStatus
+	_ = c.ShouldBindJSON(&paramsInfo)
+	if paramsInfo.Status == 0 {
+		response.FailWithMessage("状态值不能为空", c)
+		return
+	}
+	if paramsInfo.Id == 0 {
+		response.FailWithMessage("Id不能为空", c)
+		return
+	}
+	if err := computerTaskService.UpdateTaskStatus(paramsInfo); err != nil {
+		global.GVA_LOG.Error("修改失败!", zap.Error(err))
+		response.FailWithMessage(err.Error(), c)
+	} else {
+		response.OkWithMessage("修改成功", c)
+	}
+}
+
+//显示电脑任务列表
+func (a *ComputerTaskApi) GetComputerTaskList (c *gin.Context) {
+	var pageInfo newCentralControlRequest.SearchComputerTaskParams
+	_ = c.ShouldBindJSON(&pageInfo)
+	//页面信息校验
+	if err := utils.Verify(pageInfo.PageInfo, utils.PageInfoVerify); err != nil{
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if list, total, err := computerTaskService.GetComputerTaskList(pageInfo.ComputerTask, pageInfo.PageInfo, pageInfo.OrderKey, pageInfo.Desc); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}
+
+//获取游戏配置项
+func (a *ComputerTaskApi) GetGameConfInfo (c * gin.Context) {
+	info, err := computerTaskService.GetGameConfInfo()
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	}else {
+		response.OkWithDetailed(info, "获取成功", c)
+	}
+}
+
+//获取下发任务
+func (a *ComputerTaskApi) GetRunningTasks(c *gin.Context) {
+	pcCode := c.Query("pc_code")
+	if pcCode == "" {
+		response.FailWithMessage("电脑编号不能为空", c)
+		return
+	}
+	err, list := computerTaskService.GetRunningTasks(pcCode)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(list, "获取成功", c)
+	}
+}
+
+//上传租机编号
+func (a *ComputerTaskApi) UploadPcInfo(c *gin.Context) {
+	pcCode := c.Query("pc_code")
+	pcName := c.Query("pc_name")
+	user := c.Query("user")
+	if pcCode == "" {
+		response.FailWithMessage("电脑编号不能为空", c)
+		return
+	}
+	if pcName == "" {
+		response.FailWithMessage("电脑名不能为空", c)
+		return
+	}
+	if user == "" {
+		response.FailWithMessage("负责人不能为空", c)
+		return
+	}
+	if err := computerTaskService.UploadPcInfo(pcCode, pcName, user); err!= nil {
+		global.GVA_LOG.Error("上传失败!", zap.Error(err))
+		response.FailWithMessage("上传失败", c)
+	} else {
+		response.OkWithMessage("上传成功", c)
+	}
+
+}

api/v1/newCentralControl/enter.go

@@ -0,0 +1,13 @@
+package newCentralControl
+
+import "log-server/service"
+
+type GroupNewCentralControl struct {
+	GameConfApi
+	ComputerTaskApi
+}
+
+var (
+	gameConfService     = service.ServiceGroupApp.NewCentralControlServiceGroup.GameConfService
+	computerTaskService = service.ServiceGroupApp.NewCentralControlServiceGroup.ComputerTaskService
+)

api/v1/newCentralControl/game_conf.go

@@ -0,0 +1,118 @@
+package newCentralControl
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"log-server/global"
+	"log-server/model/common/request"
+	"log-server/model/common/response"
+	"log-server/model/newCentralControl"
+	newCentralControlRequest "log-server/model/newCentralControl/request"
+	"log-server/utils"
+)
+
+type GameConfApi struct {
+
+}
+
+//创建游戏配置
+func (a *GameConfApi) CreateGameConf (c *gin.Context) {
+	var conf newCentralControl.GameConf
+	_ = c.ShouldBindJSON(&conf)
+
+	if conf.Mirror == "" {
+		response.FailWithMessage("请传入镜像名称", c)
+		return
+	}
+	if conf.Script == "" {
+		response.FailWithMessage("请传入脚本名称", c)
+		return
+	}
+
+	if err := utils.Verify(conf, utils.GameConfVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := gameConfService.CreateGameConf(conf);err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Error(err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+//删除游戏配置
+func (a *GameConfApi) DeleteGameConf(c *gin.Context)  {
+	var conf newCentralControl.GameConf
+	_ = c.ShouldBindJSON(&conf)
+	//数据校验
+	if err := utils.Verify(conf, utils.GameConfVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := gameConfService.DeleteGameConf(conf); err != nil{
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+//编辑游戏配置
+func (a *GameConfApi) UpdateGameConf(c *gin.Context) {
+	var conf newCentralControl.GameConf
+	_ = c.ShouldBindJSON(&conf)
+	//数据校验
+
+	fmt.Println(conf)
+
+	if err := utils.Verify(conf, utils.GameConfVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := gameConfService.UpdateGameConf(conf); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Error(err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+//id获取游戏配置
+func (a *GameConfApi) GetGameConfById(c *gin.Context) {
+	var id request.GetById
+	_ = c.ShouldBindJSON(&id)
+	if err := utils.Verify(id, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if conf,err := gameConfService.GetGameConfById(id.ID); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	}else {
+		response.OkWithDetailed(conf, "获取成功", c)
+	}
+}
+
+//获取游戏配置列表
+func (a *GameConfApi) GetGameConfList(c *gin.Context) {
+	var pageInfo newCentralControlRequest.SearchGameConfParams
+	_ = c.ShouldBindJSON(&pageInfo)
+	//页面信息校验
+	if err := utils.Verify(pageInfo.PageInfo, utils.PageInfoVerify); err != nil{
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if list, total, err := gameConfService.GetGameConfList(pageInfo.GameConf, pageInfo.PageInfo, pageInfo.OrderKey, pageInfo.Desc); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

initialize/router.go

@@ -24,6 +24,8 @@ func Routers() *gin.Engine {
 	uploadFileRouter := router.RouterGroupApp.UploadFile
 	centralControlRouter := router.RouterGroupApp.CentralControl
 	urgentTaskRouter := router.RouterGroupApp.UrgentTask
+	computerTaskRouter := router.RouterGroupApp.ComputerTask
+	gameConfRouter := router.RouterGroupApp.GameConf
 	ipLogRouter := router.RouterGroupApp.IpLog
 	idCardRouter := router.RouterGroupApp.IdCard
 	typeManageRouter := router.RouterGroupApp.TypeManage
@@ -71,6 +73,8 @@ func Routers() *gin.Engine {
 		typeManageRouter.InitAccountTypeRouter(PublicGroup)       //账号类型路由
 		ipLogRouter.InitIpLogRouter(PublicGroup)                  //ip日志路由
 		idCardRouter.InitIdCardRouter(PublicGroup)                //身份证路由
+		computerTaskRouter.InitComputerTaskRouter(PublicGroup)	  //新中控电脑任务配置路由
+		gameConfRouter.InitGameConfRouter(PublicGroup)			  //游戏配置路由
 		taskRouter.InitGameTaskRouter(PublicGroup)
 		uploadFileRouter.InitUploadFileRouter(PublicGroup)
 		centralControlRouter.InitCentralControlRouter(PublicGroup) //中控配置

model/newCentralControl/computer_task.go

@@ -0,0 +1,27 @@
+package newCentralControl
+
+import "log-server/model/typeManage"
+
+type ComputerTask struct {
+	Id         int                  `json:"id"`
+	PcCode     string               `json:"pc_code"`   //租机编号
+	TaskId     int                  `json:"task_id"`   //任务id
+	ConfId     int                  `json:"conf_id"`   //游戏配置id
+	TaskName   string               `json:"task_name"` //任务名称
+	ConfName   string               `json:"conf_name"` //配置名称
+	Status     int                  `json:"status"`    //status：-1停止 ，1运行
+	CreateTime typeManage.LocalTime `json:"create_time"`
+	UpdateTime typeManage.LocalTime `json:"update_time"`
+}
+
+type GameConfInfo struct {
+	TaskId     int                  `json:"task_id"`   //任务id
+	ConfId     int                  `json:"conf_id"`    //游戏配置id
+	TaskName   string               `json:"task_name"` //任务名称
+	ConfName   string               `json:"conf_name"` //配置名称
+}
+
+
+func (ComputerTask) TableName() string {
+	return "computer_task"
+}

model/newCentralControl/game_conf.go

@@ -0,0 +1,39 @@
+package newCentralControl
+
+import "log-server/model/typeManage"
+
+type GameConf struct {
+	Id            int                  `json:"id"`
+	ConfName      string               `json:"conf_name"`      //配置名
+	WindowsNumber int                  `json:"windows_number"` //窗口数
+	Mirror        string               `json:"mirror"`         //镜像
+	Script        string               `json:"script"`         //脚本
+	CloneMode     int                  `json:"clone_mode"`     //克隆模式
+	SimulatorType int                  `json:"simulator_type"` //模拟器类型
+	Resolution    string               `json:"resolution"`     //分辨率
+	Zoom          string               `json:"zoom"`           //缩放
+	Timeout       int                  `json:"timeout"`        //超时时间
+	Cpu           int                  `json:"cpu"`            //cpu
+	MemorySize    int                  `json:"memory_size"`    //内存
+	TaskId        int                  `json:"task_id"`        //任务id
+	GameId        int                  `json:"game_id"`        //游戏id
+	Priority      string               `json:"priority"`       //优先级
+	GameType      int                  `json:"game_type"`      //任务类型
+	TxChannel     string               `json:"tx_channel"`     //'腾讯渠道号',
+	TxGameId      string               `json:"tx_game_id"`     //'腾讯游戏id',
+	MzChannel     string               `json:"mz_channel"`     //'魅族渠道号',
+	MzGameId      string               `json:"mz_game_id"`     //'魅族游戏id',
+	PayPrice      int                  `json:"pay_price"`      //'付费单价',
+	MirrorUpdate  string               `json:"mirror_update"`  //镜像是否更新
+	ScriptUpdate  string               `json:"script_update"`  //脚本是否更新
+	TaskAccount   int                  `json:"task_account"`   //任务下发账号类型，-1：只做新增，0：没有要求.1：只做留存
+	Md5Verify     string               `json:"md5_verify"`     //md5校验
+	PayQuit       string               `json:"pay_quit"`       //做完付费就退
+	ProxyType     int                  `json:"proxy_type"`     //代理类型，1多开王 2无忧ip
+	CreateTime    typeManage.LocalTime `json:"create_time"`
+	UpdateTime    typeManage.LocalTime `json:"update_time"`
+}
+
+func (GameConf) TableName() string {
+	return "game_conf"
+}

model/newCentralControl/pc_code.go

@@ -0,0 +1,17 @@
+package newCentralControl
+
+import "log-server/model/typeManage"
+
+type PcInfo struct {
+	Id         int                  `json:"id"`
+	PcCode     string               `json:"pc_code"`   //租机编号
+	PcName     string               `json:"pc_name"`   //租机名称
+	User       string               `json:"user"`   //负责人
+	//Status     int                  `json:"status"`    //status：-1停止 ，1运行
+	CreateTime typeManage.LocalTime `json:"create_time"`
+	UpdateTime typeManage.LocalTime `json:"update_time"`
+}
+
+func (PcInfo) TableName() string {
+	return "pc_info"
+}

model/newCentralControl/request/search_computer_task_params.go

@@ -0,0 +1,16 @@
+package request
+
+import (
+	"log-server/model/common/request"
+	"log-server/model/newCentralControl"
+)
+
+type SearchComputerTaskParams struct {
+	newCentralControl.ComputerTask
+	request.PageInfo
+	OrderKey string `json:"orderKey"` // 排序
+	Desc     bool   `json:"desc"`     // 排序方式:升序false(默认)|降序true
+
+
+}
+

model/newCentralControl/request/search_game_conf_params.go

@@ -0,0 +1,14 @@
+package request
+
+import (
+	"log-server/model/common/request"
+	"log-server/model/newCentralControl"
+)
+
+type SearchGameConfParams struct {
+	newCentralControl.GameConf
+	request.PageInfo
+	OrderKey string `json:"orderKey"` // 排序
+	Desc     bool   `json:"desc"`     // 排序方式:升序false(默认)|降序true
+
+}

model/newCentralControl/request/update_task_status.go

@@ -0,0 +1,6 @@
+package request
+
+type UpdateTaskStatus struct {
+	Status int `json:"status"` // 状态-1关闭，1开启
+	Id     int `json:"id"`
+}

router/enter.go

@@ -7,6 +7,7 @@ import (
 	"log-server/router/fileManager"
 	"log-server/router/levelMonitor"
 	"log-server/router/log"
+	"log-server/router/newCentralControl"
 	"log-server/router/rentComputer"
 	"log-server/router/system"
 	"log-server/router/task"
@@ -22,6 +23,8 @@ type RouterGroup struct {
 	Task           task.GameTaskRouter
 	UploadFile     task.UploadFileRouter
 	CentralControl task.CentralControlRouter
+	GameConf       newCentralControl.GameConfRouter
+	ComputerTask   newCentralControl.ComputerTaskRouter
 	UrgentTask     task.UrgentTaskRouter
 	RentComputer   rentComputer.RouterGroup
 	DataStatistics dataStatistics.RouterGroup

router/newCentralControl/computer_task.go

@@ -0,0 +1,30 @@
+package newCentralControl
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "log-server/api/v1"
+	"log-server/middleware"
+)
+
+type ComputerTaskRouter struct {
+}
+
+func (r *ComputerTaskRouter) InitComputerTaskRouter(Router *gin.RouterGroup) {
+	computerTaskRouter := Router.Group("newCentralControl")
+	computerTaskApi := v1.ApiGroupApp.NewCentralControlGroup.ComputerTaskApi
+	{
+		computerTaskRouter.GET("getRunningTasks", computerTaskApi.GetRunningTasks)          //获取下发任务
+		computerTaskRouter.POST("getComputerTaskList", computerTaskApi.GetComputerTaskList) //获取电脑任务列表
+		computerTaskRouter.GET("uploadPcInfo", computerTaskApi.UploadPcInfo)                //上传电脑信息
+		computerTaskRouter.GET("getGameConfInfo", computerTaskApi.GetGameConfInfo)          //获取游戏配置信息
+		computerTaskRouter.POST("getComputerTaskById", computerTaskApi.GetComputerTaskById) //单个获取电脑任务
+	}
+
+	computerTaskRouter1 := Router.Group("newCentralControl").Use(middleware.OperationRecord())
+	{
+		computerTaskRouter1.POST("createComputerTask", computerTaskApi.CreateComputerTask) //创建电脑任务
+		computerTaskRouter1.POST("updateComputerTask", computerTaskApi.UpdateComputerTask) //更新电脑任务
+		computerTaskRouter1.POST("deleteComputerTask", computerTaskApi.DeleteComputerTask) //删除电脑任务
+		computerTaskRouter1.POST("taskStatusChange", computerTaskApi.StatusChange)         //更新任务状态
+	}
+}

router/newCentralControl/enter.go

@@ -0,0 +1,6 @@
+package newCentralControl
+
+type RouterGroup struct {
+	GameConfRouter
+	ComputerTaskRouter
+}

router/newCentralControl/game_conf.go

@@ -0,0 +1,29 @@
+package newCentralControl
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "log-server/api/v1"
+	"log-server/middleware"
+)
+
+type GameConfRouter struct {
+}
+
+func (r *GameConfRouter) InitGameConfRouter(Router *gin.RouterGroup) {
+	gameConfRouter := Router.Group("newCentralControl")
+	gameConfApi := v1.ApiGroupApp.NewCentralControlGroup.GameConfApi
+	{
+		gameConfRouter.POST("getGameConfList", gameConfApi.GetGameConfList) //获取游戏配置列表
+		gameConfRouter.POST("getGameConfById", gameConfApi.GetGameConfById) //通过id单个获取游戏配置
+
+	}
+
+	gameConfRouter1 := Router.Group("newCentralControl").Use(middleware.OperationRecord())
+	{
+		gameConfRouter1.POST("createGameConf", gameConfApi.CreateGameConf)             //创建游戏配置
+		gameConfRouter1.POST("updateGameConf", gameConfApi.UpdateGameConf)				//更新游戏配置
+		//gameConfRouter1.POST("deleteGameConf", gameConfApi.DeleteGameConf)             //单个删除游戏配置
+		//gameConfRouter1.DELETE("deleteGameConfByIds", gameConfApi.DeleteGameConfByIds) //批量删除游戏配置
+		//gameConfRouter1.POST("updateGameConf", gameConfApi.UpdateGameConf)             //更新游戏配置
+	}
+}

service/enter.go

@@ -7,6 +7,7 @@ import (
 	"log-server/service/fileManager"
 	"log-server/service/levelMonitor"
 	"log-server/service/log"
+	"log-server/service/newCentralControl"
 	"log-server/service/rentComputer"
 	"log-server/service/system"
 	"log-server/service/task"
@@ -14,16 +15,17 @@ import (
 )
 
 type ServiceGroup struct {
-	SystemServiceGroup         system.ServiceGroup
-	ExampleServiceGroup        example.ServiceGroup
-	LogServiceGroup            log.ServiceGroup
-	TypeServiceGroup           typeManage.ServiceGroup
-	TaskServiceGroup           task.ServiceGroup
-	RentComputerServiceGroup   rentComputer.ServiceGroup
-	DataStatisticsServiceGroup dataStatistics.ServiceGroup
-	FileManagerServiceGroup    fileManager.ServiceGroup
-	CardServiceGroup           card.ServiceGroup
-	LevelMonitorServiceGroup   levelMonitor.ServiceGroup
+	SystemServiceGroup            system.ServiceGroup
+	ExampleServiceGroup           example.ServiceGroup
+	LogServiceGroup               log.ServiceGroup
+	TypeServiceGroup              typeManage.ServiceGroup
+	TaskServiceGroup              task.ServiceGroup
+	RentComputerServiceGroup      rentComputer.ServiceGroup
+	DataStatisticsServiceGroup    dataStatistics.ServiceGroup
+	FileManagerServiceGroup       fileManager.ServiceGroup
+	CardServiceGroup              card.ServiceGroup
+	LevelMonitorServiceGroup      levelMonitor.ServiceGroup
+	NewCentralControlServiceGroup newCentralControl.ServiceGroup
 }
 
 var ServiceGroupApp = new(ServiceGroup)

service/newCentralControl/computer_task.go

@@ -0,0 +1,157 @@
+package newCentralControl
+
+import (
+	"errors"
+	"fmt"
+	"gorm.io/gorm"
+	"log-server/global"
+	"log-server/model/common/request"
+	"log-server/model/newCentralControl"
+	newCentralControlRequest "log-server/model/newCentralControl/request"
+)
+
+type ComputerTaskService struct {
+}
+
+//创建电脑任务
+func (s *ComputerTaskService) CreateComputerTask(task newCentralControl.ComputerTask) (err error) {
+	var entity newCentralControl.ComputerTask
+	//查找此电脑编号和此配置id是否存在
+	err = global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Where("pc_code = ? and conf_id = ?", task.PcCode, task.ConfId).First(&entity).Error
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("此电脑已添加此任务配置，请勿重复添加")
+	}
+	return global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Omit("create_time", "update_time").Create(&task).Error
+}
+
+//删除电脑任务
+func (s *ComputerTaskService) DeleteComputerTask(task newCentralControl.ComputerTask) (err error) {
+	var entity newCentralControl.ComputerTask
+	err = global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Where("id", task.Id).First(&entity).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("此配置不存在，无法删除")
+	}
+	return global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Delete(&entity).Error
+
+}
+
+//更新电脑任务
+func (s *ComputerTaskService) UpdateComputerTask(task newCentralControl.ComputerTask) (err error) {
+	var entity newCentralControl.ComputerTask
+	err = global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Where("id != ? and pc_code = ? and task_id = ?", task.Id, task.PcCode, task.TaskId).First(&entity).Error
+	if !errors.Is(err, gorm.ErrRecordNotFound){
+		return errors.New("已存在相同的任务，无法更改")
+	}
+	return global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Where("id", task.Id).Omit("create_time", "update_time").Updates(&task).Error
+}
+
+//单个获取电脑任务
+func (s *ComputerTaskService) GetComputerTaskById(id int) (task newCentralControl.ComputerTask, err error) {
+	err = global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Where("id", id).First(&task).Error
+	return task, err
+}
+
+//更新任务状态
+func (s *ComputerTaskService) UpdateTaskStatus (req newCentralControlRequest.UpdateTaskStatus) (err error) {
+	var entity newCentralControl.ComputerTask
+	err = global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Where("id", req.Id).First(&entity).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("请传入正确的Id")
+	}
+	//更新状态
+	return global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Where("id", req.Id).Update("status", req.Status).Error
+}
+
+
+//中控获取下发电脑任务
+func (s *ComputerTaskService) GetRunningTasks(pcCode string) (err error, confList []newCentralControl.GameConf) {
+	//根据电脑编号查询出配置id，根据配置id查询出具体配置
+	var taskList []newCentralControl.ComputerTask
+	var confIdList []int
+	err = global.GVA_DB.Model(&newCentralControl.ComputerTask{}).Where("pc_code = ? and status = 1", pcCode).Find(&taskList).Error
+	//fmt.Println(taskList)
+	if err != nil {
+		return err,confList
+	}
+	for k,_ := range taskList {
+		confIdList = append(confIdList, taskList[k].ConfId)
+	}
+	//fmt.Println("hahah")
+	//fmt.Println(confIdList)
+	err = global.GVA_DB.Model(&newCentralControl.GameConf{}).Where("id in ?", confIdList).Find(&confList).Error
+	return err,confList
+}
+
+//上传电脑信息
+func (s *ComputerTaskService) UploadPcInfo(pcCode string, pcName string, user string) (err error){
+	var info newCentralControl.PcInfo
+	var entity newCentralControl.PcInfo
+	info.PcCode = pcCode
+	info.PcName = pcName
+	info.User = user
+	err = global.GVA_DB.Model(&newCentralControl.PcInfo{}).Where("pc_code = ?", pcCode).First(&entity).Error
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("此电脑编号已存在，请勿重复添加")
+	}
+	return global.GVA_DB.Model(&newCentralControl.PcInfo{}).Omit("create_time", "update_time").Create(&info).Error
+}
+
+//获取电脑任务列表
+func (s *ComputerTaskService) GetComputerTaskList(task newCentralControl.ComputerTask, info request.PageInfo, order string, desc bool) (list interface{}, total int64, err error) {
+	//获取limit和offset
+	limit := info.PageSize
+	offset := (info.Page - 1) * info.PageSize
+	db := global.GVA_DB.Model(&newCentralControl.ComputerTask{})
+	var taskList []newCentralControl.ComputerTask
+
+	//先条件过滤
+	if task.TaskId != 0 {
+		//条件过滤记录数
+		db = db.Where("task_id", task.TaskId)
+	}
+
+	err = db.Count(&total).Error
+	if err != nil{
+		//如果出错直接返回
+		return taskList, total, err
+	} else {
+		//先分页再排序
+		db = db.Limit(limit).Offset(offset)
+		if order != ""{
+			//传入排序字段，进行排序
+			//定义orderStr存储完整的排序字段
+			var  orderStr string
+			//为了避免sql注入，自己创建数组匹配
+			orderMap := make(map[string]bool, 3)
+			orderMap["task_id"] = true
+			orderMap["create_time"] = true
+			orderMap["update_time"] = true
+			if orderMap[order] {
+				if desc {
+					orderStr = order + " desc"
+				} else {
+					orderStr = order
+				}
+			} else {
+				//传入非法字段，不能排序
+				err = fmt.Errorf("传入非法字段 %v", order)
+				return taskList, total, err
+			}
+			//排序
+			err = db.Order(orderStr).Find(&taskList).Error
+		} else {
+			//没有传入排序字段，默认按照类型名称降序排序
+			err = db.Order("id desc").Find(&taskList).Error
+		}
+	}
+	//是因为只有切片能排序，model没办法排序;还是说为了将数组返回至前端才find扫描至切片呢？
+	return taskList, total, err
+}
+
+//获取游戏配置信息
+func (s *ComputerTaskService) GetGameConfInfo () (list interface{}, err error)  {
+	var infoList []newCentralControl.GameConfInfo
+	db := global.GVA_DB.Model(&newCentralControl.GameConf{}).Select("game_conf.task_id, game_conf.id as conf_id, game_conf.conf_name, game_task.task_name")
+	err = db.Joins("left join game_task on game_conf.task_id = game_task.task_id").Find(&infoList).Error
+	return infoList, err
+}

service/newCentralControl/enter.go

@@ -0,0 +1,6 @@
+package newCentralControl
+
+type ServiceGroup struct {
+	GameConfService
+	ComputerTaskService
+}

service/newCentralControl/game_conf.go

@@ -0,0 +1,106 @@
+package newCentralControl
+
+import (
+	"errors"
+	"fmt"
+	"gorm.io/gorm"
+	"log-server/global"
+	"log-server/model/common/request"
+	"log-server/model/newCentralControl"
+)
+
+type GameConfService struct {
+}
+
+func (s *GameConfService) CreateGameConf(conf newCentralControl.GameConf) (err error) {
+	//查找是否存在此游戏的同名配置
+	var entity newCentralControl.GameConf
+	err = global.GVA_DB.Model(&newCentralControl.GameConf{}).Where("task_id = ? and conf_name = ?", conf.TaskId, conf.ConfName).First(&entity).Error
+	//如果找到同名配置，报错
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("此配置已存在，请勿重复添加")
+	}
+	//未找到同名配置，创建配置
+	return global.GVA_DB.Model(&newCentralControl.GameConf{}).Omit("create_time", "update_time").Create(&conf).Error
+}
+
+//删除游戏配置
+func (s *GameConfService) DeleteGameConf(conf newCentralControl.GameConf) (err error) {
+	var entity newCentralControl.GameConf
+	err = global.GVA_DB.Model(&newCentralControl.GameConf{}).Where("id", conf.Id).First(&entity).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("此配置不存在，无法删除")
+	}
+	return global.GVA_DB.Model(&newCentralControl.GameConf{}).Delete(&entity).Error
+}
+
+//编辑游戏配置
+func (s *GameConfService) UpdateGameConf(conf newCentralControl.GameConf) (err error)  {
+	var entity newCentralControl.GameConf
+	err = global.GVA_DB.Model(&newCentralControl.GameConf{}).Where("conf_name = ? and id != ?", conf.ConfName, conf.Id).First(&entity).Error
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("已存在相同的配置名称，无法更改")
+	}
+	return global.GVA_DB.Model(&newCentralControl.GameConf{}).Where("id", conf.Id).Omit("create_time", "update_time").Save(&conf).Error
+}
+
+//通过id查询游戏配置
+func (s *GameConfService) GetGameConfById(id int) (conf newCentralControl.GameConf, err error){
+	err = global.GVA_DB.Model(&newCentralControl.GameConf{}).Where("id", id).First(&conf).Error
+	return conf,err
+}
+
+//获取游戏配置列表
+func(s *GameConfService) GetGameConfList (conf newCentralControl.GameConf, info request.PageInfo, order string, desc bool) (list interface{}, total int64, err error){
+	//获取limit和offset
+	limit := info.PageSize
+	offset := (info.Page - 1) * info.PageSize
+	db := global.GVA_DB.Model(&newCentralControl.GameConf{})
+	var confList []newCentralControl.GameConf
+
+	//先条件过滤
+	if conf.TaskId != 0 {
+		//条件过滤记录数
+		db = db.Where("task_id", conf.TaskId)
+	}
+
+	err = db.Count(&total).Error
+	if err != nil{
+		//如果出错直接返回
+		return confList, total, err
+	} else {
+		//先分页再排序
+		db = db.Limit(limit).Offset(offset)
+		if order != ""{
+			//传入排序字段，进行排序
+			//定义orderStr存储完整的排序字段
+			var  orderStr string
+			//为了避免sql注入，自己创建数组匹配
+			orderMap := make(map[string]bool, 3)
+			orderMap["task_id"] = true
+			orderMap["create_time"] = true
+			orderMap["update_time"] = true
+			if orderMap[order] {
+				if desc {
+					orderStr = order + " desc"
+				} else {
+					orderStr = order
+				}
+			} else {
+				//传入非法字段，不能排序
+				err = fmt.Errorf("传入非法字段 %v", order)
+				return confList, total, err
+			}
+			//排序
+			err = db.Order(orderStr).Find(&confList).Error
+		} else {
+			//没有传入排序字段，默认按照类型名称降序排序
+			err = db.Order("id desc").Find(&confList).Error
+		}
+	}
+	//是因为只有切片能排序，model没办法排序;还是说为了将数组返回至前端才find扫描至切片呢？
+	return confList, total, err
+
+}
+
+

utils/verify.go

@@ -30,7 +30,9 @@ var (
 	TaskIdVerify             = Rules{"TaskId": {NotEmpty()}}
 	UpdateTargetVerify       = Rules{"TaskId": {NotEmpty()}, "CreateDate": {NotEmpty()}}
 	TaskConfVerify           = Rules{"User": {NotEmpty()}}
-	CentralControlConfVerify = Rules{"Cpu": {NotEmpty()}, "MemorySize": {NotEmpty()}, "TaskId": {NotEmpty()}, "GameId": {NotEmpty()}} //中控配置校验
-	UrgentTaskVerify         = Rules{"TaskId": {NotEmpty()}, "PcCode": {NotEmpty()}}                                                  //紧急任务校验
-	ImageRecordVerify        = Rules{"TaskId": {NotEmpty()}, "Account": {NotEmpty()}, "ImageBase64": {NotEmpty()}}                    //图片记录验证
+	CentralControlConfVerify = Rules{"Cpu": {NotEmpty()}, "MemorySize": {NotEmpty()}, "TaskId": {NotEmpty()}, "GameId": {NotEmpty()}}                                                           //中控配置校验
+	GameConfVerify           = Rules{"Cpu": {NotEmpty()}, "MemorySize": {NotEmpty()}, "WindowsNumber": {NotEmpty()}, "TaskId": {NotEmpty()}, "GameId": {NotEmpty()}, "ProxyType": {NotEmpty()}} //游戏配置校验
+	ComputerTaskVerify       = Rules{"TaskId": {NotEmpty()}, "PcCode": {NotEmpty()}, "ConfId": {NotEmpty()}, "TaskName": {NotEmpty()}, "ConfName": {NotEmpty()}}                                //电脑任务校验
+	UrgentTaskVerify         = Rules{"TaskId": {NotEmpty()}, "PcCode": {NotEmpty()}}                                                                                                            //紧急任务校验
+	ImageRecordVerify        = Rules{"TaskId": {NotEmpty()}, "Account": {NotEmpty()}, "ImageBase64": {NotEmpty()}}                                                                              //图片记录验证
 )