扫码日志逻辑、任务同步更新

api/v1/enter.go

@@ -13,6 +13,7 @@ import (
 type ApiGroup struct {
 	SystemApiGroup       system.ApiGroup
 	ExampleApiGroup      example.ApiGroup
+	GameTaskApiGroup     task.GameTaskApi
 	LogApiGroup          log.GroupLog
 	TypeApiGroup         typeManage.ApiGroup
 	GroupTask            task.GroupTask

api/v1/log/loging.go

@@ -401,3 +401,31 @@ func (s *ApiLoging) UpdatePcRemarks(c *gin.Context) {
 		response.OkWithMessage("修改成功", c)
 	}
 }
+
+// @Tags loging
+// @Summary 上报扫码订单信息
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GetCardListRequest true "扫码订单列表"
+// @Success 200 {object} response.Response{data=response.GetGameTaskListReply,msg=string} "分页游戏任务列表,返回包括列表,总数,页码,每页数量"
+// @Router /loging/getLogScanningList [post]
+func (s *ApiLoging) GetLogScanningList(c *gin.Context) {
+	var paramsInfo request.GetLogScanningCodeRequest
+	_ = c.ShouldBindJSON(&paramsInfo)
+	if err := utils.Verify(paramsInfo.PageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if list, total, err := ServiceStatisticsLog.GetScanningInfoList(paramsInfo.LogScanningRequest, paramsInfo.PageInfo, paramsInfo.OrderKey, paramsInfo.Desc); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败"+err.Error(), c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     paramsInfo.Page,
+			PageSize: paramsInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

api/v1/task/game_task.go

@@ -180,7 +180,35 @@ func (s *GameTaskApi) GetGameTaskTargetList(c *gin.Context) {
 		response.FailWithMessage(err.Error(), c)
 		return
 	}
-	if list, total, err := taskService.GetGameTaskTargetInfoList(paramsInfo.GameTargetCompleteRequest, paramsInfo.PageInfo, paramsInfo.OrderKey, paramsInfo.Desc); err != nil {
+	if list, total, err := taskService.GetGameTaskTargetInfoList(paramsInfo.GameTargetCompleteRequest, paramsInfo.PageInfo, paramsInfo.OrderKey, paramsInfo.Desc, false); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败 "+err.Error(), c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     paramsInfo.Page,
+			PageSize: paramsInfo.PageSize,
+		}, "获取成功", c)
+	}
+}
+
+// @Tags gameTask
+// @Summary 腾讯游戏任务列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GetCardListRequest true "腾讯游戏任务列表"
+// @Success 200 {object} response.Response{data=response.GetGameTaskListReply,msg=string} "分页游戏任务列表,返回包括列表,总数,页码,每页数量"
+// @Router /gameTask/getGameTxTaskList [post]
+func (s *GameTaskApi) GetGameTxTaskList(c *gin.Context) {
+	var paramsInfo request.GetGameTaskListTargetRequest
+	_ = c.ShouldBindJSON(&paramsInfo)
+	if err := utils.Verify(paramsInfo.PageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if list, total, err := taskService.GetGameTaskTargetInfoList(paramsInfo.GameTargetCompleteRequest, paramsInfo.PageInfo, paramsInfo.OrderKey, paramsInfo.Desc, true); err != nil {
 		global.GVA_LOG.Error("获取失败!", zap.Error(err))
 		response.FailWithMessage("获取失败 "+err.Error(), c)
 	} else {
@@ -272,3 +300,101 @@ func (s *GameTaskApi) TargetStatistics(c *gin.Context) {
 		return
 	}
 }
+
+// @Tags gameTask
+// @Summary 数优每日统计
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data Query create_date true
+// @Success 200 {object} []response.GameTargetStatistics "数优每日统计数据"
+// @Router /gameTask/everyDayStatistics [post]
+func (s *GameTaskApi) EveryDayStatistics(c *gin.Context) {
+	var paramsInfo request.GameTaskStatisticsRequest
+	_ = c.ShouldBindJSON(&paramsInfo)
+
+	if data, err := taskService.DayStatisticsData(paramsInfo); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败 "+err.Error(), c)
+	} else {
+
+		response.OkWithDetailed(response.PageResult{
+			List:     data,
+			Total:    0,
+			Page:     1,
+			PageSize: 10,
+		}, "获取成功", c)
+	}
+}
+
+// @Tags gameTask
+// @Summary 数优每月统计
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data Query create_date true
+// @Success 200 {object} []response.GameTargetStatistics "数优每月统计数据"
+// @Router /gameTask/monthStatistics [post]
+func (s *GameTaskApi) MonthStatistics(c *gin.Context) {
+	if data, err := taskService.MonthStatisticsData(); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败 "+err.Error(), c)
+	} else {
+
+		response.OkWithDetailed(response.PageResult{
+			List:     data,
+			Total:    0,
+			Page:     1,
+			PageSize: 10,
+		}, "获取成功", c)
+	}
+}
+
+// @Tags gameTask
+// @Summary 数优游戏统计
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data Query create_date true
+// @Success 200 {object} []response.GameTargetStatistics "数优游戏统计数据"
+// @Router /gameTask/gameStatistics [post]
+func (s *GameTaskApi) GameStatistics(c *gin.Context) {
+	var paramsInfo request.CreateDateReply
+	_ = c.ShouldBindJSON(&paramsInfo)
+	if data, err := taskService.GameStatisticsData(paramsInfo.CreateDate); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败 "+err.Error(), c)
+	} else {
+
+		response.OkWithDetailed(response.PageResult{
+			List:     data,
+			Total:    10,
+			Page:     1,
+			PageSize: 10,
+		}, "获取成功", c)
+	}
+}
+
+// @Tags gameTask
+// @Summary 负责人端口游戏列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data Query create_date true
+// @Success 200 {object} []response.GameTargetStatistics "负责人端口游戏列表"
+// @Router /gameTask/gameList [post]
+func (s *GameTaskApi) GameList(c *gin.Context) {
+	var paramsInfo request.GameListRequest
+	_ = c.ShouldBindJSON(&paramsInfo)
+	if data, err := taskService.GameStatisticsList(paramsInfo); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败 "+err.Error(), c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     data,
+			Total:    10,
+			Page:     1,
+			PageSize: 10,
+		}, "获取成功", c)
+	}
+}

initialize/timer.go

@@ -43,51 +43,56 @@ func Timer() {
 		fmt.Println("add taskCode timer error:", err)
 	}
 
-	// 定时同步电脑相关的统计数据
-	//_, err = global.GVA_Timer.AddTaskByFunc("CreateComputerStatisticsData", "40 0/9 7-23 * * * ", serviceStatisticsLog.CreateComputerStatisticsData)
-	//if err != nil {
-	//	fmt.Println("add CreateComputerStatisticsData timer error:", err)
-	//}
-	//// 同步游戏相关的统计数据
-	//_, err = global.GVA_Timer.AddTaskByFunc("TodayCreateStatisticsGameInfoLog", "2 0/8 6-23 * * * ", serviceStatisticsLog.TodayCreateStatisticsGameInfoLog)
-	//if err != nil {
-	//	fmt.Println("add TodayCreateStatisticsGameInfoLog timer error:", err)
-	//}
-	//// 同步任务统计数据
-	//_, err = global.GVA_Timer.AddTaskByFunc("TaskStatisticsDataCache", "2 0/3 6-23 * * * ", serviceStatisticsLog.TaskStatisticsDataCache)
-	//if err != nil {
-	//	fmt.Println("add TaskStatisticsDataCache timer error:", err)
-	//}
-	//// 重试失败数据
-	//_, err = global.GVA_Timer.AddTaskByFunc("createFailLog", "2 0/5 6-23 * * * ", ServiceLogList.CreateFailLog)
-	//if err != nil {
-	//	fmt.Println("everyDayResetStatisticsCache timer error:", err)
-	//}
-	//// 定时检查电脑上报
-	//_, err = global.GVA_Timer.AddTaskByFunc("RegularCheckPc", "2 57 8-23 * * * ", serviceStatisticsLog.RegularCheckPc)
-	//if err != nil {
-	//	fmt.Println("RegularCheckPc timer error:", err)
-	//}
-	//// 新建日志表
-	//_, err = global.GVA_Timer.AddTaskByFunc("RegularCreateLogingTable", "2 1 19 20,29 * * ", ServiceLogList.RegularCreateLogingTable)
-	//if err != nil {
-	//	fmt.Println("add RegularCreateLogingTable timer error:", err)
-	//}
-	//// 定时删缓存
-	//_, err = global.GVA_Timer.AddTaskByFunc("RegularDelCheckData", "2 33 11 * * *", serviceStatisticsLog.RegularDelCheckData)
-	//if err != nil {
-	//	fmt.Println("add RegularDelCheckData timer error:", err)
-	//}
-	////定时添加任务
-	//_, err = global.GVA_Timer.AddTaskByFunc("EveryDaySyncTaskData", "30 29 10 * * *", syncData.EveryDaySyncTaskData)
-	//if err != nil {
-	//	fmt.Println("add EveryDaySyncTaskData timer error:", err)
-	//}
-	//
-	//_, err = global.GVA_Timer.AddTaskByFunc("SyncTaskData", "2 0/3 1-23 * * *", syncData.SyncTaskData)
-	//if err != nil {
-	//	fmt.Println("add SyncTaskData timer error:", err)
-	//}
+	//定时同步电脑相关的统计数据
+	_, err = global.GVA_Timer.AddTaskByFunc("CreateComputerStatisticsData", "40 9,19,29,39,49,59 7-23 * * * ", serviceStatisticsLog.CreateComputerStatisticsData)
+	if err != nil {
+		fmt.Println("add CreateComputerStatisticsData timer error:", err)
+	}
+	// 同步游戏相关的统计数据
+	_, err = global.GVA_Timer.AddTaskByFunc("TodayCreateStatisticsGameInfoLog", "2 8,18,28,38,48,58 6-23 * * * ", serviceStatisticsLog.TodayCreateStatisticsGameInfoLog)
+	if err != nil {
+		fmt.Println("add TodayCreateStatisticsGameInfoLog timer error:", err)
+	}
+	// 同步任务统计数据
+	_, err = global.GVA_Timer.AddTaskByFunc("TaskStatisticsDataCache", "20 0/3 6-23 * * * ", serviceStatisticsLog.TaskStatisticsDataCache)
+	if err != nil {
+		fmt.Println("add TaskStatisticsDataCache timer error:", err)
+	}
+	// 重试失败数据
+	_, err = global.GVA_Timer.AddTaskByFunc("createFailLog", "2 5,15,25,35,45,55 6-23 * * * ", ServiceLogList.CreateFailLog)
+	if err != nil {
+		fmt.Println("everyDayResetStatisticsCache timer error:", err)
+	}
+	// 定时检查电脑上报
+	_, err = global.GVA_Timer.AddTaskByFunc("RegularCheckPc", "2 57 8-23 * * * ", serviceStatisticsLog.RegularCheckPc)
+	if err != nil {
+		fmt.Println("RegularCheckPc timer error:", err)
+	}
+	// 新建日志表
+	_, err = global.GVA_Timer.AddTaskByFunc("RegularCreateLogingTable", "2 1 19 20 * * ", ServiceLogList.RegularCreateLogingTable)
+	if err != nil {
+		fmt.Println("add RegularCreateLogingTable timer error:", err)
+	}
+	// 定时删缓存
+	_, err = global.GVA_Timer.AddTaskByFunc("RegularDelCheckData", "2 33 11 * * *", serviceStatisticsLog.RegularDelCheckData)
+	if err != nil {
+		fmt.Println("add RegularDelCheckData timer error:", err)
+	}
+	//定时添加任务
+	_, err = global.GVA_Timer.AddTaskByFunc("EveryDaySyncTaskData", "30 22 21 * * *", syncData.EveryDaySyncTaskData)
+	if err != nil {
+		fmt.Println("add EveryDaySyncTaskData timer error:", err)
+	}
+	//同步任务数据
+	_, err = global.GVA_Timer.AddTaskByFunc("SyncTaskData", "2 0/3 1-23 * * *", syncData.SyncTaskData)
+	if err != nil {
+		fmt.Println("add SyncTaskData timer error:", err)
+	}
+	// 数优任务统计
+	_, err = global.GVA_Timer.AddTaskByFunc("DayTargetDataStatistics", "40 2 5 * * *", syncData.DayTargetDataStatistics)
+	if err != nil {
+		fmt.Println("add DayTargetDataStatistics timer error:", err)
+	}
 
 	// 定时检查是否有电脑到期，修改租机状态@every 1s
 	//_, err = global.GVA_Timer.AddTaskByFunc("CheckIsExpire", "0/59 0/5 * * * *", serviceRentComputer.CheckIsExpire)

model/log/log_scanning_code.go

@@ -0,0 +1,21 @@
+package log
+
+import (
+	"time"
+)
+
+type LogScanningCode struct {
+	Id         uint      `json:"id"`
+	Supplier   string    `json:"supplier"`
+	OrderNum   string    `json:"order_num"`
+	GameId     int       `json:"game_id"`
+	LogUuid    string    `json:"log_uuid"`
+	Status     int       `json:"status"` // 1成功2失败
+	TaskType   int       `json:"task_type"`
+	CreateDate time.Time `json:"create_date"`
+	CreateTime time.Time `json:"create_time"` // 创建时间
+}
+
+func (LogScanningCode) TableName() string {
+	return "log_scanning_code"
+}

model/log/log_statistics.go

@@ -67,6 +67,10 @@ type StatisticsLog struct {
 	ScanningSuccessRate   float64 `json:"scanning_success_rate"`
 	LocalOrderSuccessRate float64 `json:"local_order_success_rate"`
 	Operator              string  `json:"operator"`
+	EnterScanningCode     int     `json:"enter_scanning_code"`
+	TranscodingFail       int     `json:"transcoding_fail"`
+	ThirdPartyFail        int     `json:"third_party_fail"`
+	ScanningCodeSuccess   int     `json:"scanning_code_success"`
 }
 
 func (StatisticsLog) TableName() string {

model/log/request/log_statistics.go

@@ -68,3 +68,22 @@ type ExcelInfo struct {
 		Desc     bool   `json:"desc"`     // 排序方式:升序false(默认)|降序true
 	} `json:"infoList"`
 }
+
+type GetLogScanningCodeRequest struct {
+	LogScanningRequest
+	PageInfo
+	OrderKey string `json:"orderKey"` // 排序
+	Desc     bool   `json:"desc"`     // 排序方式:升序false(默认)|降序true
+}
+
+type LogScanningRequest struct {
+	Id         uint   `json:"id"`
+	Supplier   string `json:"supplier"`
+	OrderNum   string `json:"order_num"`
+	GameId     int    `json:"game_id"`
+	LogUuid    string `json:"log_uuid"`
+	Status     int    `json:"status"` // 1成功2失败
+	TaskType   int    `json:"task_type"`
+	CreateDate string `json:"create_date"`
+	CreateTime string `json:"create_time"` // 创建时间
+}

model/log/response/loging.go

@@ -79,3 +79,15 @@ type ComputerUseLogReply struct {
 	EnterMainTotal   int    `json:"enter_main_total"`
 	Remarks          string `json:"remarks"`
 }
+
+type LogScanningReply struct {
+	Id         uint   `json:"id"`
+	Supplier   string `json:"supplier"`
+	OrderNum   string `json:"order_num"`
+	GameId     int    `json:"game_id"`
+	LogUuid    string `json:"log_uuid"`
+	Status     int    `json:"status"` // 1成功-1失败
+	TaskType   int    `json:"task_type"`
+	CreateDate string `json:"create_date"`
+	CreateTime string `json:"create_time"` // 创建时间
+}

model/task/game_target_statistics.go

@@ -0,0 +1,24 @@
+package task
+
+import "time"
+
+type GameTargetStatistics struct {
+	Id               uint      `json:"id"`
+	NewComplete      int       `json:"new_complete"`
+	PayComplete      int       `json:"pay_complete"`
+	RetainedComplete int       `json:"retained_complete"`
+	NewTarget        int       `json:"new_target"`
+	PayTarget        int       `json:"pay_target"`
+	RetainedTarget   int       `json:"retained_target"`
+	Amount           int       `json:"amount"`
+	TaskDate         time.Time `json:"task_date"`
+	TaskMonth        int       `json:"task_month"` // 月维度
+	TaskYear         int       `json:"task_year"`
+	UpdateTime       time.Time `json:"update_time"` // 更新时间
+	User             string    `json:"user"`
+	GamePortId       int       `json:"game_port_id"`
+}
+
+func (GameTargetStatistics) TableName() string {
+	return "game_target_statistics"
+}

model/task/request/game_task.go

@@ -88,3 +88,14 @@ type CardInfo struct {
 	Card   string `json:"card"`
 	Amount int    `json:"amount"`
 }
+
+type GameTaskStatisticsRequest struct {
+	GroupKey string `json:"group_key"`
+	Date     string `json:"date"`
+}
+
+type GameListRequest struct {
+	User       string `json:"user"`
+	Date       string `json:"date"`
+	GamePortId int    `json:"game_port_id"`
+}

model/task/response/game_task.go

@@ -1,5 +1,7 @@
 package response
 
+import "time"
+
 type GetGameTaskListReply struct {
 	TaskId         int    `json:"task_id"`
 	TaskName       string `json:"task_name"`
@@ -41,3 +43,54 @@ type GetGameTargetComplete struct {
 	HandPayComplete      int    `json:"hand_pay_complete"`
 	HandAmountTotal      int    `json:"hand_amount_total"`
 }
+
+type GameTargetStatistics struct {
+	NewComplete      int    `json:"new_complete"`
+	PayComplete      int    `json:"pay_complete"`
+	RetainedComplete int    `json:"retained_complete"`
+	NewTarget        int    `json:"new_target"`
+	PayTarget        int    `json:"pay_target"`
+	RetainedTarget   int    `json:"retained_target"`
+	Amount           int    `json:"amount"`
+	TaskDate         string `json:"task_date"`
+	TaskMonth        int    `json:"task_month"` // 月维度
+	User             string `json:"user"`
+	GamePort         string `json:"game_port"`
+}
+
+type GameTargetCompleteReply struct {
+	Id                   uint      `json:"id"`
+	TaskId               int       `json:"task_id"`
+	NewComplete          int       `json:"new_complete"`
+	PayComplete          int       `json:"pay_complete"`
+	RetainedComplete     int       `json:"retained_complete"`
+	NewTarget            int       `json:"new_target"`
+	PayTarget            int       `json:"pay_target"`
+	RetainedTarget       int       `json:"retained_target"`
+	Amount               int       `json:"amount"`
+	CreateDate           time.Time `json:"create_date"`
+	UpdateTime           time.Time `json:"update_time"` // 更新时间
+	GameRate             string    `json:"game_rate"`
+	IsComplete           int       `json:"is_complete"`
+	HandNewComplete      int       `json:"hand_new_complete"`
+	HandRetainedComplete int       `json:"hand_retained_complete"`
+	HandPayComplete      int       `json:"hand_pay_complete"`
+	HandAmountTotal      int       `json:"hand_amount_total"`
+	GamePortId           int       `json:"game_port_id"`
+	User                 string    `json:"user"`
+}
+
+type GameStatisticsDataReply struct {
+	Total      int    `json:"total"`
+	GamePortId int    `json:"game_port_id"`
+	GamePort   string `json:"game_port"`
+	User       string `json:"user"`
+	CreateDate string `json:"create_date"`
+}
+
+type GameStatisticsListReply struct {
+	GamePortId int    `json:"game_port_id"`
+	GamePort   string `json:"game_port"`
+	CreateDate string `json:"create_date"`
+	GameName   string `json:"game_name"`
+}

router/log/computer.go

@@ -3,6 +3,7 @@ package log
 import (
 	"github.com/gin-gonic/gin"
 	v1 "log-server/api/v1"
+	"log-server/middleware"
 )
 
 type ComputerRouter struct {
@@ -14,9 +15,12 @@ func (e *ComputerRouter) InitComputerRouter(Router *gin.RouterGroup) {
 	{
 		computerRouter.POST("getPcList", computerApi.GetPcList)
 		computerRouter.POST("getPcById", computerApi.GetPcById)
-		computerRouter.POST("createPc", computerApi.CreatePc)
-		computerRouter.POST("updatePc", computerApi.UpdatePc)
-		computerRouter.POST("statusOperation", computerApi.PcStatusOperation)
 		computerRouter.POST("importExcel", computerApi.ImportExcel)
 	}
+	computerRouter1 := Router.Group("computer").Use(middleware.OperationRecord())
+	{
+		computerRouter1.POST("createPc", computerApi.CreatePc)
+		computerRouter1.POST("updatePc", computerApi.UpdatePc)
+		computerRouter1.POST("statusOperation", computerApi.PcStatusOperation)
+	}
 }

router/log/loging.go

@@ -25,5 +25,6 @@ func (e *LogingRouter) InitLogingRouter(Router *gin.RouterGroup) {
 		excelRouter.POST("test", logApi.ComputerTest)
 		excelRouter.POST("exportExcel", logApi.ExportExcel)
 		excelRouter.POST("updatePcRemarks", logApi.UpdatePcRemarks)
+		excelRouter.POST("getLogScanningList", logApi.GetLogScanningList)
 	}
 }

router/task/game_task.go

@@ -3,6 +3,7 @@ package task
 import (
 	"github.com/gin-gonic/gin"
 	v1 "log-server/api/v1"
+	"log-server/middleware"
 )
 
 type GameTaskRouter struct {
@@ -12,15 +13,23 @@ func (e *GameTaskRouter) InitGameTaskRouter(Router *gin.RouterGroup) {
 	GameTaskRouter := Router.Group("gameTask")
 	GameTaskApi := v1.ApiGroupApp.GroupTask.GameTaskApi
 	{
-		GameTaskRouter.POST("create", GameTaskApi.CreateGameTask)
 		GameTaskRouter.POST("getGameTaskList", GameTaskApi.GetGameTaskList)
 		GameTaskRouter.POST("getGameTaskById", GameTaskApi.GetGameTaskById)
-		GameTaskRouter.POST("statusOperation", GameTaskApi.StatusOperation)
-		GameTaskRouter.POST("update", GameTaskApi.UpdateGameTask)
-		GameTaskRouter.POST("delete", GameTaskApi.DeleteGameTask)
 		GameTaskRouter.POST("getGameTaskTargetList", GameTaskApi.GetGameTaskTargetList)
 		GameTaskRouter.POST("getGameTaskTargetById", GameTaskApi.GetGameTaskTargetById)
-		GameTaskRouter.POST("updateTarget", GameTaskApi.UpdateGameTaskTarget)
 		GameTaskRouter.GET("targetStatistics", GameTaskApi.TargetStatistics)
+		GameTaskRouter.POST("everyDayStatistics", GameTaskApi.EveryDayStatistics)
+		GameTaskRouter.POST("monthStatistics", GameTaskApi.MonthStatistics)
+		GameTaskRouter.POST("gameStatistics", GameTaskApi.GameStatistics)
+		GameTaskRouter.POST("gameList", GameTaskApi.GameList)
+		GameTaskRouter.POST("getGameTxTaskList", GameTaskApi.GetGameTxTaskList)
+	}
+	GameTaskRouter1 := Router.Group("gameTask").Use(middleware.OperationRecord())
+	{
+		GameTaskRouter1.POST("create", GameTaskApi.CreateGameTask)
+		GameTaskRouter1.POST("statusOperation", GameTaskApi.StatusOperation)
+		GameTaskRouter1.POST("update", GameTaskApi.UpdateGameTask)
+		GameTaskRouter1.POST("delete", GameTaskApi.DeleteGameTask)
+		GameTaskRouter1.POST("updateTarget", GameTaskApi.UpdateGameTaskTarget)
 	}
 }

service/log/log_list.go

@@ -144,7 +144,7 @@ func (s *ServiceLogList) CreateLog(c context.Context, request request.AddLogRequ
 	} else {
 		err = logical.FailLog(c, request)
 	}
-	if request.Coding == 4301001 {
+	if request.Coding == 4301001 || request.Coding == 4501001 {
 		return
 	}
 	if err != nil {

service/log/log_statistics.go

@@ -219,6 +219,10 @@ func (s *ServiceStatisticsLog) statisticsData(ctx context.Context, gameIdInt, tt
 	Freeze, _ := s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4809904", loging2.NoLogStatus, tt) // 冻结
 	BanOff := BanOff1 + BanOff2 + BanOff3 + BanOff4
 	EnterLogin := EnterXmyLogin + EnterMzLogin + EnterWxLogin
+	EnterScanningCode, _ := s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4608000", loging2.NoLogStatus, tt)
+	TranscodingFail, _ := s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4608001", loging2.FailStatus, tt)
+	ThirdPartyFail, _ := s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4608002", loging2.FailStatus, tt)
+	ScanningCodeSuccess, _ := s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4608099", loging2.OkStatus, tt)
 	//statisticsLog.NewHaveRole, _ = s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4604004", loging2.NoLogStatus, tt) // 新增有角色
 	//statisticsLog.RetainedNotRole, _ = s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4604003", loging2.NoLogStatus, tt) // 留存无角色
 	statisticsLog.PullAccountOk = pullAccountOk
@@ -265,13 +269,17 @@ func (s *ServiceStatisticsLog) statisticsData(ctx context.Context, gameIdInt, tt
 	statisticsLog.Type = tt
 	statisticsLog.CreateTime = time.Now().Format("2006-01-02 15:04:05")
 	statisticsLog.CreateDate = date
+	statisticsLog.EnterScanningCode = EnterScanningCode
+	statisticsLog.ThirdPartyFail = ThirdPartyFail
+	statisticsLog.TranscodingFail = TranscodingFail
+	statisticsLog.ScanningCodeSuccess = ScanningCodeSuccess
 	if tt == 1 {
 		statisticsLog.NotRole, _ = s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4609901", loging2.NoLogStatus, tt)
 		statisticsLog.HasRole = 0
 		statisticsLog.IssuedAccount = taskStatistics.RetainedPullAccount
 		statisticsLog.TargetNum = taskStatistics.RetainedTarget
 		statisticsLog.TargetCompleteNum = taskStatistics.RetainedComplete
-		statisticsLog.ScanningSuccessRate = 0
+		//statisticsLog.ScanningSuccessRate = 0
 	} else {
 		statisticsLog.NotRole = 0
 		statisticsLog.HasRole, _ = s.LogicalLog.CodeLogGetNum(ctx, date, gameIdInt, "4609902", loging2.NoLogStatus, tt)
@@ -279,9 +287,12 @@ func (s *ServiceStatisticsLog) statisticsData(ctx context.Context, gameIdInt, tt
 		statisticsLog.TargetCompleteNum = taskStatistics.NewComplete
 		statisticsLog.TargetNum = taskStatistics.NewTarget
 		statisticsLog.NewScanningCode = taskStatistics.NewScanningCode
-		if statisticsLog.NewScanningCode != 0 {
-			statisticsLog.ScanningSuccessRate = float64(statisticsLog.TargetNum) / float64(statisticsLog.NewScanningCode) * 100
-		}
+		//if statisticsLog.NewScanningCode != 0 {
+		//	statisticsLog.ScanningSuccessRate = float64(statisticsLog.TargetNum) / float64(statisticsLog.NewScanningCode) * 100
+		//}
+	}
+	if statisticsLog.ScanningCodeSuccess != 0 {
+		statisticsLog.ScanningSuccessRate = float64(statisticsLog.ScanningCodeSuccess) / float64(statisticsLog.EnterScanningCode) * 100
 	}
 	statisticsLog.PayComplete = taskStatistics.PayComplete
 	statisticsLog.PayTarget = taskStatistics.PayTarget
@@ -1128,3 +1139,83 @@ func (a *ServiceStatisticsLog) UpdateComputerUseLog(c log.ComputerUseRemarks) (e
 	}
 	return
 }
+
+// 统计上报的订单
+//@function: GetScanningInfoList
+//@description: 分页获取数据,
+//@param: card card.Card, info request.PageInfo, order string, desc bool
+//@return: list interface{}, total int64, err error
+func (apiService *ServiceStatisticsLog) GetScanningInfoList(api request.LogScanningRequest, info request.PageInfo, order string, desc bool) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Page - 1)
+	db := global.GVA_DB.Model(&log.LogScanningCode{})
+	var apiList []log.LogScanningCode
+	if api.CreateDate == "" {
+		api.CreateDate = time.Now().Format("2006-01-02")
+	}
+	db = db.Where("create_date = ?", api.CreateDate)
+
+	if api.GameId != 0 {
+		db = db.Where("game_id = ?", api.GameId)
+	}
+
+	if api.Status != 0 {
+		db = db.Where("status = ?", api.Status)
+	}
+
+	if api.TaskType != 0 {
+		if api.TaskType == -1 {
+			db = db.Where("task_type = ?", 0)
+		} else {
+			db = db.Where("task_type = ?", api.TaskType)
+		}
+	}
+
+	err = db.Count(&total).Error
+
+	if err != nil {
+		return apiList, total, err
+	} else {
+		db = db.Limit(limit).Offset(offset)
+		if order != "" {
+			var OrderStr string
+			// 设置有效排序key 防止sql注入
+			// 感谢 Tom4t0 提交漏洞信息
+			orderMap := make(map[string]bool, 4)
+			orderMap["id"] = true
+			orderMap["create_date"] = true
+			orderMap["game_id"] = true
+			orderMap["status"] = true
+			if orderMap[order] {
+				if desc {
+					OrderStr = order + " desc"
+				} else {
+					OrderStr = order
+				}
+			} else { // didn't matched any order key in `orderMap`
+				err = fmt.Errorf("非法的排序字段: %v", order)
+				return apiList, total, err
+			}
+
+			err = db.Order(OrderStr).Find(&apiList).Error
+		} else {
+			err = db.Order("id desc").Find(&apiList).Error
+		}
+	}
+	var apisReply []response.LogScanningReply
+	if len(apiList) != 0 {
+		for _, apiInfo := range apiList {
+			var apiReply = response.LogScanningReply{}
+			apiReply.Status = apiInfo.Status
+			apiReply.TaskType = apiInfo.TaskType
+			apiReply.GameId = apiInfo.GameId
+			apiReply.Supplier = apiInfo.Supplier
+			apiReply.OrderNum = apiInfo.OrderNum
+			apiReply.CreateDate = apiInfo.CreateTime.Format("2006-01-02")
+			apiReply.CreateTime = apiInfo.CreateTime.Format("2006-01-02 15:04:05")
+			apisReply = append(apisReply, apiReply)
+		}
+
+	}
+	return apisReply, total, err
+}

service/log/loging/logical_log.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/go-redis/redis/v8"
+	"go.uber.org/zap"
 	"log-server/global"
 	"log-server/model/log"
 	"log-server/model/log/request"
@@ -157,6 +158,7 @@ func (s *LogicalLog) RepositoryData() (*log.Loging, error) {
 	logInfo.AccountType = s.Request.AccountType
 	logInfo.TaskType = s.Request.TaskType
 	logInfo.ScriptType = s.ScriptType
+	logInfo.Remarks = s.Request.Remarks
 	logInfo.CreateDate = time.Now().Format("2006-01-02")
 	logInfo.CreateTime = time.Now().Format("2006-01-02 15:04:05")
 	return logInfo, err
@@ -811,3 +813,26 @@ func (s *LogicalLog) DelHashUuidKey(ctx context.Context, date string) {
 		}
 	}
 }
+
+// 记录扫码订单号信息
+func (s *LogicalLog) AddCodeLog(request request.AddLogRequest, status int) {
+	if request.Remarks == "" {
+		return
+	}
+	logSC := new(log.LogScanningCode)
+	logSC.GameId = request.GameId
+	logSC.LogUuid = request.LogUuid
+	logSC.TaskType = request.TaskType
+	logSC.Status = status
+	if logSC.Status == 0 {
+		logSC.Status = -1
+	}
+	codeSupplier := strings.Split(request.Remarks, "|")
+	logSC.OrderNum = codeSupplier[0]
+	logSC.Supplier = codeSupplier[1]
+	logSC.CreateDate = time.Now()
+	err := global.GVA_DB.Omit("create_time").Create(&logSC).Error
+	if err != nil {
+		global.GVA_LOG.Error("create LogScanningCode fail", zap.Error(err))
+	}
+}

service/log/loging/login_log.go

@@ -28,6 +28,9 @@ func (s *LoginLog) SuccessLog(ctx context.Context, request request.AddLogRequest
 		_ = s.logical.SetUuidCodeCache(context.Background(), s.logical.CurrentDate(), s.logical.Request.LogUuid, s.logical.Request.Coding, s.logical.Request.GameId)
 	}
 	code := strconv.Itoa(request.Coding)
+	if code[:5] == "46080" {
+		s.logical.AddCodeLog(s.logical.Request, s.logical.Status)
+	}
 	err = s.logical.PartTypeLogSetNum(ctx, s.logical.CurrentDate(), s.logical.Request.GameId, code, OkStatus, s.logical.Request.TaskType)
 	if err != nil {
 		return
@@ -61,6 +64,9 @@ func (s *LoginLog) FailLog(ctx context.Context, request request.AddLogRequest) (
 		err = s.logical.CodeLogSetNum(ctx, s.logical.CurrentDate(), s.logical.Request.GameId, strconv.Itoa(request.Coding), NoLogStatus, s.logical.Request.TaskType)
 		return
 	}
+	if code[:5] == "46080" && s.logical.Request.Remarks != "" {
+		s.logical.AddCodeLog(s.logical.Request, s.logical.Status)
+	}
 	err = s.logical.PartTypeLogSetNum(ctx, s.logical.CurrentDate(), s.logical.Request.GameId, code, FailStatus, s.logical.Request.TaskType)
 	if err != nil {
 		return

service/log/loging/pull_account_log.go

@@ -12,6 +12,7 @@ type PullAccountLog struct {
 
 func (s *PullAccountLog) SuccessLog(ctx context.Context, request request.AddLogRequest) (err error) {
 	s.logical.Status = 1
+	s.logical.ScriptType = request.ScriptType
 	s.logical.Request = request
 	err = s.logical.DataAdd()
 	if err != nil {
@@ -39,6 +40,7 @@ func (s *PullAccountLog) SuccessLog(ctx context.Context, request request.AddLogR
 func (s *PullAccountLog) FailLog(ctx context.Context, request request.AddLogRequest) (err error) {
 	s.logical.Status = 0
 	s.logical.Request = request
+	s.logical.ScriptType = request.ScriptType
 	err = s.logical.DataAdd()
 	if err != nil {
 		return

service/log/loging/simulator_start_log.go

@@ -13,6 +13,7 @@ type SimulatorStartLog struct {
 func (s *SimulatorStartLog) SuccessLog(ctx context.Context, request request.AddLogRequest) (err error) {
 	s.logical.Status = 1
 	s.logical.Request = request
+	s.logical.ScriptType = request.ScriptType
 	err = s.logical.DataAdd()
 	if err != nil {
 		return
@@ -35,6 +36,7 @@ func (s *SimulatorStartLog) SuccessLog(ctx context.Context, request request.AddL
 func (s *SimulatorStartLog) FailLog(ctx context.Context, request request.AddLogRequest) (err error) {
 	s.logical.Status = 0
 	s.logical.Request = request
+	s.logical.ScriptType = request.ScriptType
 	err = s.logical.DataAdd()
 	if err != nil {
 		return

service/task/game_task.go

@@ -125,9 +125,12 @@ func (s *GameTask) CreateGameTargetCompleteModel(oldA task.GameTask, date time.T
 	retainedTargetRate := rand.Float64()
 	if oldA.RetainedTarget < 100 {
 		retainedTarget = oldA.RetainedTarget
+	} else if oldA.RetainedTarget > 1000 {
+		retainedTarget = 1000
 	} else {
 		retainedTarget = 200
 	}
+
 	targetComplete := new(task.GameTargetComplete)
 	targetComplete.TaskId = oldA.TaskId
 	targetComplete.NewTarget = oldA.NewTarget + int(math.Ceil(newTargetRate*float64(newTarget)))
@@ -135,6 +138,9 @@ func (s *GameTask) CreateGameTargetCompleteModel(oldA task.GameTask, date time.T
 		targetComplete.NewTarget = 0
 	}
 	targetComplete.RetainedTarget = oldA.RetainedTarget + int(math.Ceil(retainedTargetRate*float64(retainedTarget)))
+	if oldA.RetainedTarget == 1 {
+		targetComplete.RetainedTarget = 1
+	}
 	targetComplete.PayTarget = 0
 	targetComplete.CreateDate = date
 	targetComplete.RetainedComplete = 0
@@ -372,6 +378,8 @@ func (s *GameTask) UpdateGameTaskStatus(c request.UpdateGameTaskStatusRequest) (
 		if c.Status == -1 {
 			status = 0
 			update["stop_time"] = time.Now().Format("2006-01-02 15:04:05")
+			date := time.Now().Add(+time.Hour * 24)
+			tx.Where("task_id = ?", c.TaskId).Where("create_date = ?", date.Format("2006-01-02")).Delete(&task.GameTargetComplete{})
 		} else {
 			date := time.Now()
 			if !errors.Is(tx.Where("task_id = ?", c.TaskId).Where("create_date = ?", date.Format("2006-01-02")).First(&task.GameTargetComplete{}).Error, gorm.ErrRecordNotFound) {
@@ -401,6 +409,11 @@ func (s *GameTask) UpdateGameTask(requestData request.GameTaskRequest) (err erro
 	if errors.Is(global.GVA_DB.Where("task_id = ?", requestData.TaskId).First(&task.GameTask{}).Error, gorm.ErrRecordNotFound) {
 		return errors.New("不存在的任务")
 	}
+	d, err := s.GetControlTaskId(requestData.TaskId)
+	if err != nil {
+		global.GVA_LOG.Error("请求群控数据报错: ", zap.Error(err))
+		return errors.New("请求群控数据报错")
+	}
 	gameTask := new(task.GameTask)
 	global.GVA_DB.Where("task_id = ?", requestData.TaskId).First(&gameTask)
 	gameTask.TaskId = requestData.TaskId
@@ -428,7 +441,7 @@ func (s *GameTask) UpdateGameTask(requestData request.GameTaskRequest) (err erro
 			global.GVA_LOG.Error("更新任务数据失败: ", zap.Error(err))
 			return err
 		}
-		_, err := s.UpdateTaskRequestControl(taskRequestData, gameTask.ControlTaskId)
+		_, err := s.UpdateTaskRequestControl(taskRequestData, d.IdDong)
 		if err != nil {
 			global.GVA_LOG.Error("更新任务数据请求群控失败: ", zap.Error(err))
 		}
@@ -460,21 +473,23 @@ func (s *GameTask) DeleteGameTask(api request.GameTaskRequest) (err error) {
 	if errors.Is(err, gorm.ErrRecordNotFound) {
 		return err
 	}
-	gameTask := new(task.GameTask)
-	global.GVA_DB.Where("task_id = ?", api.TaskId).First(&gameTask)
-	controlTaskId := gameTask.ControlTaskId
 	//update := map[string]interface{}{
 	//	"is_del":      1,
 	//	"status":      -1,
 	//	"stop_time":   time.Now(),
 	//	"delete_time": time.Now(),
 	//}
+	d, err := s.GetControlTaskId(api.TaskId)
+	if err != nil {
+		global.GVA_LOG.Error("请求群控数据报错: ", zap.Error(err))
+		return errors.New("请求群控数据报错")
+	}
 	err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
 		err := tx.Where("task_id", api.TaskId).Delete(&task.GameTask{}).Error
 		if err != nil {
 			return err
 		}
-		_, err = s.DelTaskRequestControl(controlTaskId)
+		_, err = s.DelTaskRequestControl(d.IdDong)
 		return err
 	})
 	return
@@ -484,7 +499,7 @@ func (s *GameTask) DeleteGameTask(api request.GameTaskRequest) (err error) {
 //@description: 分页获取数据,
 //@param: card card.Card, info request.PageInfo, order string, desc bool
 //@return: list interface{}, total int64, err error
-func (apiService *GameTask) GetGameTaskTargetInfoList(api request.GameTargetCompleteRequest, info request.PageInfo, order string, desc bool) (list interface{}, total int64, err error) {
+func (apiService *GameTask) GetGameTaskTargetInfoList(api request.GameTargetCompleteRequest, info request.PageInfo, order string, desc bool, isTx bool) (list interface{}, total int64, err error) {
 	limit := info.PageSize
 	offset := info.PageSize * (info.Page - 1)
 	if api.CreateDate == "" {
@@ -503,6 +518,9 @@ func (apiService *GameTask) GetGameTaskTargetInfoList(api request.GameTargetComp
 	if api.User != "" {
 		db = db.Where("gt.user LIKE ?", "%"+api.User+"%")
 	}
+	if isTx {
+		db = db.Where("gt.game_port_id = ?", 1)
+	}
 	if api.TaskId != 0 {
 		db = db.Where("gtc.task_id = ?", api.TaskId)
 	}
@@ -639,7 +657,7 @@ func (s *GameTask) UpdateGameTaskTarget(requestData request.UpdateGameTaskTarget
 	//}
 	updateData := map[string]interface{}{
 		"new_target":             requestData.NewTarget,
-		"pay_complete":           requestData.PayTarget,
+		"pay_target":             requestData.PayTarget,
 		"retained_target":        requestData.RetainedTarget,
 		"hand_new_complete":      requestData.HandNewComplete + gameTask.HandNewComplete,
 		"hand_retained_complete": requestData.HandRetainedComplete + gameTask.HandRetainedComplete,
@@ -761,3 +779,126 @@ func (s *GameTask) TargetStatistics(date string) (apiList []control.TargetStatis
 	}
 	return
 }
+
+func (s *GameTask) DayStatisticsData(request request.GameTaskStatisticsRequest) (gameTargetDates []response.GameTargetStatistics, err error) {
+	createDate := time.Now().Format("2006-01-02")
+	if request.Date == "" || request.Date == createDate {
+		request.Date = time.Now().Format("2006-01-02")
+		gameTargets, err := s.EveryDayTargetData(request.Date, request)
+		if err != nil {
+			return gameTargetDates, err
+		}
+		for _, gameTarget := range gameTargets {
+			var gameTargetDate response.GameTargetStatistics
+			gameTargetDate.PayTarget = gameTarget.PayTarget
+			gameTargetDate.NewTarget = gameTarget.NewTarget
+			gameTargetDate.RetainedTarget = gameTarget.RetainedTarget
+			gameTargetDate.PayComplete = gameTarget.PayComplete + gameTarget.HandPayComplete
+			gameTargetDate.NewComplete = gameTarget.NewComplete + gameTarget.HandNewComplete
+			gameTargetDate.RetainedComplete = gameTarget.RetainedComplete + gameTarget.HandRetainedComplete
+			gameTargetDate.Amount = gameTarget.Amount + gameTarget.HandAmountTotal
+			gameTargetDate.GamePort = GamePort[gameTarget.GamePortId]
+			gameTargetDate.User = gameTarget.User
+			gameTargetDate.TaskDate = gameTarget.CreateDate.Format("2006-01-02")
+			gameTargetDates = append(gameTargetDates, gameTargetDate)
+		}
+
+	} else {
+		gameTargets, err := s.PastDayTargetData(request.Date, request)
+		if err != nil {
+			return gameTargetDates, err
+		}
+		for _, gameTarget := range gameTargets {
+			var gameTargetDate response.GameTargetStatistics
+			gameTargetDate.PayTarget = gameTarget.PayTarget
+			gameTargetDate.NewTarget = gameTarget.NewTarget
+			gameTargetDate.RetainedTarget = gameTarget.RetainedTarget
+			gameTargetDate.PayComplete = gameTarget.PayComplete
+			gameTargetDate.NewComplete = gameTarget.NewComplete
+			gameTargetDate.RetainedComplete = gameTarget.RetainedComplete
+			gameTargetDate.Amount = gameTarget.Amount
+			gameTargetDate.TaskDate = gameTarget.TaskDate.Format("2006-01-02")
+			gameTargetDate.GamePort = GamePort[gameTarget.GamePortId]
+			gameTargetDate.User = gameTarget.User
+			gameTargetDates = append(gameTargetDates, gameTargetDate)
+		}
+
+	}
+	return
+}
+
+func (s *GameTask) EveryDayTargetData(date string, request request.GameTaskStatisticsRequest) (gameTarget []response.GameTargetCompleteReply, err error) {
+	db := global.GVA_DB.Table("game_target_complete gtc")
+	db = db.Select("gtc.create_date,SUM(gtc.new_complete) new_complete,SUM(gtc.pay_complete) pay_complete,SUM(gtc.retained_complete) retained_complete,SUM(gtc.new_target) new_target,SUM(gtc.pay_target) pay_target,SUM(gtc.retained_target) retained_target,SUM(gtc.amount) amount,SUM(gtc.hand_pay_complete) hand_pay_complete,SUM(gtc.hand_new_complete) hand_new_complete,SUM(gtc.hand_retained_complete) hand_retained_complete,SUM(gtc.hand_amount_total) hand_amount_total," +
+		"gt.user,gt.game_port_id")
+	db = db.Joins("left join game_task gt on gt.task_id = gtc.task_id")
+	db = db.Where("gtc.create_date = ?", date)
+	if request.GroupKey != "" {
+		group := "gt." + request.GroupKey
+		db = db.Group(group)
+	}
+	err = db.Find(&gameTarget).Error
+	return
+}
+
+func (s *GameTask) PastDayTargetData(date string, request request.GameTaskStatisticsRequest) (gameTarget []task.GameTargetStatistics, err error) {
+	db := global.GVA_DB.Table("game_target_statistics")
+	db = db.Where("task_date = ?", date)
+	if request.GroupKey != "" {
+		group := request.GroupKey
+		db = db.Group(group)
+	}
+	err = db.Find(&gameTarget).Error
+	return
+}
+
+func (s *GameTask) MonthStatisticsData() (gameTarget []task.GameTargetStatistics, err error) {
+	year, _, _ := time.Now().Date()
+	db := global.GVA_DB.Table("game_target_statistics")
+	db = db.Select("task_year,task_month,SUM(new_complete) new_complete,SUM(pay_complete) pay_complete,SUM(retained_complete) retained_complete,SUM(new_target) new_target,SUM(pay_target) pay_target,SUM(retained_target) retained_target,SUM(amount) amount")
+	db = db.Where("task_year = ?", year)
+	db = db.Group("task_month")
+	err = db.Find(&gameTarget).Error
+	return
+}
+
+func (s *GameTask) GameStatisticsData(date string) (gameTarget []response.GameStatisticsDataReply, err error) {
+	if date == "" {
+		date = time.Now().Format("2006-01-02")
+	}
+	db := global.GVA_DB.Table("game_target_complete gtc")
+	db = db.Select("gt.user,gt.game_port_id,COUNT(DISTINCT(gtc.task_id)) total,gtc.create_date")
+	db = db.Joins("left join game_task gt on gt.task_id = gtc.task_id")
+	db = db.Where("gtc.create_date = ?", date)
+	db = db.Group("gt.user,gt.game_port_id")
+	err = db.Find(&gameTarget).Error
+	if err != nil {
+		return nil, err
+	}
+	for i, target := range gameTarget {
+		gameTarget[i].GamePort = GamePort[target.GamePortId]
+		gameTarget[i].CreateDate = date
+	}
+	return
+}
+
+func (s *GameTask) GameStatisticsList(rq request.GameListRequest) (gameTarget []response.GameStatisticsListReply, err error) {
+	if rq.Date == "" {
+		rq.Date = time.Now().Format("2006-01-02")
+	}
+	db := global.GVA_DB.Table("game_target_complete gtc")
+	db = db.Select("gt.game_port_id,gt.game_name")
+	db = db.Joins("left join game_task gt on gt.task_id = gtc.task_id")
+	db = db.Where("gtc.create_date = ?", rq.Date)
+	db = db.Where("gt.user = ?", rq.User)
+	db = db.Where("gt.game_port_id = ?", rq.GamePortId)
+	err = db.Find(&gameTarget).Error
+	if err != nil {
+		return nil, err
+	}
+	for i, target := range gameTarget {
+		gameTarget[i].GamePort = GamePort[target.GamePortId]
+		gameTarget[i].CreateDate = rq.Date
+	}
+	return
+}

service/task/sync_data.go

@@ -3,13 +3,16 @@ package task
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"github.com/go-redis/redis/v8"
 	"go.uber.org/zap"
+	"gorm.io/gorm"
 	"log-server/global"
 	"log-server/model/log/request"
 	"log-server/model/task"
 	"log-server/model/task/control"
+	request2 "log-server/model/task/request"
 	"log-server/utils"
 	"strconv"
 	"time"
@@ -122,6 +125,9 @@ func (s *SyncData) EveryDaySyncTaskData() {
 	date := time.Now().Add(+time.Hour * 24)
 	var gameTargetCompletes []*task.GameTargetComplete
 	for _, gameTask := range apiList {
+		if !errors.Is(global.GVA_DB.Where("task_id = ?", gameTask.TaskId).Where("create_date = ?", date).First(&task.GameTargetComplete{}).Error, gorm.ErrRecordNotFound) {
+			continue
+		}
 		gameTargetComplete := s.GameTask.CreateGameTargetCompleteModel(gameTask, date)
 		gameTargetCompletes = append(gameTargetCompletes, gameTargetComplete)
 	}
@@ -203,3 +209,49 @@ func (s *SyncData) SyncTaskData() {
 	}
 	return
 }
+
+func (s *SyncData) DayTargetDataStatistics() {
+	date := time.Now().Add(-time.Hour * 24).Format("2006-01-02")
+	request1 := request2.GameTaskStatisticsRequest{
+		GroupKey: "user,gt.game_port_id",
+		Date:     date,
+	}
+	gameTargets, err := s.GameTask.EveryDayTargetData(date, request1)
+	if err != nil {
+		global.GVA_LOG.Error("DayTargetDataStatistics 统计数据失败", zap.Error(err))
+		return
+	}
+	if len(gameTargets) == 0 {
+		global.GVA_LOG.Info("没有数据统计", zap.Error(err))
+		return
+	}
+	var gameTargetDates []task.GameTargetStatistics
+	for _, gameTarget := range gameTargets {
+		var gameTargetDate task.GameTargetStatistics
+		gameTargetDate.PayTarget = gameTarget.PayTarget
+		gameTargetDate.NewTarget = gameTarget.NewTarget
+		gameTargetDate.RetainedTarget = gameTarget.RetainedTarget
+		gameTargetDate.PayComplete = gameTarget.PayComplete + gameTarget.HandPayComplete
+		gameTargetDate.NewComplete = gameTarget.NewComplete + gameTarget.HandNewComplete
+		gameTargetDate.RetainedComplete = gameTarget.RetainedComplete + gameTarget.HandRetainedComplete
+		gameTargetDate.Amount = gameTarget.Amount + gameTarget.HandAmountTotal
+		gameTargetDate.GamePortId = gameTarget.GamePortId
+		gameTargetDate.User = gameTarget.User
+		gameTargetDate.TaskDate = gameTarget.CreateDate
+		if !errors.Is(global.GVA_DB.Where("user = ?", gameTarget.User).Where("task_date = ?", gameTarget.CreateDate).Where("game_port_id = ?", gameTarget.GamePortId).First(&task.GameTargetStatistics{}).Error, gorm.ErrRecordNotFound) {
+			err := global.GVA_DB.Where("user = ?", gameTarget.User).Where("task_date = ?", gameTarget.CreateDate).Where("game_port_id = ?", gameTarget.GamePortId).Omit("update_time", "task_date", "user", "game_port_id", "task_month", "task_year").Updates(&gameTargetDate).Error
+			if err != nil {
+				global.GVA_LOG.Error("DayTargetDataStatistics 更新统计数据失败", zap.Error(err))
+			}
+			continue
+		}
+		year, month, _ := time.Now().Date()
+		gameTargetDate.TaskMonth = int(month)
+		gameTargetDate.TaskYear = year
+		gameTargetDates = append(gameTargetDates, gameTargetDate)
+	}
+	if len(gameTargetDates) < 1 {
+		return
+	}
+	global.GVA_DB.Omit("update_time").Create(gameTargetDates)
+}