紧急任务接口提交

api/v1/task/enter.go

@@ -6,10 +6,12 @@ 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

@@ -23,6 +23,7 @@ func Routers() *gin.Engine {
 	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,7 +72,8 @@ func Routers() *gin.Engine {
 		idCardRouter.InitIdCardRouter(PublicGroup)                //身份证路由
 		taskRouter.InitGameTaskRouter(PublicGroup)
 		uploadFileRouter.InitUploadFileRouter(PublicGroup)
-		centralControlRouter.InitCentralControlRouter(PublicGroup)  //中控配置
+		centralControlRouter.InitCentralControlRouter(PublicGroup) //中控配置
+		urgentTaskRouter.InitUrgentTaskRouter(PublicGroup)         //紧急任务
 		rentComputerRouter.InitRentComputerRouter(PublicGroup)     //租机管理
 		rentComputerRouter.InitRentComputerShopRouter(PublicGroup) // 租机供应商管理
 		rentComputerRouter.InitRentSetMealRouter(PublicGroup)

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

@@ -13,19 +13,20 @@ import (
 )
 
 type RouterGroup struct {
-	System             system.RouterGroup
-	Example            example.RouterGroup
-	Loging             log.RouterGroup
-	Computer           log.ComputerRouter
-	TypeManage         typeManage.RouterGroup
-	Task               task.GameTaskRouter
-	UploadFile         task.UploadFileRouter
+	System         system.RouterGroup
+	Example        example.RouterGroup
+	Loging         log.RouterGroup
+	Computer       log.ComputerRouter
+	TypeManage     typeManage.RouterGroup
+	Task           task.GameTaskRouter
+	UploadFile     task.UploadFileRouter
 	CentralControl task.CentralControlRouter
-	RentComputer       rentComputer.RouterGroup
-	DataStatistics     dataStatistics.RouterGroup
-	FileManager        fileManager.RouterGroup
-	IpLog              log.IpLogRouter
-	IdCard             card.IdCardRouter
+	UrgentTask     task.UrgentTaskRouter
+	RentComputer   rentComputer.RouterGroup
+	DataStatistics dataStatistics.RouterGroup
+	FileManager    fileManager.RouterGroup
+	IpLog          log.IpLogRouter
+	IdCard         card.IdCardRouter
 }
 
 var RouterGroupApp = new(RouterGroup)

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/enter.go

@@ -4,4 +4,5 @@ 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

@@ -31,4 +31,5 @@ var (
 	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()}}                                                  //紧急任务校验
 )