Merge remote-tracking branch 'origin/master'

api/v1/task/central_control_conf.go

@@ -0,0 +1,124 @@
+package task
+
+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/task"
+	taskRequest "log-server/model/task/request"
+	"log-server/utils"
+)
+
+type CentralControlApi struct {
+
+}
+
+//创建中控配置
+func (a *CentralControlApi) CreateCentralControlConf (c *gin.Context)  {
+	var conf task.CentralControlConf
+	_ = c.ShouldBindJSON(&conf)
+	if conf.Mirror == "" {
+		response.FailWithMessage("请传入镜像名称", c)
+		return
+	}
+	if conf.Script == "" {
+		response.FailWithMessage("请传入脚本名称", c)
+		return
+	}
+	if err := utils.Verify(conf, utils.GameChannelVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := centralControlService.CreateCentralControlConf(conf);err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Error(err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+//删除配置列表
+func (a *CentralControlApi) DeleteCentralControlConf(c *gin.Context) {
+	var conf task.CentralControlConf
+	 _ = c.ShouldBindJSON(&conf)
+
+	 //数据校验
+	 if err := utils.Verify(conf, utils.CentralControlConfVerify); err != nil {
+		 response.FailWithMessage(err.Error(), c)
+		 return
+	 }
+	if err := centralControlService.DeleteCentralControlConf(conf); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+//批量删除配置列表
+func (a *CentralControlApi) DeleteCentralControlConfByIds(c *gin.Context) {
+	var ids request.IdsReq
+	_ = c.ShouldBindJSON(&ids)
+	if err := centralControlService.DeleteCentralControlConfByIds(ids.Ids); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+//更新中控配置
+func (a *CentralControlApi) UpdateCentralControlConf (c *gin.Context)  {
+	var conf task.CentralControlConf
+	_ = c.ShouldBindJSON(&conf)
+	if err := utils.Verify(conf, utils.CentralControlConfVerify); err != nil{
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := centralControlService.UpdateCentralControlConf(conf); err != nil{
+		global.GVA_LOG.Error("更新失败!", zap.Error(err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+func (a *CentralControlApi) GetCentralControlConfById (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 := centralControlService.GetCentralControlConfById(id.ID); err != nil{
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(conf, "获取成功", c)
+	}
+}
+
+//获取中控配置列表
+func (a *CentralControlApi) GetCentralControlConfList (c *gin.Context)  {
+	//获取前端传值并校验
+	var pageInfo taskRequest.SearchCentralControlConfParams
+	_ = c.ShouldBindJSON(&pageInfo)
+	//页面信息校验
+	if err := utils.Verify(pageInfo.PageInfo, utils.PageInfoVerify); err != nil{
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if list, total, err := centralControlService.GetCentralControlConfList(pageInfo.CentralControlConf, 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)
+	}
+}

api/v1/task/enter.go

@@ -5,9 +5,13 @@ import "log-server/service"
 type GroupTask struct {
 	GameTaskApi
 	TaskConfApi
+	CentralControlApi
+	UrgentTaskApi
 }
 
 var (
-	taskService = service.ServiceGroupApp.TaskServiceGroup.GameTask
-	taskConfService = service.ServiceGroupApp.TaskServiceGroup.TaskConfService
+	taskService           = service.ServiceGroupApp.TaskServiceGroup.GameTask
+	taskConfService       = service.ServiceGroupApp.TaskServiceGroup.TaskConfService
+	centralControlService = service.ServiceGroupApp.TaskServiceGroup.CentralControlService
+	urgentTaskService     = service.ServiceGroupApp.TaskServiceGroup.UrgentTaskService
 )

api/v1/task/urgent_task_conf.go

@@ -0,0 +1,122 @@
+package task
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"log-server/global"
+	"log-server/model/common/response"
+	"log-server/model/task"
+	"log-server/model/task/request"
+	"log-server/utils"
+)
+
+type UrgentTaskApi struct {
+}
+
+//查询空闲租机
+func (a *UrgentTaskApi) GetUnusedPc (c *gin.Context)  {
+	if pcList,err := urgentTaskService.GetUnusedPc(); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Error(err))
+		response.FailWithMessage(err.Error(), c)
+	} else {
+		response.OkWithDetailed(pcList, "获取成功", c)
+	}
+}
+
+//创建紧急任务
+func (a *UrgentTaskApi) CreateUrgentTask (c *gin.Context)  {
+	var task1 task.UrgentTaskConf
+	_ = c.ShouldBindJSON(&task1)
+	if err := utils.Verify(task1, utils.UrgentTaskVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := urgentTaskService.CreateUrgentTask(task1); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Error(err))
+		response.FailWithMessage(err.Error(), c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+//删除单个紧急任务
+func (a *UrgentTaskApi) DeleteUrgentTask(c *gin.Context) {
+	var task1 task.UrgentTaskConf
+	_ = c.ShouldBindJSON(&task1)
+	if err := utils.Verify(task1, utils.UrgentTaskVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := urgentTaskService.DeleteUrgentTask(task1); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+//批量删除紧急任务
+func (a *UrgentTaskApi) DeleteUrgentTaskByIds (c *gin.Context) {
+	var ids request.IdsReq
+	_ = c.ShouldBindJSON(&ids)
+	if err := urgentTaskService.DeleteUrgentTaskByIds(ids.Ids); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+//更新紧急任务
+func (a *UrgentTaskApi) UpdateUrgentTask (c *gin.Context)  {
+	var task1 task.UrgentTaskConf
+	_ = c.ShouldBindJSON(&task1)
+	if err := utils.Verify(task1, utils.UrgentTaskVerify); err != nil{
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := urgentTaskService.UpdateUrgentTask(task1); err != nil{
+		global.GVA_LOG.Error("更新失败!", zap.Error(err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+//id获取紧急任务
+func (a *UrgentTaskApi) GetUrgentTaskById(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 task1, err := urgentTaskService.GetUrgentTaskById(id.ID); err != nil{
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(task1, "获取成功", c)
+	}
+}
+
+//获取紧急任务列表
+func (a *UrgentTaskApi) GetUrgentTaskList(c *gin.Context) {
+	var paramsInfo request.SearchUrgentTaskParams
+	_ = c.ShouldBindJSON(&paramsInfo)
+	if err := utils.Verify(paramsInfo.PageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	list, total, err := urgentTaskService.GetUrgentTaskList(paramsInfo.UrgentTaskConfRequest, paramsInfo.PageInfo, paramsInfo.OrderKey, paramsInfo.Desc)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     paramsInfo.Page,
+			PageSize: paramsInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

initialize/router.go

@@ -22,7 +22,8 @@ func Routers() *gin.Engine {
 	computerRouter := router.RouterGroupApp.Computer
 	taskRouter := router.RouterGroupApp.Task
 	uploadFileRouter := router.RouterGroupApp.UploadFile
-
+	centralControlRouter := router.RouterGroupApp.CentralControl
+	urgentTaskRouter := router.RouterGroupApp.UrgentTask
 	ipLogRouter := router.RouterGroupApp.IpLog
 	idCardRouter := router.RouterGroupApp.IdCard
 	typeManageRouter := router.RouterGroupApp.TypeManage
@@ -71,6 +72,8 @@ func Routers() *gin.Engine {
 		idCardRouter.InitIdCardRouter(PublicGroup)                //身份证路由
 		taskRouter.InitGameTaskRouter(PublicGroup)
 		uploadFileRouter.InitUploadFileRouter(PublicGroup)
+		centralControlRouter.InitCentralControlRouter(PublicGroup) //中控配置
+		urgentTaskRouter.InitUrgentTaskRouter(PublicGroup)         //紧急任务
 		rentComputerRouter.InitRentComputerRouter(PublicGroup)     //租机管理
 		rentComputerRouter.InitRentComputerShopRouter(PublicGroup) // 租机供应商管理
 		rentComputerRouter.InitRentSetMealRouter(PublicGroup)

model/task/central_control_conf.go

@@ -0,0 +1,31 @@
+package task
+
+import "log-server/model/typeManage"
+
+type CentralControlConf struct {
+	Id            int                  `json:"id"`
+	Mirror        string               `json:"mirror"`         //镜像
+	Script        string               `json:"script"`         //脚本
+	CloneMode     string               `json:"clone_mode"`     //克隆模式
+	SimulatorType string               `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"`      //'付费单价',
+	CreateTime    typeManage.LocalTime `json:"create_time"`
+	UpdateTime    typeManage.LocalTime `json:"update_time"`
+}
+
+func (CentralControlConf) TableName() string {
+	return "central_control_conf"
+}

model/task/request/search_central_control_conf_params.go

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

model/task/request/search_urgent_task_params.go

@@ -0,0 +1,13 @@
+package request
+
+import (
+	"log-server/model/common/request"
+	"log-server/model/task"
+)
+
+type SearchUrgentTaskParams struct {
+	task.UrgentTaskConfRequest
+	request.PageInfo
+	OrderKey string `json:"orderKey"`
+	Desc     bool   `json:"desc"`
+}

model/task/urgent_task_conf.go

@@ -0,0 +1,31 @@
+package task
+
+import "log-server/model/typeManage"
+
+type UrgentTaskConf struct {
+	Id         int                  `json:"id"`
+	TaskId     int                  `json:"task_id"`     //任务id
+	PcCode     string               `json:"pc_code"`     //电脑编号
+	CreateDate string               `json:"create_date"` //创建日期
+	CreateTime typeManage.LocalTime `json:"create_time"`
+	UpdateTime typeManage.LocalTime `json:"update_time"`
+}
+
+//紧急任务请求
+type UrgentTaskConfRequest struct {
+	Id         int                  `json:"id"`
+	TaskId     int                  `json:"task_id"` //任务id
+	Date       []string             `json:"date"`
+	PcCode     string               `json:"pc_code"`     //电脑编号
+	CreateDate string               `json:"create_date"` //创建日期
+	CreateTime typeManage.LocalTime `json:"create_time"`
+	UpdateTime typeManage.LocalTime `json:"update_time"`
+}
+
+type UnusedPc struct {
+	PcCode string `json:"pc_code"`
+}
+
+func (UrgentTaskConf) TableName() string {
+	return "urgent_task_conf"
+}

router/enter.go

@@ -20,6 +20,8 @@ type RouterGroup struct {
 	TypeManage     typeManage.RouterGroup
 	Task           task.GameTaskRouter
 	UploadFile     task.UploadFileRouter
+	CentralControl task.CentralControlRouter
+	UrgentTask     task.UrgentTaskRouter
 	RentComputer   rentComputer.RouterGroup
 	DataStatistics dataStatistics.RouterGroup
 	FileManager    fileManager.RouterGroup

router/task/central_control_conf.go

@@ -0,0 +1,29 @@
+package task
+
+import (
+"github.com/gin-gonic/gin"
+v1 "log-server/api/v1"
+	"log-server/middleware"
+)
+
+type CentralControlRouter struct {
+
+}
+
+func (r *CentralControlRouter) InitCentralControlRouter(Router *gin.RouterGroup) {
+	GameTaskRouter := Router.Group("gameTask")
+	centralControlConfApi := v1.ApiGroupApp.GroupTask.CentralControlApi
+	{
+		GameTaskRouter.POST("getCentralControlConfList", centralControlConfApi.GetCentralControlConfList)  //获取配置列表
+		GameTaskRouter.POST("getCentralControlConfById", centralControlConfApi.GetCentralControlConfById)  //通过id获取单个配置
+
+	}
+
+	centralControlConfApi1 := Router.Group("gameTask").Use(middleware.OperationRecord())
+	{
+		centralControlConfApi1.POST("createCentralControlConf", centralControlConfApi.CreateCentralControlConf)   //创建中控配置
+		centralControlConfApi1.POST("deleteCentralControlConf", centralControlConfApi.DeleteCentralControlConf)   //单个删除中控配置
+		centralControlConfApi1.DELETE("deleteCentralControlConfByIds", centralControlConfApi.DeleteCentralControlConfByIds)   //批量删除中控配置
+		centralControlConfApi1.POST("updateCentralControlConf", centralControlConfApi.UpdateCentralControlConf)   //更新中控配置
+	}
+}

router/task/urgent_task_conf.go

@@ -0,0 +1,29 @@
+package task
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "log-server/api/v1"
+	"log-server/middleware"
+)
+
+type UrgentTaskRouter struct {
+}
+
+func (r *UrgentTaskRouter) InitUrgentTaskRouter(Router *gin.RouterGroup) {
+	GameTaskRouter := Router.Group("gameTask")
+	urgentTaskApi := v1.ApiGroupApp.GroupTask.UrgentTaskApi
+	{
+		GameTaskRouter.POST("getUrgentTaskList", urgentTaskApi.GetUrgentTaskList) //获取紧急任务列表
+		GameTaskRouter.POST("getUrgentTaskById", urgentTaskApi.GetUrgentTaskById) //通过id单个获取紧急任务
+		GameTaskRouter.POST("getUnusedPc", urgentTaskApi.GetUnusedPc)             //获取空闲租机列表
+
+	}
+
+	urgentTaskApi1 := Router.Group("gameTask").Use(middleware.OperationRecord())
+	{
+		urgentTaskApi1.POST("createUrgentTask", urgentTaskApi.CreateUrgentTask)             //创建紧急任务
+		urgentTaskApi1.POST("deleteUrgentTask", urgentTaskApi.DeleteUrgentTask)             //单个删除紧急任务
+		urgentTaskApi1.DELETE("deleteUrgentTaskByIds", urgentTaskApi.DeleteUrgentTaskByIds) //批量删除紧急任务
+		urgentTaskApi1.POST("updateUrgentTask", urgentTaskApi.UpdateUrgentTask)             //更新紧急任务
+	}
+}

service/task/central_control_conf.go

@@ -0,0 +1,111 @@
+package task
+
+import (
+	"errors"
+	"fmt"
+	"gorm.io/gorm"
+	"log-server/global"
+	"log-server/model/common/request"
+	"log-server/model/task"
+)
+
+type CentralControlService struct {
+
+}
+
+//创建配置记录
+func (s *CentralControlService) CreateCentralControlConf(conf task.CentralControlConf) (err error) {
+	//查找是否有这个taskId的记录
+	var entity task.CentralControlConf
+	err = global.GVA_DB.Model(&task.CentralControlConf{}).Where("task_id", conf.TaskId).First(&entity).Error
+	//如果有，报错返回
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("已有配置记录，请勿重复添加")
+	}
+	//如果没有，直接创建
+	return global.GVA_DB.Model(&task.CentralControlConf{}).Omit("create_time", "update_time").Create(&conf).Error
+}
+
+//删除中控配置记录
+func (s *CentralControlService) DeleteCentralControlConf(conf task.CentralControlConf) (err error)  {
+	var entity task.CentralControlConf
+	err = global.GVA_DB.Model(&task.CentralControlConf{}).Where("id", conf.Id).First(&entity).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("此配置不存在，无法删除")
+	}
+	return global.GVA_DB.Model(&task.CentralControlConf{}).Delete(&entity).Error
+}
+
+//批量删除中控配置记录
+func (s *CentralControlService) DeleteCentralControlConfByIds(ids []int) (err error) {
+	err = global.GVA_DB.Model(&task.CentralControlConf{}).Delete("id in ?", ids).Error
+	return err
+}
+
+//更新中控配置列表
+func (s *CentralControlService) UpdateCentralControlConf(conf task.CentralControlConf) (err error) {
+	var entity task.CentralControlConf
+	err = global.GVA_DB.Model(&task.CentralControlConf{}).Where("task_id = ? and id != ?", conf.TaskId, conf.Id).First(&entity).Error
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("已存在相同的task_id，无法更改")
+	}
+	return global.GVA_DB.Model(&task.CentralControlConf{}).Where("id", conf.Id).Updates(&conf).Error
+}
+
+//通过id获取单条配置
+func (s *CentralControlService) GetCentralControlConfById(id int) (conf task.CentralControlConf, err error) {
+	err = global.GVA_DB.Model(&task.CentralControlConf{}).Where("id", id).First(&conf).Error
+	return conf, err
+}
+
+//获取配置列表
+func (s *CentralControlService) GetCentralControlConfList(conf task.CentralControlConf, 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(&task.CentralControlConf{})
+	var confList []task.CentralControlConf
+
+	//先条件过滤
+	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
+}

service/task/enter.go

@@ -3,4 +3,6 @@ package task
 type ServiceGroup struct {
 	GameTask
 	TaskConfService
+	CentralControlService
+	UrgentTaskService
 }

service/task/urgent_task_conf.go

@@ -0,0 +1,125 @@
+package task
+
+import (
+	"errors"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+	"log-server/global"
+	"log-server/model/common/request"
+	"log-server/model/task"
+	"time"
+)
+
+type UrgentTaskService struct {
+}
+
+func (s *UrgentTaskService) CreateUrgentTask(task1 task.UrgentTaskConf) (err error)  {
+	//根据平均期望，将故障较大的放前面可以减少查询次数。那么需要先查是否有task_id以及create_date相等的
+	var urgentEntity task.UrgentTaskConf
+	var centralEntity task.CentralControlConf
+	date := time.Now().Format("2006-01-02")
+	task1.CreateDate = date
+	err = global.GVA_DB.Model(&task.UrgentTaskConf{}).Where("task_id = ? and create_date = ?", task1.TaskId, date).First(&urgentEntity).Error
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("任务已存在，请勿重复添加")
+	}
+	//查找中控配置是否存在
+	err = global.GVA_DB.Model(&task.CentralControlConf{}).Where("task_id", task1.TaskId).First(&centralEntity).Error
+	//若记录不存在，则报错返回
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("请先添加此任务中控配置")
+	}
+	//创建紧急任务
+	return global.GVA_DB.Model(&task.UrgentTaskConf{}).Omit("create_time", "update_time").Create(&task1).Error
+}
+
+func (s *UrgentTaskService) DeleteUrgentTask(task1 task.UrgentTaskConf) (err error) {
+	//查找此任务是否存在
+	var entity task.UrgentTaskConf
+	err = global.GVA_DB.Model(&task.UrgentTaskConf{}).Where("id", task1.Id).First(&entity).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return errors.New("此任务不存在")
+	}
+	return global.GVA_DB.Model(&task.UrgentTaskConf{}).Delete(&entity).Error
+}
+
+//批量删除
+func (s *UrgentTaskService) DeleteUrgentTaskByIds(ids []int) (err error){
+	err = global.GVA_DB.Model(&task.UrgentTaskConf{}).Delete("id in ?", ids).Error
+	return err
+}
+
+func (s *UrgentTaskService) UpdateUrgentTask(task1 task.UrgentTaskConf) (err error) {
+	//查找此task_id是否存在，如果存在不更新，否则更新
+	var entity task.UrgentTaskConf
+	err = global.GVA_DB.Model(&task.UrgentTaskConf{}).Where("task_id = ? and id != ?", task1.TaskId, task1.Id).First(&entity).Error
+	if !errors.Is(err , gorm.ErrRecordNotFound) {
+		return errors.New("已存在此task_id的任务，更新失败")
+	}
+	return global.GVA_DB.Model(&task.UrgentTaskConf{}).Where("id", task1.Id).Updates(&task1).Error
+}
+
+func (s *UrgentTaskService) GetUrgentTaskById(id int) (task1 task.UrgentTaskConf, err error) {
+	err = global.GVA_DB.Model(&task.UrgentTaskConf{}).Where("id", id).First(&task1).Error
+	return task1, err
+}
+
+//查询空闲租机
+func (s *UrgentTaskService) GetUnusedPc() (unusedPcList []task.UnusedPc, err error)  {
+	//获取当日日期
+	date := time.Now().Format("2006-01-02")
+	err = global.GVA_DB.Table("computer_status").Where("status = ? and create_date = ?", -1, date).Order("pc_code").Find(&unusedPcList).Error
+	return unusedPcList, err
+}
+
+//获取紧急任务列表
+func (s *UrgentTaskService) GetUrgentTaskList(conf task.UrgentTaskConfRequest, info request.PageInfo, order string, desc bool) (confList []task.UrgentTaskConf, total int64, err error){
+	limit := info.PageSize
+	offset := info.PageSize * (info.Page - 1)
+	db := global.GVA_DB.Model(&task.UrgentTaskConf{})
+	startDate := time.Now().Format("2006-01-02")
+	endDate := time.Now().Format("2006-01-02")
+	if len(conf.Date) == 2 {
+		startDate = conf.Date[0]
+		endDate = conf.Date[1]
+	}
+	//筛选日期
+	db = db.Where("create_date >= ? and create_date <= ?", startDate, endDate)
+	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 != "" {
+			var OrderStr string
+			// 设置有效排序key 防止sql注入
+			// 感谢 Tom4t0 提交漏洞信息
+			orderMap := make(map[string]bool, 4)
+			orderMap["task_id"] = true
+			orderMap["create_date"] = true
+			orderMap["create_time"] = true
+			orderMap["update_time"] = true
+			if orderMap[order] {
+				if desc {
+					OrderStr = order + " desc"
+				} else {
+					OrderStr = order
+				}
+			} else { // didn't matched any order key in `orderMap`
+				global.GVA_LOG.Error("获取失败!", zap.Error(err))
+				return confList, total, err
+			}
+			err = db.Order(OrderStr).Find(&confList).Error
+		} else {
+			err = db.Order("id desc").Find(&confList).Error
+		}
+	}
+	//遍历更改日期格式
+	//for i, _ := range confList {
+	//	confList[i].CreateDate = confList[i].CreateDate[:10]
+	//}
+	return confList, total, err
+}

utils/verify.go

@@ -21,13 +21,15 @@ var (
 	PcVerify               = Rules{"PcCode": {NotEmpty()}, "User": {NotEmpty()}, "Supplier": {NotEmpty()}}
 
 	//自己添加的校验
-	GameChannelVerify       = Rules{"ChannelName": {NotEmpty()}, "ChannelDesc": {NotEmpty()}, "DisplaySequence": {NotEmpty()}}
-	GameListVerify          = Rules{"GameName": {NotEmpty()}, "GamePort": {NotEmpty()}, "LoginType": {NotEmpty()}}
-	LoginTypeVerify         = Rules{"LoginName": {NotEmpty()}, "LoginDesc": {NotEmpty()}}
-	ResponsiblePersonVerify = Rules{"Name": {NotEmpty()} }
-	AccountTypeVerify       = Rules{"TypeName": {NotEmpty()}}
-	GameTaskVerify          = Rules{"TaskId": {NotEmpty()}, "TaskName": {NotEmpty()}, "User": {NotEmpty()}, "NewRetained": {NotEmpty()}, "GamePortId": {NotEmpty()}}
-	TaskIdVerify            = Rules{"TaskId": {NotEmpty()}}
-	UpdateTargetVerify      = Rules{"TaskId": {NotEmpty()}, "CreateDate": {NotEmpty()}}
-	TaskConfVerify          = Rules{"User": {NotEmpty()}}
+	GameChannelVerify        = Rules{"ChannelName": {NotEmpty()}, "ChannelDesc": {NotEmpty()}, "DisplaySequence": {NotEmpty()}}
+	GameListVerify           = Rules{"GameName": {NotEmpty()}, "GamePort": {NotEmpty()}, "LoginType": {NotEmpty()}}
+	LoginTypeVerify          = Rules{"LoginName": {NotEmpty()}, "LoginDesc": {NotEmpty()}}
+	ResponsiblePersonVerify  = Rules{"Name": {NotEmpty()}}
+	AccountTypeVerify        = Rules{"TypeName": {NotEmpty()}}
+	GameTaskVerify           = Rules{"TaskId": {NotEmpty()}, "TaskName": {NotEmpty()}, "User": {NotEmpty()}, "NewRetained": {NotEmpty()}, "GamePortId": {NotEmpty()}}
+	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()}}                                                  //紧急任务校验
 )