migu_music_server/app/admin/apis/strategymanage/strategy.go

package strategymanage

import (
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/go-admin-team/go-admin-core/logger"
	"github.com/go-admin-team/go-admin-core/sdk/pkg/response"
	"go-admin/common/apis"
	"time"

	"go-admin/app/admin/models"
	"net/http"
)

const QueryTimeFormat = "2006-01-02 15:04:05"

type StrategyDeployService struct {
	apis.Api
}

func (e StrategyDeployService) StrategyList(c *gin.Context) {
	fmt.Println("StrategyList")
	err := e.MakeContext(c).MakeOrm().Errors
	if err != nil {
		fmt.Println("MakeContext err:", err)
		e.Logger.Error(err)
		return
	}

	req := &models.StrategyListReq{}
	if c.ShouldBindJSON(req) != nil {
		logger.Errorf("para err")
		response.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	//resp, err := req.List()
	//if err != nil {
	//	logger.Errorf("err:", err)
	//	response.Error(c, http.StatusInternalServerError, err, "查询失败")
	//	return
	//}
	resp := models.StrategyListResp{
		PageNum: req.PageNum,
	}

	pageNum := req.PageNum - 1
	if pageNum < 0 {
		pageNum = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}
	resp.PageSize = req.PageSize
	if e.Orm == nil {
		fmt.Println("Orm is nil")
	}
	var count int64
	qs := e.Orm.Model(&models.Strategy{})
	err = qs.Count(&count).Error
	if err != nil {
		logger.Errorf("count err:", err)
		response.Error(c, http.StatusInternalServerError, err, "查询失败")
		return
	}

	var strategies []models.Strategy
	err = qs.Order("id ").Offset(pageNum * req.PageSize).Limit(req.PageSize).Find(&strategies).Error
	if err != nil {
		logger.Errorf("strategies err:%#v", err)
		response.Error(c, http.StatusInternalServerError, err, "查询失败")
		return
	}

	resp.List = strategies

	e.OK(resp, "")
}

func (e StrategyDeployService) StrategyCreate(c *gin.Context) {
	err := e.MakeContext(c).MakeOrm().Errors
	if err != nil {
		e.Logger.Error(err)
		return
	}
	req := &models.Strategy{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Errorf("para err")
		response.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	exist, err := models.QueryRecordExist(fmt.Sprintf("SELECT * FROM strategy WHERE domain='%s'", req.Domain), e.Orm)
	if err != nil {
		logger.Errorf("err:", err)
		response.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}
	if exist {
		logger.Info("域名已存在")
		response.Error(c, http.StatusInternalServerError, err, "域名已存在")
		return
	}
	//req.OperatingInterval = fmt.Sprintf("%s~%s", req.StartTime.Format(time.DateOnly), req.EndTime.Format(time.DateOnly))

	err = e.Orm.Create(req).Error
	if err != nil {
		logger.Info("Create Strategy err:", err)
		response.Error(c, http.StatusInternalServerError, err, "域名已存在")
		return
	}

	e.OK(req, "")
}

func (e StrategyDeployService) StrategyDetail(c *gin.Context) {
	fmt.Println("StrategyDetail")
	err := e.MakeContext(c).MakeOrm().Errors
	if err != nil {
		fmt.Println("MakeContext err:", err)
		e.Logger.Error(err)
		return
	}

	req := &models.StrategyDetailReq{}
	if c.ShouldBindJSON(req) != nil {
		logger.Errorf("para err")
		response.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	qs := e.Orm.Model(&models.Strategy{}).Where("domain = ?", req.Domain)

	var strategies models.Strategy
	err = qs.Find(&strategies).Error
	if err != nil {
		logger.Errorf("strategies err:%#v", err)
		response.Error(c, http.StatusInternalServerError, err, "查询失败")
		return
	}

	e.OK(strategies, "")
}

func (e StrategyDeployService) StrategyUpdate(c *gin.Context) {
	fmt.Println("StrategyUpdate")
	err := e.MakeContext(c).MakeOrm().Errors
	if err != nil {
		fmt.Println("MakeContext err:", err)
		e.Logger.Error(err)
		return
	}

	req := &models.StrategyUpdate{}
	if c.ShouldBindJSON(req) != nil {
		logger.Errorf("para err")
		response.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	updateData := &models.Strategy{}
	updateData.ID = req.ID
	updateData.CreatedAt = req.CreatedAt
	updateData.UpdatedAt = req.UpdatedAt
	updateData.Name = req.Name
	updateData.Domain = req.Domain
	updateData.OperatingInterval = req.OperatingInterval
	updateData.PageDepth = req.PageDepth
	updateData.AdClickCount = req.AdClickCount
	updateData.SearchBehavior = req.SearchBehavior
	updateData.PageTime = req.PageTime

	parseStartTime, err := time.Parse(QueryTimeFormat, req.StartTime)
	if err != nil {
		logger.Errorf("para err:StartTime")
		response.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	updateData.StartTime = parseStartTime

	parseEndTime, err := time.Parse(QueryTimeFormat, req.EndTime)
	if err != nil {
		logger.Errorf("para err:EndTime")
		response.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	updateData.EndTime = parseEndTime

	if err = e.Orm.Model(&models.Strategy{}).Where("id = ?", updateData.ID).Updates(&updateData).Error; err != nil {
		logger.Errorf("strategies err:%#v", err)
		response.Error(c, http.StatusInternalServerError, err, "更新失败")
		return
	}

	e.OK(req, "")
}