hepa-calc-admin-api/api/controller/Public.go

package controller

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"github.com/gin-gonic/gin"
	"hepa-calc-admin-api/api/dao"
	"hepa-calc-admin-api/api/dto"
	"hepa-calc-admin-api/api/requests"
	"hepa-calc-admin-api/api/responses"
	"hepa-calc-admin-api/config"
	"hepa-calc-admin-api/global"
	"hepa-calc-admin-api/utils"
	"time"
)

type Public struct{}

// Login 登陆
func (b *Public) Login(c *gin.Context) {
	publicRequest := requests.PublicRequest{}
	req := publicRequest.Login
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 验证验证码
	if config.C.Env == "prod" {
		isValid := utils.VerifyCaptcha(req.CaptchaId, req.Captcha)
		if !isValid {
			// 验证码错误
			responses.FailWithMessage("验证码错误", c)
			return
		}
	}

	// 获取用户信息
	AdminUserDao := dao.AdminUserDao{}
	maps := make(map[string]interface{})
	maps["access"] = req.Access
	adminUser, err := AdminUserDao.GetAdminUser(maps)
	if err != nil || adminUser == nil {
		responses.FailWithMessage("用户名或密码错误", c)
		return
	}

	// 检测用户密码
	password := md5.Sum([]byte(req.Password + adminUser.Salt))
	// 将哈希值转换为16进制字符串
	passwordString := hex.EncodeToString(password[:])

	fmt.Println(passwordString)
	if passwordString != adminUser.Password {
		responses.FailWithMessage("用户名或密码错误", c)
		return
	}

	// 检测用户状态
	if adminUser.IsDeleted == 1 {
		responses.FailWithMessage("非法用户", c)
		return
	}

	if adminUser.IsDisabled == 1 {
		responses.FailWithMessage("您的账号已被禁用，请联系管理员处理", c)
		return
	}

	// 下发token
	token := &utils.Token{
		UserId: fmt.Sprintf("%d", adminUser.UserId),
	}

	// 生成jwt
	jwt, err := token.NewJWT()
	if err != nil || jwt == "" {
		responses.FailWithMessage("登陆失败", c)
		return
	}

	g := dto.AdminLoginDto(adminUser)

	g.LoadToken(jwt)

	responses.OkWithData(g, c)
}

// GetCaptcha 获取验证码
func (b *Public) GetCaptcha(c *gin.Context) {
	id, b64s, err := utils.GenerateCaptcha()
	if err != nil {
		responses.FailWithMessage("验证码获取失败", c)
	}

	responses.OkWithData(gin.H{
		"id":   id,
		"b64s": b64s,
	}, c)
}

// GetIndex 首页
func (b *Public) GetIndex(c *gin.Context) {
	userDao := dao.UserDao{}
	questionDao := dao.QuestionDao{}
	orderMemberDao := dao.OrderMemberDao{}
	orderSingleDao := dao.OrderSingleDao{}

	// 获取问题数量
	maps := make(map[string]interface{})
	maps["question_status"] = 1
	questionCount, err := questionDao.GetQuestionCount(maps)
	if err != nil {
		questionCount = 0
	}

	// 获取用户数量
	maps = make(map[string]interface{})
	userCount, err := userDao.GetUserCount(maps)
	if err != nil {
		questionCount = 0
	}

	// 获取有效会员数
	maps = make(map[string]interface{})
	maps["user_status"] = 1
	maps["is_member"] = 1
	validMemberCount, err := userDao.GetUserCount(maps)
	if err != nil {
		validMemberCount = 0
	}

	// 获取问题总提交次数
	maps = make(map[string]interface{})
	questionSubmitCount, err := questionDao.GetQuestionSum(maps, "submit_count")
	if err != nil {
		questionSubmitCount = 0
	}

	// 获取问题总支付次数
	maps = make(map[string]interface{})
	questionPayCount, err := questionDao.GetQuestionSum(maps, "pay_count")
	if err != nil {
		questionPayCount = 0
	}

	// 获取会员购买次数
	maps = make(map[string]interface{})
	maps["order_status"] = 2
	maps["pay_status"] = 2
	maps["refund_status"] = 0
	maps["cancel_status"] = 0
	memberBuyCount, err := orderMemberDao.GetOrderMemberCount(maps)
	if err != nil {
		memberBuyCount = 0
	}

	// 获取会员购买总金额
	maps = make(map[string]interface{})
	maps["order_status"] = 2
	maps["pay_status"] = 2
	maps["refund_status"] = 0
	maps["cancel_status"] = 0
	memberAmountTotal, err := orderMemberDao.GetOrderMemberSum(maps, "payment_amount_total")
	if err != nil {
		memberAmountTotal = 0
	}

	// 获取会员购买总金额
	maps = make(map[string]interface{})
	maps["order_status"] = 2
	maps["pay_status"] = 2
	maps["refund_status"] = 0
	maps["cancel_status"] = 0
	singleAmountTotal, err := orderSingleDao.GetOrderSingleSum(maps, "payment_amount_total")
	if err != nil {
		singleAmountTotal = 0
	}

	g := dto.IndexDto{
		QuestionCount:       questionCount,
		UserCount:           userCount,
		ValidMemberCount:    validMemberCount,
		QuestionSubmitCount: int64(questionSubmitCount),
		QuestionPayCount:    int64(questionPayCount),
		MemberBuyCount:      memberBuyCount,
		MemberAmountTotal:   memberAmountTotal,
		SingleAmountTotal:   singleAmountTotal,
		AmountTotal:         memberAmountTotal + singleAmountTotal,
	}

	responses.OkWithData(g, c)
}

// GetIndexData 首页动态统计数据
func (b *Public) GetIndexData(c *gin.Context) {
	publicRequest := requests.PublicRequest{}
	req := publicRequest.GetIndexData
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 返回值
	var g []*dto.IndexDataDto
	results := make(map[string]int64)

	// 分类（1:新增用户数 2:新增算算数 3:新增单项支付数 4:新增会员购买数）
	if req.Type == 1 {
		// 新增用户数
		endTime, _ := time.Parse("2006-01-02", req.EndTime)
		req.EndTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second).Format("2006-01-02 15:04:05")

		userDao := dao.UserDao{}
		maps := make(map[string]interface{})
		users, err := userDao.GetUserListByTime(maps, req.StartTime, req.EndTime, "created_at")
		if err != nil {
			responses.FailWithMessage(err.Error(), c)
			return
		}

		for _, user := range users {
			date := time.Time(user.CreatedAt).Format("2006-01-02")
			results[date]++
		}

	}

	// 新增算算数
	if req.Type == 2 {
		endTime, _ := time.Parse("2006-01-02", req.EndTime)
		req.EndTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second).Format("2006-01-02 15:04:05")

		questionDao := dao.QuestionDao{}
		maps := make(map[string]interface{})
		maps["question_status"] = 1
		questions, err := questionDao.GetQuestionListByTime(maps, req.StartTime, req.EndTime, "created_at")
		if err != nil {
			responses.FailWithMessage(err.Error(), c)
			return
		}

		for _, question := range questions {
			date := time.Time(question.CreatedAt).Format("2006-01-02")
			results[date]++
		}
	}

	// 新增单项支付数
	if req.Type == 3 {
		endTime, _ := time.Parse("2006-01-02", req.EndTime)
		req.EndTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second).Format("2006-01-02 15:04:05")

		orderSingleDao := dao.OrderSingleDao{}
		maps := make(map[string]interface{})
		maps["order_status"] = 2
		maps["pay_status"] = 2
		maps["refund_status"] = 0
		maps["cancel_status"] = 0
		orderSingles, err := orderSingleDao.GetOrderSingleListByTime(maps, req.StartTime, req.EndTime, "pay_time")
		if err != nil {
			responses.FailWithMessage(err.Error(), c)
			return
		}

		for _, orderSingle := range orderSingles {
			date := orderSingle.PayTime.Format("2006-01-02")
			results[date]++
		}
	}

	// 新增会员购买数
	if req.Type == 4 {
		endTime, _ := time.Parse("2006-01-02", req.EndTime)
		req.EndTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second).Format("2006-01-02 15:04:05")

		orderMemberDao := dao.OrderMemberDao{}
		maps := make(map[string]interface{})
		maps["order_status"] = 2
		maps["pay_status"] = 2
		maps["refund_status"] = 0
		maps["cancel_status"] = 0
		orderMembers, err := orderMemberDao.GetOrderMemberListByTime(maps, req.StartTime, req.EndTime, "pay_time")
		if err != nil {
			responses.FailWithMessage(err.Error(), c)
			return
		}

		for _, orderMember := range orderMembers {
			date := orderMember.PayTime.Format("2006-01-02")
			results[date]++
		}
	}

	for k, v := range results {
		response := &dto.IndexDataDto{
			Date:  k,
			Count: v,
		}

		g = append(g, response)
	}

	responses.OkWithData(g, c)
}