任务同步

api/v1/enter.go

@@ -4,6 +4,7 @@ import (
 	"log-server/api/v1/example"
 	"log-server/api/v1/log"
 	"log-server/api/v1/system"
+	"log-server/api/v1/task"
 	"log-server/api/v1/typeManage"
 )
 
@@ -11,7 +12,8 @@ type ApiGroup struct {
 	SystemApiGroup  system.ApiGroup
 	ExampleApiGroup example.ApiGroup
 	LogApiGroup     log.GroupLog
-	TypeApiGroup typeManage.ApiGroup
+	TypeApiGroup    typeManage.ApiGroup
+	TaskApiGroup    task.GroupTask
 }
 
 var ApiGroupApp = new(ApiGroup)

api/v1/task/enter.go

@@ -0,0 +1,11 @@
+package task
+
+import "log-server/service"
+
+type GroupTask struct {
+	GameTaskApi
+}
+
+var (
+	taskService = service.ServiceGroupApp.TaskServiceGroup.GameTask
+)

api/v1/task/game_task.go

@@ -0,0 +1,163 @@
+package task
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"log-server/global"
+	"log-server/model/common/response"
+	"log-server/model/task/request"
+	"log-server/utils"
+)
+
+type GameTaskApi struct {
+}
+
+// @Tags gameTask
+// @Summary 创建游戏任务
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GameTaskRequest true
+// @Success 200 {object} response.Response{msg=string} "创建游戏任务"
+// @Router /gameTask/create [post]
+func (s *GameTaskApi) CreateGameTask(c *gin.Context) {
+	var api request.GameTaskRequest
+	_ = c.ShouldBindJSON(&api)
+	if err := utils.Verify(api, utils.GameTaskVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	if err := taskService.CreateGameTask(api); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Error(err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", 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/getGameTaskList [post]
+func (s *GameTaskApi) GetGameTaskList(c *gin.Context) {
+	var paramsInfo request.GetGameTaskListRequest
+	_ = c.ShouldBindJSON(&paramsInfo)
+	if err := utils.Verify(paramsInfo.PageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if list, total, err := taskService.GetGameTaskInfoList(paramsInfo.GameTask, paramsInfo.PageInfo, paramsInfo.OrderKey, paramsInfo.Desc); 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)
+	}
+}
+
+// @Tags gameTask
+// @Summary 根据id获取游戏任务信息
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GetById true "根据id获取游戏任务信息"
+// @Success 200 {object} response.Response{data=systemRes.GameTaskRequest} "根据id获取游戏任务信息,返回包括游戏任务信息详情"
+// @Router /gameTask/getGameTaskById [post]
+func (s *GameTaskApi) GetGameTaskById(c *gin.Context) {
+	var idInfo request.GetById
+	_ = c.ShouldBindJSON(&idInfo)
+	if err := utils.Verify(idInfo, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	api, err := taskService.GetGameTaskById(idInfo.ID)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(api, "获取成功", c)
+	}
+}
+
+// @Tags GameTask
+// @Summary 游戏任务信息状态
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.UpdateGameTaskStatusRequest true "id, 状态"
+// @Success 200 {object} response.Response{msg=string} "修改游戏任务信息状态"
+// @Router /gameTask/statusOperation [post]
+func (s *GameTaskApi) StatusOperation(c *gin.Context) {
+	var paramsInfo request.UpdateGameTaskStatusRequest
+	_ = c.ShouldBindJSON(&paramsInfo)
+	if paramsInfo.TaskId == 0 {
+		response.FailWithMessage("Id不能为空", c)
+		return
+	}
+	if paramsInfo.Status == 0 {
+		response.FailWithMessage("状态值不能为空", c)
+		return
+	}
+	if err := taskService.UpdateGameTaskStatus(paramsInfo); err != nil {
+		global.GVA_LOG.Error("修改失败!", zap.Error(err))
+		response.FailWithMessage(err.Error(), c)
+	} else {
+		response.OkWithMessage("修改成功", c)
+	}
+}
+
+// @Tags gameTask
+// @Summary 更新游戏任务
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GameTaskRequest true
+// @Success 200 {object} response.Response{msg=string} "更新游戏任务"
+// @Router /gameTask/update [post]
+func (s *GameTaskApi) UpdateGameTask(c *gin.Context) {
+	var api request.GameTaskRequest
+	_ = c.ShouldBindJSON(&api)
+	if err := utils.Verify(api, utils.GameTaskVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	if err := taskService.UpdateGameTask(api); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Error(err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+// @Tags gameTask
+// @Summary 删除gameTask
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body task.GameTask true "ID"
+// @Success 200 {object} response.Response{msg=string} "删除gameTask"
+// @Router /gameTask/delete [post]
+func (s *GameTaskApi) DeleteGameTask(c *gin.Context) {
+	var api request.GameTaskRequest
+	_ = c.ShouldBindJSON(&api)
+	if err := utils.Verify(api, utils.TaskIdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := taskService.DeleteGameTask(api); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}

config/config.go

@@ -25,6 +25,7 @@ type Server struct {
 	Timer Timer `mapstructure:"timer" json:"timer" yaml:"timer"`
 
 	// 跨域配置
-	Cors    CORS    `mapstructure:"cors" json:"cors" yaml:"cors"`
-	SendUrl SendUrl `mapstructure:"send-url" json:"send-url" yaml:"send-url"`
+	Cors           CORS           `mapstructure:"cors" json:"cors" yaml:"cors"`
+	SendUrl        SendUrl        `mapstructure:"send-url" json:"send-url" yaml:"send-url"`
+	ExtranetDomain ExtranetDomain `mapstructure:"extranet-domain" json:"extranet-domain" yaml:"extranet-domain"`
 }

config/extranet_domain.go

@@ -0,0 +1,5 @@
+package config
+
+type ExtranetDomain struct {
+	Control string `mapstructure:"control" json:"control" yaml:"control"` // 群控域名
+}

initialize/router.go

@@ -20,6 +20,8 @@ func Routers() *gin.Engine {
 	exampleRouter := router.RouterGroupApp.Example
 	logingRouter := router.RouterGroupApp.Loging
 	computerRouter := router.RouterGroupApp.Computer
+	taskRouter := router.RouterGroupApp.Task
+
 	typeManageRouter := router.RouterGroupApp.TypeManage
 	// 如果想要不使用nginx代理前端网页，可以修改 web/.env.production 下的
 	// VUE_APP_BASE_API = /
@@ -54,11 +56,12 @@ func Routers() *gin.Engine {
 		logingRouter.InitLogingRouter(PublicGroup)
 		logingRouter.InitCodingLogRouter(PublicGroup)
 		computerRouter.InitComputerRouter(PublicGroup)
-		typeManageRouter.InitGameChannelRouter(PublicGroup)		//游戏渠道路由
-		typeManageRouter.InitGameListRouter(PublicGroup)		//游戏列表路由
-		typeManageRouter.InitLoginTypeRouter(PublicGroup)	//登录类型路由
-		typeManageRouter.InitResponsiblePersonRouter(PublicGroup)	//负责人路由
-		typeManageRouter.InitAccountTypeRouter(PublicGroup)		//账号类型路由
+		typeManageRouter.InitGameChannelRouter(PublicGroup)       //游戏渠道路由
+		typeManageRouter.InitGameListRouter(PublicGroup)          //游戏列表路由
+		typeManageRouter.InitLoginTypeRouter(PublicGroup)         //登录类型路由
+		typeManageRouter.InitResponsiblePersonRouter(PublicGroup) //负责人路由
+		typeManageRouter.InitAccountTypeRouter(PublicGroup)       //账号类型路由
+		taskRouter.InitGameTaskRouter(PublicGroup)
 	}
 	PrivateGroup := Router.Group("")
 	PrivateGroup.Use(middleware.JWTAuth()).Use(middleware.CasbinHandler())

initialize/timer.go

@@ -3,6 +3,7 @@ package initialize
 import (
 	"fmt"
 	"log-server/service/log"
+	"log-server/service/task"
 
 	"log-server/config"
 	"log-server/global"
@@ -11,6 +12,7 @@ import (
 
 var serviceStatisticsLog = new(log.ServiceStatisticsLog)
 var ServiceLogList = new(log.ServiceLogList)
+var syncData = new(task.SyncData)
 
 func Timer() {
 	if global.GVA_CONFIG.Timer.Start {
@@ -48,18 +50,18 @@ func Timer() {
 	//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("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 0/57 8-23 * * * ", serviceStatisticsLog.RegularCheckPc)
+	//_, err = global.GVA_Timer.AddTaskByFunc("RegularCheckPc", "2 57 8-23 * * * ", serviceStatisticsLog.RegularCheckPc)
 	//if err != nil {
 	//	fmt.Println("RegularCheckPc timer error:", err)
 	//}
@@ -73,4 +75,14 @@ func Timer() {
 	//if err != nil {
 	//	fmt.Println("add RegularDelCheckData timer error:", err)
 	//}
+	// 定时添加任务
+	//_, err = global.GVA_Timer.AddTaskByFunc("EveryDaySyncTaskData", "2 39 18 * * *", syncData.EveryDaySyncTaskData)
+	//if err != nil {
+	//	fmt.Println("add EveryDaySyncTaskData timer error:", err)
+	//}
+	//
+	//_, err = global.GVA_Timer.AddTaskByFunc("SyncTaskData", "2 0/3 6-23 * * *", syncData.SyncTaskData)
+	//if err != nil {
+	//	fmt.Println("add SyncTaskData timer error:", err)
+	//}
 }

model/log/request/log_statistics.go

@@ -46,6 +46,7 @@ type TaskStatistics struct {
 	RetainedAccountNum    int    `json:"retained_account_num"` // 留存账号
 	FeeAccountNum         int    `json:"fee_account_num"`      // 付费账号
 	Remark                string `json:"remark"`               //负责人
+	GameRate              string `json:"game_rate"`            // 游戏效率
 }
 
 type TaskData struct {

model/task/control/request.go

@@ -0,0 +1,18 @@
+package control
+
+type CreateGameTaskRequest struct {
+	Date              string `json:"date"`
+	GameId            int    `json:"game_id"`
+	GameName          string `json:"game_name"`
+	NewTarget         int    `json:"new_target"`
+	PayTarget         int    `json:"pay_target"`
+	RetainedTarget    int    `json:"retained_target"`
+	PayPrice          int    `json:"pay_price"`
+	Remark            string `json:"remark"`
+	SpiritPackageName string `json:"spirit_package_name"`
+	GamePackageName   string `json:"game_package_name"`
+	GameIdXmy         string `json:"game_id_xmy"`
+	SyDataId          int    `json:"sy_data_id"`
+	NewRetained       string `json:"new_retained"`
+	GamePort          string `json:"game_port"`
+}

model/task/control/response.go

@@ -0,0 +1,39 @@
+package control
+
+type WslReply struct {
+	GameId string `json:"gameid"`
+	Money  string `json:"money"`
+}
+
+//{"active_user_num":"13","game_id":"1000680","date":"2022-12-12","amount":"0","cnt":"0","user_num":"0","name":"\u5e7b\u5854\u9177\u6d3e"}
+type XmyCommonReply struct {
+	Status bool   `json:"status"`
+	Msg    string `json:"msg"`
+}
+
+type XmyPayRequestReplyData struct {
+	ActiveUserNum string `json:"active_user_num"`
+	GameId        string `json:"game_id"`
+	Amount        string `json:"amount"`
+	Cnt           string `json:"cnt"`
+	UserNum       string `json:"user_num"`
+}
+
+type XmyReply struct {
+	XmyCommonReply
+	Data struct {
+		List []XmyPayRequestReplyData `json:"list"`
+	}
+}
+
+type XmyFree struct {
+	Amount string `json:"amount"`
+	UseNum string `json:"use_num"`
+	Num    string `json:"num"`
+}
+
+type XmyFreeReply struct {
+	Code int       `json:"code"`
+	Msg  string    `json:"msg"`
+	Data []XmyFree `json:"data"`
+}

model/task/game_target_complete.go

@@ -0,0 +1,22 @@
+package task
+
+import "time"
+
+type GameTargetComplete 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"`
+}
+
+func (GameTargetComplete) TableName() string {
+	return "game_target_complete"
+}

model/task/game_task.go

@@ -0,0 +1,37 @@
+package task
+
+import "time"
+
+type GameTask struct {
+	Id             uint      `json:"id"`
+	TaskId         int       `json:"task_id"`
+	TaskName       string    `json:"task_name"`
+	User           string    `json:"user"`
+	NewRetained    string    `json:"new_retained"`
+	GameName       string    `json:"game_name"`
+	GameId         int       `json:"game_id"`
+	Date           time.Time `json:"date"`
+	GamePortId     int       `json:"game_port_id"`
+	AccountType    int       `json:"account_type"`
+	LoginMethod    int       `json:"login_method"`
+	TxChannel      string    `json:"tx_channel"`
+	TxGameId       string    `json:"tx_game_id"`
+	MzChannel      string    `json:"mz_channel"`
+	MzGameId       string    `json:"mz_game_id"`
+	GameIdXmy      string    `json:"game_id_xmy"`
+	NewTarget      int       `json:"new_target"`
+	PayTarget      int       `json:"pay_target"`
+	RetainedTarget int       `json:"retained_target"`
+	PayPrice       int       `json:"pay_price"`
+	ControlTaskId  int       `json:"control_task_id"`
+	CreateTime     time.Time `json:"create_time"` // 创建时间
+	UpdateTime     time.Time `json:"update_time"` // 更新时间
+	Status         int       `json:"status"`      // 状态-1关闭，1开启
+	IsDel          int       `json:"is_del"`      // 是否删除-1删除，1正常
+	DeleteTime     time.Time `json:"delete_time"`
+	StopTime       time.Time `json:"stop_time"`
+}
+
+func (GameTask) TableName() string {
+	return "game_task"
+}

model/task/request/common.go

@@ -0,0 +1,33 @@
+package request
+
+// PageInfo Paging common input parameter structure
+type PageInfo struct {
+	Page     int    `json:"page" form:"page"`         // 页码
+	PageSize int    `json:"pageSize" form:"pageSize"` // 每页大小
+	Keyword  string `json:"keyword" form:"keyword"`   //关键字
+}
+
+// GetById Find by id structure
+type GetById struct {
+	ID int `json:"id" form:"id"` // 主键ID
+}
+
+// Create Date Find by id structure
+type CreateDateReply struct {
+	CreateDate string `json:"create_date"` // 日期
+}
+
+func (r *GetById) Uint() uint {
+	return uint(r.ID)
+}
+
+type IdsReq struct {
+	Ids []int `json:"ids" form:"ids"`
+}
+
+// GetAuthorityId Get role by id structure
+type GetAuthorityId struct {
+	AuthorityId uint `json:"authorityId" form:"authorityId"` // 角色ID
+}
+
+type Empty struct{}

model/task/request/game_task.go

@@ -0,0 +1,38 @@
+package request
+
+import "log-server/model/task"
+
+type GameTaskRequest struct {
+	Id             uint   `json:"id"`
+	TaskId         int    `json:"task_id"`
+	TaskName       string `json:"task_name"`
+	User           string `json:"user"`
+	NewRetained    string `json:"new_retained"`
+	GameName       string `json:"game_name"`
+	GameId         int    `json:"game_id"`
+	Date           string `json:"date"`
+	GamePortId     int    `json:"game_port_id"`
+	AccountType    int    `json:"account_type"`
+	LoginMethod    int    `json:"login_method"`
+	TxChannel      string `json:"tx_channel"`
+	TxGameId       string `json:"tx_game_id"`
+	MzChannel      string `json:"mz_channel"`
+	MzGameId       string `json:"mz_game_id"`
+	GameIdXmy      string `json:"game_id_xmy"`
+	NewTarget      int    `json:"new_target"`
+	PayTarget      int    `json:"pay_target"`
+	RetainedTarget int    `json:"retained_target"`
+	PayPrice       int    `json:"pay_price"`
+}
+
+type GetGameTaskListRequest struct {
+	task.GameTask
+	PageInfo
+	OrderKey string `json:"orderKey"` // 排序
+	Desc     bool   `json:"desc"`     // 排序方式:升序false(默认)|降序true
+}
+
+type UpdateGameTaskStatusRequest struct {
+	TaskId int `json:"task_id"`
+	Status int `json:"status"` // 状态-1关闭，1开启
+}

model/task/response/common.go

@@ -0,0 +1,8 @@
+package response
+
+type PageResult struct {
+	List     interface{} `json:"list"`
+	Total    int64       `json:"total"`
+	Page     int         `json:"page"`
+	PageSize int         `json:"pageSize"`
+}

model/task/response/game_task.go

@@ -0,0 +1,20 @@
+package response
+
+type GetGameTaskListReply struct {
+	TaskId         int    `json:"task_id"`
+	TaskName       string `json:"task_name"`
+	User           string `json:"user"`
+	GameName       string `json:"game_name"`
+	Date           string `json:"date"`
+	GamePort       string `json:"game_port"`
+	AccountType    string `json:"account_type"`
+	LoginMethod    string `json:"login_method"`
+	NewTarget      int    `json:"new_target"`
+	PayTarget      int    `json:"pay_target"`
+	RetainedTarget int    `json:"retained_target"`
+	PayPrice       int    `json:"pay_price"`
+	Status         int    `json:"status"`      // 状态-1关闭，1开启
+	CreateTime     string `json:"create_time"` // 创建时间
+	UpdateTime     string `json:"update_time"` // 更新时间
+	StopTime       string `json:"stop_time"`
+}

router/enter.go

@@ -4,15 +4,17 @@ import (
 	"log-server/router/example"
 	"log-server/router/log"
 	"log-server/router/system"
+	"log-server/router/task"
 	"log-server/router/typeManage"
 )
 
 type RouterGroup struct {
-	System   system.RouterGroup
-	Example  example.RouterGroup
-	Loging   log.RouterGroup
-	Computer log.ComputerRouter
+	System     system.RouterGroup
+	Example    example.RouterGroup
+	Loging     log.RouterGroup
+	Computer   log.ComputerRouter
 	TypeManage typeManage.RouterGroup
+	Task       task.GameTaskRouter
 }
 
 var RouterGroupApp = new(RouterGroup)

router/task/enter.go

@@ -0,0 +1,5 @@
+package task
+
+type RouterGroup struct {
+	GameTaskRouter
+}

router/task/game_task.go

@@ -0,0 +1,22 @@
+package task
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "log-server/api/v1"
+)
+
+type GameTaskRouter struct {
+}
+
+func (e *GameTaskRouter) InitGameTaskRouter(Router *gin.RouterGroup) {
+	GameTaskRouter := Router.Group("gameTask")
+	GameTaskApi := v1.ApiGroupApp.TaskApiGroup.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)
+	}
+}

service/enter.go

@@ -4,6 +4,7 @@ import (
 	"log-server/service/example"
 	"log-server/service/log"
 	"log-server/service/system"
+	"log-server/service/task"
 	"log-server/service/typeManage"
 )
 
@@ -12,6 +13,7 @@ type ServiceGroup struct {
 	ExampleServiceGroup example.ServiceGroup
 	LogServiceGroup     log.ServiceGroup
 	TypeServiceGroup    typeManage.ServiceGroup
+	TaskServiceGroup    task.ServiceGroup
 }
 
 var ServiceGroupApp = new(ServiceGroup)

service/log/log_statistics.go

@@ -170,7 +170,6 @@ func (s *ServiceStatisticsLog) statisticsData(ctx context.Context, gameIdInt, tt
 			global.GVA_LOG.Error("添加缓存数据失败TaskStatisticsDataCache", zap.Error(err))
 			return nil
 		}
-
 	}
 	var taskStatistics request.TaskStatistics
 	_ = json.Unmarshal([]byte(data), &taskStatistics)

service/task/enter.go

@@ -0,0 +1,5 @@
+package task
+
+type ServiceGroup struct {
+	GameTask
+}

service/task/game_task.go

@@ -0,0 +1,465 @@
+package task
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+	"log-server/global"
+	"log-server/model/task"
+	"log-server/model/task/control"
+	"log-server/model/task/request"
+	"log-server/model/task/response"
+	"log-server/utils"
+	"math"
+	"math/rand"
+	"strconv"
+	"time"
+)
+
+var AccountType = map[int]string{
+	1: "小绵羊账号",
+	2: "QQ账号",
+	3: "魅族账号",
+	4: "华为账号",
+	5: "测试类型",
+	6: "微信",
+	7: "微信+QQ",
+}
+
+var LoginMethod = map[int]string{
+	1: "小绵羊登录",
+	2: "魅族账号登录",
+	3: "QQ账号登录",
+	4: "网易账号登录",
+	5: "微信授权登录",
+	6: "微信+QQ授权登录",
+}
+var GamePort = map[int]string{
+	1: "腾讯游戏",
+	2: "360游戏",
+	3: "网易游戏",
+	4: "酷派游戏",
+	5: "魅族游戏",
+}
+
+var (
+	CreateTaskUrl           = "/v1/task_statistics"
+	GetControlTaskIdUrl     = "/v1/task_statistics/get_data_id"
+	UpdateGameTaskStatusUrl = "/v1/install_info/updateinstallstatus"
+)
+
+type GameTask struct {
+}
+
+// 创建游戏任务
+func (s *GameTask) CreateGameTask(requestData request.GameTaskRequest) (err error) {
+	if !errors.Is(global.GVA_DB.Where("task_id = ?", requestData.TaskId).First(&task.GameTask{}).Error, gorm.ErrRecordNotFound) {
+		return errors.New("存在相同任务ID")
+	}
+	gameTask := new(task.GameTask)
+	gameTask.TaskId = requestData.TaskId
+	gameTask.TaskName = requestData.TaskName
+	gameTask.User = requestData.User
+	gameTask.NewRetained = requestData.NewRetained
+	gameTask.GameName = requestData.GameName
+	gameTask.GameId = requestData.GameId
+	gameTask.Date = time.Now()
+	gameTask.GamePortId = requestData.GamePortId
+	gameTask.AccountType = requestData.AccountType
+	gameTask.LoginMethod = requestData.LoginMethod
+	gameTask.TxChannel = requestData.TxChannel
+	gameTask.TxGameId = requestData.TxGameId
+	gameTask.MzChannel = requestData.MzChannel
+	gameTask.MzGameId = requestData.MzGameId
+	gameTask.GameIdXmy = requestData.GameIdXmy
+	gameTask.NewTarget = requestData.NewTarget
+	gameTask.PayTarget = requestData.PayTarget
+	gameTask.RetainedTarget = requestData.RetainedTarget
+	gameTask.PayPrice = requestData.PayPrice
+	//gameTask.CreateTime		= requestData.CreateTime
+	//gameTask.UpdateTime		= requestData.UpdateTime
+	//gameTask.Status			= requestData.Status
+	//gameTask.IsDel			= requestData.IsDel
+	//gameTask.DeleteTime		= requestData.DeleteTime
+	taskRequestData := s.CreateGameTaskRequestData(requestData)
+	err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
+		err = tx.Omit("create_time", "update_time", "status", "is_del", "delete_time", "control_task_id").Create(&gameTask).Error
+		if err != nil {
+			global.GVA_LOG.Error("添加任务数据失败: ", zap.Error(err))
+			return err
+		}
+		_, err := s.CreateTaskRequestControl(taskRequestData)
+		if err != nil {
+			global.GVA_LOG.Error("添加任务数据请求群控失败: ", zap.Error(err))
+		}
+		return err
+	})
+	if err != nil {
+		return err
+	}
+	// 同步群控任务id
+	d, err := s.GetControlTaskId(taskRequestData.GameId)
+	if err != nil {
+		global.GVA_LOG.Error("获取群控的任务id失败")
+		return err
+	}
+	err = global.GVA_DB.Model(&task.GameTask{}).Where("task_id = ?", taskRequestData.GameId).Update("control_task_id", d.IdDong).Error
+	return
+}
+
+// 创建游戏任务完成model
+func (s *GameTask) CreateGameTargetCompleteModel(oldA task.GameTask, date time.Time) *task.GameTargetComplete {
+	var newTarget int
+	rand.Seed(time.Now().UnixNano())
+	newTargetRate := rand.Float64()
+	if oldA.NewTarget <= 10 {
+		newTarget = 10
+	} else {
+		newTarget = int(math.Ceil(float64(oldA.NewTarget) * 0.5))
+	}
+	var retainedTarget int
+	rand.Seed(time.Now().UnixNano())
+	retainedTargetRate := rand.Float64()
+	if oldA.NewTarget < 100 {
+		newTarget = oldA.NewTarget
+	} else {
+		newTarget = 200
+	}
+	targetComplete := new(task.GameTargetComplete)
+	targetComplete.TaskId = oldA.TaskId
+	targetComplete.NewTarget = oldA.NewTarget + int(math.Ceil(newTargetRate*float64(newTarget)))
+	targetComplete.RetainedTarget = oldA.RetainedTarget + int(math.Ceil(retainedTargetRate*float64(retainedTarget)))
+	targetComplete.PayTarget = 0
+	targetComplete.CreateDate = date
+	targetComplete.RetainedComplete = 0
+	targetComplete.PayComplete = 0
+	targetComplete.NewComplete = 0
+	return targetComplete
+}
+
+// 创建任务群控请求数据
+func (s *GameTask) CreateGameTaskRequestData(requestData request.GameTaskRequest) control.CreateGameTaskRequest {
+	gameTask := control.CreateGameTaskRequest{}
+	gameTask.GameId = requestData.TaskId
+	gameTask.GameName = requestData.TaskName
+	gameTask.Remark = requestData.User
+	gameTask.NewRetained = requestData.NewRetained
+	gameTask.Date = time.Now().Format("2006-01-02")
+	gameTask.GamePort = GamePort[requestData.GamePortId]
+	gameTask.GameIdXmy = requestData.GameIdXmy
+	gameTask.NewTarget = requestData.NewTarget
+	gameTask.PayTarget = requestData.PayTarget
+	gameTask.RetainedTarget = requestData.RetainedTarget
+	gameTask.PayPrice = requestData.PayPrice
+	gameTask.SyDataId = requestData.TaskId
+	gameTask.SpiritPackageName = "0"
+	gameTask.GamePackageName = "0"
+	return gameTask
+}
+
+// http请求群控创建任务
+func (s *GameTask) CreateTaskRequestControl(requestData control.CreateGameTaskRequest) (d string, err error) {
+	url := global.GVA_CONFIG.ExtranetDomain.Control + CreateTaskUrl
+	data, code, err := utils.HttpPostReplyCode(url, requestData)
+	fmt.Println(code)
+	if code != 200 {
+		return string(data), errors.New(string(data))
+	}
+	d = string(data)
+	return
+}
+
+// http请求群控更新任务
+func (s *GameTask) UpdateTaskRequestControl(requestData control.CreateGameTaskRequest, controlTaskId int) (d string, err error) {
+	url := global.GVA_CONFIG.ExtranetDomain.Control + CreateTaskUrl + "/" + strconv.Itoa(controlTaskId)
+	data, code, err := utils.HttpPutReplyCode(url, requestData)
+	fmt.Println(code)
+	if code != 200 {
+		return string(data), errors.New(string(data))
+	}
+	d = string(data)
+	return
+}
+
+type ControlTaskId struct {
+	IdDong int
+	IdYang int
+}
+
+// http请求获取群控创建任务id
+func (s *GameTask) GetControlTaskId(gameId int) (d *ControlTaskId, err error) {
+	url := global.GVA_CONFIG.ExtranetDomain.Control + GetControlTaskIdUrl
+	requestData := map[string]string{
+		"game_id": strconv.Itoa(gameId),
+	}
+	data, code, err := utils.HttpGetReplyCode(url, requestData)
+	fmt.Println(code)
+	if code != 200 {
+		return d, errors.New(string(data))
+	}
+	msg := new(ControlTaskId)
+	_ = json.Unmarshal(data, &msg)
+	d = msg
+	return
+}
+
+//@author: [piexlmax](https://github.com/piexlmax)
+//@function: GetGameTaskInfoList
+//@description: 分页获取数据,
+//@param: card card.Card, info request.PageInfo, order string, desc bool
+//@return: list interface{}, total int64, err error
+func (apiService *GameTask) GetGameTaskInfoList(api task.GameTask, 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(&task.GameTask{})
+	var apiList []task.GameTask
+	db = db.Where("is_del = ?", -1)
+	if api.TaskName != "" {
+		db = db.Where("task_name LIKE ?", "%"+api.TaskName+"%")
+	}
+
+	if api.User != "" {
+		db = db.Where("user LIKE ?", "%"+api.User+"%")
+	}
+
+	if api.Status != 0 {
+		db = db.Where("status = ?", api.Status)
+	}
+
+	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["task_name"] = true
+			orderMap["user"] = 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.GetGameTaskListReply
+	if len(apiList) != 0 {
+		for _, apiInfo := range apiList {
+			var apiReply = new(response.GetGameTaskListReply)
+			apiReply.Status = apiInfo.Status
+			apiReply.TaskId = apiInfo.TaskId
+			apiReply.TaskName = apiInfo.TaskName
+			apiReply.GamePort = GamePort[apiInfo.GamePortId]
+			apiReply.AccountType = AccountType[apiInfo.AccountType]
+			apiReply.LoginMethod = LoginMethod[apiInfo.LoginMethod]
+			apiReply.CreateTime = apiInfo.CreateTime.Format("2006-01-02 15:04:05")
+			apiReply.User = apiInfo.User
+			apiReply.Date = apiInfo.Date.Format("2006-01-02")
+			apiReply.GameName = apiInfo.GameName
+			apiReply.UpdateTime = apiInfo.UpdateTime.Format("2006-01-02 15:04:05")
+			apiReply.NewTarget = apiInfo.NewTarget
+			apiReply.PayTarget = apiInfo.PayTarget
+			apiReply.RetainedTarget = apiInfo.RetainedTarget
+			apiReply.PayPrice = apiInfo.PayPrice
+			apiReply.StopTime = apiInfo.StopTime.Format("2006-01-02 15:04:05")
+			if apiInfo.Status == 1 {
+				apiReply.StopTime = ""
+			}
+			apisReply = append(apisReply, apiReply)
+		}
+
+	}
+	return apisReply, total, err
+}
+
+//@author: [piexlmax](https://github.com/piexlmax)
+//@function: GetGameTaskById
+//@description: 根据id获取GameTask
+//@param: id uint
+//@return: apiReply response.GetPcListReply, err error
+func (c *GameTask) GetGameTaskById(id int) (gameTask request.GameTaskRequest, err error) {
+	var requestData task.GameTask
+	err = global.GVA_DB.Where("task_id = ?", id).First(&requestData).Error
+	if err != nil {
+		return
+	}
+	gameTask.TaskId = requestData.TaskId
+	gameTask.TaskName = requestData.TaskName
+	gameTask.User = requestData.User
+	gameTask.NewRetained = requestData.NewRetained
+	gameTask.GameName = requestData.GameName
+	gameTask.GamePortId = requestData.GamePortId
+	gameTask.AccountType = requestData.AccountType
+	gameTask.LoginMethod = requestData.LoginMethod
+	gameTask.TxChannel = requestData.TxChannel
+	gameTask.TxGameId = requestData.TxGameId
+	gameTask.MzChannel = requestData.MzChannel
+	gameTask.MzGameId = requestData.MzGameId
+	gameTask.GameIdXmy = requestData.GameIdXmy
+	gameTask.NewTarget = requestData.NewTarget
+	gameTask.PayTarget = requestData.PayTarget
+	gameTask.RetainedTarget = requestData.RetainedTarget
+	gameTask.PayPrice = requestData.PayPrice
+	return
+}
+
+// http请求群控更新任务装
+func (s *GameTask) UpdateControlStatus(gameId int, status int) (err error) {
+	url := global.GVA_CONFIG.ExtranetDomain.Control + UpdateGameTaskStatusUrl
+	requestData := map[string]string{
+		"status":  strconv.Itoa(status),
+		"game_id": strconv.Itoa(gameId),
+	}
+	data, code, err := utils.HttpGetReplyCode(url, requestData)
+	if err != nil {
+		return err
+	}
+	fmt.Println(code)
+	if code != 200 {
+		return errors.New(string(data))
+	}
+	return
+}
+
+//@author: [piexlmax](https://github.com/piexlmax)
+//@function: UpdateGameTaskStatus
+//@description: 根据id更新GameTask状态
+//@param: GameTask request.UpdateGameTaskRequest
+//@return: err error
+func (s *GameTask) UpdateGameTaskStatus(c request.UpdateGameTaskStatusRequest) (err error) {
+	var oldA task.GameTask
+	err = global.GVA_DB.Where("task_id = ?", c.TaskId).First(&oldA).Error
+	if err != nil {
+		return err
+	}
+	err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
+		update := map[string]interface{}{
+			"status": c.Status,
+		}
+		status := c.Status
+		if c.Status == -1 {
+			status = 0
+			update["stop_time"] = time.Now().Format("2006-01-02 15:04:05")
+		} 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) {
+				global.GVA_LOG.Info("当天的任务目标已存在")
+			} else {
+				targetComplete := s.CreateGameTargetCompleteModel(oldA, date)
+				err := tx.Omit("update_time").Create(&targetComplete).Error
+				if err != nil {
+					global.GVA_LOG.Error("创建任务目标数据失败", zap.Error(err))
+					return err
+				}
+			}
+		}
+		err := tx.Table("game_task").Where("task_id", c.TaskId).Updates(update).Error
+		if err != nil {
+			return err
+		}
+		err = s.UpdateControlStatus(c.TaskId, status)
+		return err
+	})
+
+	return err
+}
+
+// 更新GameTask
+func (s *GameTask) UpdateGameTask(requestData request.GameTaskRequest) (err error) {
+	if errors.Is(global.GVA_DB.Where("task_id = ?", requestData.TaskId).First(&task.GameTask{}).Error, gorm.ErrRecordNotFound) {
+		return errors.New("不存在的任务")
+	}
+	gameTask := new(task.GameTask)
+	global.GVA_DB.Where("task_id = ?", requestData.TaskId).First(&gameTask)
+	gameTask.TaskId = requestData.TaskId
+	gameTask.TaskName = requestData.TaskName
+	gameTask.User = requestData.User
+	gameTask.NewRetained = requestData.NewRetained
+	gameTask.GameName = requestData.GameName
+	gameTask.GameId = requestData.GameId
+	gameTask.GamePortId = requestData.GamePortId
+	gameTask.AccountType = requestData.AccountType
+	gameTask.LoginMethod = requestData.LoginMethod
+	gameTask.TxChannel = requestData.TxChannel
+	gameTask.TxGameId = requestData.TxGameId
+	gameTask.MzChannel = requestData.MzChannel
+	gameTask.MzGameId = requestData.MzGameId
+	gameTask.GameIdXmy = requestData.GameIdXmy
+	gameTask.NewTarget = requestData.NewTarget
+	gameTask.PayTarget = requestData.PayTarget
+	gameTask.RetainedTarget = requestData.RetainedTarget
+	gameTask.PayPrice = requestData.PayPrice
+	taskRequestData := s.CreateGameTaskRequestData(requestData)
+	err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
+		err = tx.Where("task_id = ?", requestData.TaskId).Omit("create_time", "update_time", "status", "is_del", "delete_time", "control_task_id", "date", "task_id").Updates(&gameTask).Error
+		if err != nil {
+			global.GVA_LOG.Error("更新任务数据失败: ", zap.Error(err))
+			return err
+		}
+		_, err := s.UpdateTaskRequestControl(taskRequestData, gameTask.ControlTaskId)
+		if err != nil {
+			global.GVA_LOG.Error("更新任务数据请求群控失败: ", zap.Error(err))
+		}
+		return err
+	})
+	return
+}
+
+// http请求群控刪除任务
+func (s *GameTask) DelTaskRequestControl(controlTaskId int) (d string, err error) {
+	url := global.GVA_CONFIG.ExtranetDomain.Control + CreateTaskUrl + "/" + strconv.Itoa(controlTaskId)
+	data, code, err := utils.HttpDeleteReplyCode(url, nil)
+	fmt.Println(code)
+	if code != 200 {
+		return string(data), errors.New(string(data))
+	}
+	d = string(data)
+	return
+}
+
+//@author: [piexlmax](https://github.com/piexlmax)
+//@function: DeleteGameTask
+//@description: 删除GameTask
+//@param: api task.GameTask
+//@return: err error
+func (s *GameTask) DeleteGameTask(api request.GameTaskRequest) (err error) {
+	var entity task.GameTask
+	err = global.GVA_DB.Where("task_id = ?", api.TaskId).First(&entity).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(),
+	}
+	err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
+		err := tx.Table("game_task").Where("task_id", api.TaskId).Updates(update).Error
+		if err != nil {
+			return err
+		}
+		_, err = s.DelTaskRequestControl(controlTaskId)
+		return err
+	})
+	return
+}

service/task/sync_data.go

@@ -0,0 +1,176 @@
+package task
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/go-redis/redis/v8"
+	"go.uber.org/zap"
+	"log-server/global"
+	"log-server/model/log/request"
+	"log-server/model/task"
+	"log-server/model/task/control"
+	"log-server/utils"
+	"strconv"
+	"time"
+)
+
+type SyncData struct {
+	GameTask GameTask
+}
+
+func (s *SyncData) SyncXmyGameData(date string) (mps map[int]control.XmyPayRequestReplyData, err error) {
+	xmyUrl := "http://api.sheepsdk.17xmy.com/foreign/api/get_youhua_data.php"
+	xmyParams := map[string]string{
+		"start_day": date,
+		"end_day":   date,
+	}
+	requestData := new(control.XmyReply)
+	xmyByteData, err := utils.HttpGet(xmyUrl, xmyParams)
+	if err != nil {
+		return
+	}
+	_ = json.Unmarshal(xmyByteData, &requestData)
+	mps = map[int]control.XmyPayRequestReplyData{}
+	for _, data := range requestData.Data.List {
+		gameId, _ := strconv.Atoi(data.GameId)
+		mps[gameId] = data
+	}
+	return
+}
+
+func (s *SyncData) SyncXmyFreeData(date string, gameId int) (num int, err error) {
+	xmyFreeUrl := "http://rtd.kfzs.com/fake.php"
+	xmyFreeParams := map[string]string{
+		"day":     date,
+		"game_id": strconv.Itoa(gameId),
+	}
+	requestData := new(control.XmyFreeReply)
+	xmyByteData, err := utils.HttpGet(xmyFreeUrl, xmyFreeParams)
+	if err != nil {
+		return
+	}
+	_ = json.Unmarshal(xmyByteData, &requestData)
+	if len(requestData.Data) != 0 {
+		num, _ = strconv.Atoi(requestData.Data[0].Num)
+	}
+	return
+}
+
+func (s *SyncData) SyncWslGameData(date string) (mps map[string]int, err error) {
+	wslUrl := "http://148.70.251.170/wsl-A/get_sheep_pay.php"
+	wslParams := map[string]string{
+		"times": date,
+	}
+	var requestData []control.WslReply
+	wslByteData, err := utils.HttpGet(wslUrl, wslParams)
+	if err != nil {
+		return
+	}
+	_ = json.Unmarshal(wslByteData, &requestData)
+	mps = map[string]int{}
+	for _, data := range requestData {
+		num, _ := strconv.Atoi(data.Money)
+		mps[data.GameId] = num
+	}
+	return
+}
+
+var taskStatistics = "%s:taskStatistics"
+
+func (s *SyncData) SyncRoomData(date string, gameIdInt int) (ts request.TaskStatistics, err error) {
+	ctx := context.Background()
+	key := fmt.Sprintf(taskStatistics, date)
+	gameIdStr := strconv.Itoa(gameIdInt)
+	data, err := global.GVA_REDIS.HGet(ctx, key, gameIdStr).Result()
+	if err != nil {
+		if err == redis.Nil {
+			global.GVA_LOG.Info("SyncRoomData not data", zap.Error(err))
+		} else {
+			global.GVA_LOG.Error("SyncRoomData fail", zap.Error(err))
+			return
+		}
+	}
+	_ = json.Unmarshal([]byte(data), &ts)
+	return
+}
+
+// 同步每天的任务基础数据
+func (s *SyncData) EveryDaySyncTaskData() {
+	db := global.GVA_DB.Model(&task.GameTask{})
+	var apiList []task.GameTask
+	db = db.Where("is_del = ?", -1)
+	db = db.Where("status = ?", 1)
+	err := db.Order("id desc").Find(&apiList).Error
+	if err != nil {
+		global.GVA_LOG.Error("EveryDaySyncTaskData fail", zap.Error(err))
+		return
+	}
+	date := time.Now().Add(+time.Hour * 24)
+	var gameTargetCompletes []*task.GameTargetComplete
+	for _, gameTask := range apiList {
+		gameTargetComplete := s.GameTask.CreateGameTargetCompleteModel(gameTask, date)
+		gameTargetCompletes = append(gameTargetCompletes, gameTargetComplete)
+	}
+	err = global.GVA_DB.Model(&task.GameTargetComplete{}).Create(gameTargetCompletes).Error
+	if err != nil {
+		global.GVA_LOG.Error("create GameTargetComplete fail", zap.Error(err))
+		return
+	}
+	return
+}
+
+// 定时同步机房群控、小绵羊数据
+func (s *SyncData) SyncTaskData() {
+	db := global.GVA_DB.Model(&task.GameTask{})
+	var apiList []task.GameTask
+	db = db.Where("is_del = ?", -1)
+	db = db.Where("status = ?", 1)
+	err := db.Order("id desc").Find(&apiList).Error
+	if err != nil {
+		global.GVA_LOG.Error("EveryDaySyncTaskData fail", zap.Error(err))
+		return
+	}
+	date := time.Now().Format("2006-01-02")
+	xmyGameData, err := s.SyncXmyGameData(date)
+	if err != nil {
+		global.GVA_LOG.Error("SyncTaskData get xmy data fail", zap.Error(err))
+		return
+	}
+	wslData, err := s.SyncWslGameData(date)
+	if err != nil {
+		global.GVA_LOG.Error("SyncWslGameData get wsl data fail", zap.Error(err))
+		return
+	}
+	for _, gameTask := range apiList {
+		var gameTarget task.GameTargetComplete
+		roomData, _ := s.SyncRoomData(date, gameTask.TaskId)
+		if gameTask.GameIdXmy != "" {
+			gameIdXmy, _ := strconv.Atoi(gameTask.GameIdXmy)
+			xmyGameInfo := xmyGameData[gameIdXmy]
+			gameTarget.NewComplete, _ = strconv.Atoi(xmyGameInfo.UserNum)
+			gameTarget.PayComplete, _ = strconv.Atoi(xmyGameInfo.Cnt)
+			gameTarget.RetainedComplete, _ = strconv.Atoi(xmyGameInfo.ActiveUserNum)
+			gameTarget.Amount, _ = strconv.Atoi(xmyGameInfo.Amount)
+			num, _ := s.SyncXmyFreeData(date, gameIdXmy)
+			if num != 0 {
+				gameTarget.PayTarget = num
+			}
+		} else {
+			gameTarget.NewComplete = roomData.NewCompleteLocal
+			gameTarget.PayComplete = roomData.PayCompleteLocal
+			gameTarget.RetainedComplete = roomData.NewCompleteLocal + roomData.RetainedCompleteLocal
+			gameTarget.Amount = 6
+		}
+		gameTarget.GameRate = roomData.GameRate
+		if gameTask.GamePortId == 5 && gameTask.LoginMethod == 2 {
+			mzGameId := gameTask.MzGameId + "-" + gameTask.MzChannel
+			if _, ok := wslData[mzGameId]; ok {
+				gameTarget.PayTarget = wslData[mzGameId]
+			}
+		}
+		global.GVA_DB.Model(&task.GameTargetComplete{}).Where("task_id = ?", gameTask.TaskId).Where("create_date = ?", date).Omit("create_date", "update_time", "task_id").Updates(gameTarget)
+	}
+
+	return
+}

utils/requst_http.go

@@ -60,3 +60,104 @@ func HttpPost(url string, params interface{}) (result []byte, err error) {
 	result = body
 	return
 }
+
+func HttpPostReplyCode(url string, params interface{}) (result []byte, code int, err error) {
+	data, _ := json.Marshal(params)
+	client := &http.Client{}
+	req, err := http.NewRequest("POST", url, strings.NewReader(string(data)))
+	if err != nil {
+		return
+	}
+	fmt.Println(url)
+	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
+	resp, err := client.Do(req)
+	if err != nil {
+		return
+	}
+	code = resp.StatusCode
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	result = body
+	return
+}
+
+func HttpGetReplyCode(url string, params map[string]string) (result []byte, code int, err error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	q := req.URL.Query()
+	for k, v := range params {
+		q.Add(k, v)
+	}
+	req.URL.RawQuery = q.Encode()
+	fmt.Println(req.URL.String())
+	var resp *http.Response
+
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil || resp == nil {
+		return
+	}
+	code = resp.StatusCode
+	output, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	result = output
+	defer func() {
+		if resp != nil {
+			resp.Body.Close()
+		}
+	}()
+	return
+}
+
+func HttpPutReplyCode(url string, params interface{}) (result []byte, code int, err error) {
+	data, _ := json.Marshal(params)
+	client := &http.Client{}
+	req, err := http.NewRequest("PUT", url, strings.NewReader(string(data)))
+	if err != nil {
+		return
+	}
+	fmt.Println(url)
+	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
+	resp, err := client.Do(req)
+	if err != nil {
+		return
+	}
+	code = resp.StatusCode
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	result = body
+	return
+}
+
+func HttpDeleteReplyCode(url string, params interface{}) (result []byte, code int, err error) {
+	data, _ := json.Marshal(params)
+	client := &http.Client{}
+	req, err := http.NewRequest("DELETE", url, strings.NewReader(string(data)))
+	if err != nil {
+		return
+	}
+	fmt.Println(url)
+	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
+	resp, err := client.Do(req)
+	if err != nil {
+		return
+	}
+	code = resp.StatusCode
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	result = body
+	return
+}

utils/verify.go

@@ -20,11 +20,12 @@ var (
 	LogAddVerify           = Rules{"LogUuid": {NotEmpty()}, "Coding": {NotEmpty()}}
 	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()}}
+	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()}}
+	AccountTypeVerify       = Rules{"TypeName": {NotEmpty()}}
+	GameTaskVerify          = Rules{"TaskId": {NotEmpty()}, "TaskName": {NotEmpty()}, "User": {NotEmpty()}, "NewRetained": {NotEmpty()}, "GamePortId": {NotEmpty()}}
+	TaskIdVerify            = Rules{"TaskId": {NotEmpty()}}
 )