xugu_license/internal/controllers/OALicenseInfo_controllers.go

package controllers

import (
	"database/sql"
	"fmt"
	"net/http"
	"sort"
	"strconv"
	"strings"
	"xugu_license/internal/api"
	"xugu_license/internal/global"
	middlewares "xugu_license/internal/middleware"
	"xugu_license/internal/models"
	"xugu_license/internal/module/capture"
	"xugu_license/internal/module/email"
	"xugu_license/internal/utils"

	"github.com/gin-gonic/gin"
	"github.com/pkg/errors"
)

func getLoginInfo(c *gin.Context) (*middlewares.UserAuthInfo, error) {
	//获取当前登录用户信息
	userAny, exists := c.Get("userInfo")
	if !exists {
		global.Logger.Errorln("GetLicenseInfo: 用户信息不存在")
		return nil, errors.New("GetLicenseInfo: 用户信息不存在")
		// c.JSON(http.StatusUnauthorized, gin.H{"error": "用户信息不存在"})
		// c.Abort()

	}

	userInfo := userAny.(*middlewares.UserAuthInfo)
	return userInfo, nil
}

func GetSingleLicenseInfoController(c *gin.Context) {

	// userInfo, err := getLoginInfo(c)
	// if err != nil {
	// 	c.JSON(http.StatusUnauthorized, gin.H{"error": "用户信息不存在"})
	// 	c.Abort()
	// }

	//获取请求参数
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "10"))
	LicUniqueID := c.DefaultQuery("LicUniqueID", "10")

	//获取指定的license信息
	applications, total, err := models.GetOALicenseInfo(page, pageSize, "", LicUniqueID, "", "")
	if err != nil {
		global.Logger.Errorln("指定UniqueID查询错误：", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("指定UniqueID查询错误: ", err.Error())})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"data":     *applications,
		"page":     1,
		"pageSize": 1,
		"total":    total,
	})

}

// func GetAllLicenseInfoControllerToDb(c *gin.Context) {

// 	// userInfo, err := getLoginInfo(c)
// 	// if err != nil {
// 	// 	c.JSON(http.StatusUnauthorized, gin.H{"error": "用户信息不存在"})
// 	// 	c.Abort()
// 	// }

// 	//获取请求参数
// 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
// 	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "10"))
// 	//获取指定的license信息
// 	applications, total, err := models.GetOALicenseInfo(page, pageSize, "read_all_license", "", "", "")
// 	if err != nil {
// 		global.Logger.Errorln("read_all_license查询错误：", err.Error())
// 		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("read_all_license查询错误: ", err.Error())})
// 		return
// 	}

// 	var datas []api.AllLicenseInfoResponse
// 	for _, v := range *applications {

// 		data := api.AllLicenseInfoResponse{

// 			UniqueID:               utils.ToString(v.LicInfo.UniqueID),
// 			OARequestID:            utils.ToInt64(v.LicInfo.OARequestID),
// 			OARequestName:          utils.ToString(v.LicInfo.OARequestName),
// 			OARequestNameNew:       utils.ToString(v.LicInfo.OARequestNameNew),
// 			OARequestNameHTMLNew:   utils.ToString(v.LicInfo.OARequestNameHTMLNew),
// 			OAGLXMId:               utils.ToInt64(v.LicInfo.OAGLXMID),
// 			OAGLXMName:             utils.ToString(v.LicInfo.OAGLXMName),
// 			OASQSJ:                 utils.ToTimeString(v.LicInfo.OASQSJ),
// 			OASalespersonName:      utils.ToString(v.LicInfo.OASalespersonName),
// 			OAXSJSYX:               utils.ToString(v.LicInfo.OAXSJSYX),
// 			OAOperationsPersonName: utils.ToString(v.LicInfo.OAOperationsPersonName),
// 			OAJFJSYX:               utils.ToString(v.LicInfo.OAJFJSYX),
// 			OASYDW:                 utils.ToString(v.LicInfo.OASYDW),
// 			OAXMXXMS:               utils.ToString(v.LicInfo.OAXMXXMS),
// 			OAJDS:                  utils.ToInt64(v.LicInfo.OAJDS),
// 			OANodeCount:            utils.ToInt64(v.LicInfo.OANodeCount),
// 			OAProductCode:          utils.ToString(v.LicInfo.OAProductCode),
// 			OAProductName:          utils.ToString(v.LicInfo.OAProductName),
// 			OAProductVersion:       utils.ToString(v.LicInfo.OAProductVersion),
// 			OACPU:                  utils.ToString(v.LicInfo.OACPU),
// 			OAOperatingSystem:      utils.ToString(v.LicInfo.OAOperatingSystem),
// 			OAMainMAC:              utils.ToString(v.LicInfo.OAMainMAC),
// 			OASecondMAC:            utils.ToString(v.LicInfo.OASecondMAC),
// 			OACreationDate:         utils.ToString(v.LicInfo.OACreationDate),
// 			OACreationTime:         utils.ToString(v.LicInfo.OACreationTime),
// 			OALastOperateDate:      utils.ToString(v.LicInfo.OALastOperateDate),
// 			OALastOperateTime:      utils.ToString(v.LicInfo.OALastOperateTime),
// 			CaptureTime:            utils.ToTimeString(v.LicInfo.CaptureTime),
// 			DelTime:                utils.ToTimeString(v.LicInfo.DelTime),
// 			LastOperateTime:        utils.ToTimeString(v.LicInfo.LastOperateTime),

// 			LicenseUniqueID: utils.ToString(v.GenrateInfo.LicenseUniqueID),
// 			LicenseFlage:    utils.ToString(v.GenrateInfo.LicenseFlage),
// 			Lic1:            utils.ToString(v.GenrateInfo.Lic1),
// 			Lic2:            utils.ToString(v.GenrateInfo.Lic2),
// 			CreatorGenerate: utils.ToTimeString(v.GenrateInfo.CreatorGenerate),
// 		}
// 		datas = append(datas, data)
// 	}

// 	c.JSON(http.StatusOK, gin.H{
// 		"data":     datas,
// 		"page":     page,
// 		"pageSize": pageSize,
// 		"total":    total,
// 	})
// }

func GetAllLicenseInfoController(c *gin.Context) {
	//获取请求参数
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "10"))
	//获取用户信息和权限
	userInfo, err := getLoginInfo(c)
	if err != nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "用户信息不存在"})
		c.Abort()
	}
	// if t := userInfo.Permission[middlewares.ReadAllLicense]; t == middlewares.ReadAllLicense {

	// }
	var datas [][]api.AllLicenseInfoResponse
	var Total int
	// 初始化存储 `OARequestID` 相同的 `ApiLicenseInfoTemp` 列表的 map
	oaRequestIDMap := make(map[int64][]api.AllLicenseInfoResponse)
	if userInfo.Permission[middlewares.ReadAllLicense] == middlewares.ReadAllLicense {
		datas1, total, err := models.GetOALicenseInfo(pageSize, page, "read_all_license", "", "", "")
		if err != nil {
			global.Logger.Errorln("error", err.Error())
			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
			return
		}
		Total = total

		//var ApiLicenseInfoTemp []api.AllLicenseInfoResponse
		for _, data := range *datas1 {

			ApiLicenseInfo := api.AllLicenseInfoResponse{
				UniqueID:               utils.ToString(data.LicInfo.UniqueID),
				OARequestID:            utils.ToInt64(data.LicInfo.OARequestID),
				OARequestName:          utils.ToString(data.LicInfo.OARequestName),
				OARequestNameNew:       utils.ToString(data.LicInfo.OARequestNameNew),
				OARequestNameHTMLNew:   utils.ToString(data.LicInfo.OARequestNameHTMLNew),
				OAGLXMId:               utils.ToInt64(data.LicInfo.OAGLXMID),
				OAGLXMName:             utils.ToString(data.LicInfo.OAGLXMName),
				OASQSJ:                 utils.ToString(data.LicInfo.OASQSJ),
				OASalespersonName:      utils.ToString(data.LicInfo.OASalespersonName),
				OAXSJSYX:               utils.ToString(data.LicInfo.OAXSJSYX),
				OAOperationsPersonName: utils.ToString(data.LicInfo.OAOperationsPersonName),
				OAJFJSYX:               utils.ToString(data.LicInfo.OAJFJSYX),
				OASYDW:                 utils.ToString(data.LicInfo.OASYDW),
				OAXMXXMS:               utils.ToString(data.LicInfo.OAXMXXMS),
				OAJDS:                  utils.ToInt64(data.LicInfo.OAJDS),
				OANodeCount:            utils.ToInt64(data.LicInfo.OANodeCount),
				OAProductCode:          utils.ToString(data.LicInfo.OAProductCode),
				OAProductName:          utils.ToString(data.LicInfo.OAProductName),
				OAProductVersion:       utils.ToString(data.LicInfo.OAProductVersion),
				OACPU:                  utils.ToString(data.LicInfo.OACPU),
				OAOperatingSystem:      utils.ToString(data.LicInfo.OAOperatingSystem),
				OAMainMAC:              utils.ToString(data.LicInfo.OAMainMAC),
				OASecondMAC:            utils.ToString(data.LicInfo.OASecondMAC),
				OACreationDate:         utils.ToString(data.LicInfo.OACreationDate),
				OACreationTime:         utils.ToString(data.LicInfo.OACreationTime),
				OALastOperateDate:      utils.ToString(data.LicInfo.OALastOperateDate),
				OALastOperateTime:      utils.ToString(data.LicInfo.OALastOperateTime),
				CaptureTime:            utils.ToTimeString(data.LicInfo.CaptureTime),
				DelTime:                utils.ToTimeString(data.LicInfo.DelTime),
				LastOperateTime:        utils.ToTimeString(data.LicInfo.LastOperateTime),
				LicenseFlage:           utils.ToString(data.GenrateInfo.LicenseFlage),
				Lic1:                   utils.ToString(data.GenrateInfo.Lic1),
				Lic2:                   utils.ToString(data.GenrateInfo.Lic2),
				CreatorGenerate:        utils.ToTimeString(data.GenrateInfo.CreatorGenerate),
			}
			// 将 `ApiLicenseInfo` 添加到 `OARequestID` 对应的数组中
			oaRequestID := utils.ToInt64(data.LicInfo.OARequestID)
			oaRequestIDMap[oaRequestID] = append(oaRequestIDMap[oaRequestID], ApiLicenseInfo)

		}

	} else if userInfo.Permission[middlewares.ReadLicense] == middlewares.ReadLicense {
		datas1, total, err := models.GetOALicenseInfo(pageSize, page, "", "", userInfo.UniqueID, "")
		if err != nil {
			global.Logger.Errorln("error", err.Error())
			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
			return
		}
		Total = total

		//var ApiLicenseInfoTemp []api.AllLicenseInfoResponse
		for _, data := range *datas1 {

			ApiLicenseInfo := api.AllLicenseInfoResponse{
				UniqueID:               utils.ToString(data.LicInfo.UniqueID),
				OARequestID:            utils.ToInt64(data.LicInfo.OARequestID),
				OARequestName:          utils.ToString(data.LicInfo.OARequestName),
				OARequestNameNew:       utils.ToString(data.LicInfo.OARequestNameNew),
				OARequestNameHTMLNew:   utils.ToString(data.LicInfo.OARequestNameHTMLNew),
				OAGLXMId:               utils.ToInt64(data.LicInfo.OAGLXMID),
				OAGLXMName:             utils.ToString(data.LicInfo.OAGLXMName),
				OASQSJ:                 utils.ToString(data.LicInfo.OASQSJ),
				OASalespersonName:      utils.ToString(data.LicInfo.OASalespersonName),
				OAXSJSYX:               utils.ToString(data.LicInfo.OAXSJSYX),
				OAOperationsPersonName: utils.ToString(data.LicInfo.OAOperationsPersonName),
				OAJFJSYX:               utils.ToString(data.LicInfo.OAJFJSYX),
				OASYDW:                 utils.ToString(data.LicInfo.OASYDW),
				OAXMXXMS:               utils.ToString(data.LicInfo.OAXMXXMS),
				OAJDS:                  utils.ToInt64(data.LicInfo.OAJDS),
				OANodeCount:            utils.ToInt64(data.LicInfo.OANodeCount),
				OAProductCode:          utils.ToString(data.LicInfo.OAProductCode),
				OAProductName:          utils.ToString(data.LicInfo.OAProductName),
				OAProductVersion:       utils.ToString(data.LicInfo.OAProductVersion),
				OACPU:                  utils.ToString(data.LicInfo.OACPU),
				OAOperatingSystem:      utils.ToString(data.LicInfo.OAOperatingSystem),
				OAMainMAC:              utils.ToString(data.LicInfo.OAMainMAC),
				OASecondMAC:            utils.ToString(data.LicInfo.OASecondMAC),
				OACreationDate:         utils.ToString(data.LicInfo.OACreationDate),
				OACreationTime:         utils.ToString(data.LicInfo.OACreationTime),
				OALastOperateDate:      utils.ToString(data.LicInfo.OALastOperateDate),
				OALastOperateTime:      utils.ToString(data.LicInfo.OALastOperateTime),
				CaptureTime:            utils.ToTimeString(data.LicInfo.CaptureTime),
				DelTime:                utils.ToTimeString(data.LicInfo.DelTime),
				LastOperateTime:        utils.ToTimeString(data.LicInfo.LastOperateTime),
				LicenseFlage:           utils.ToString(data.GenrateInfo.LicenseFlage),
				Lic1:                   utils.ToString(data.GenrateInfo.Lic1),
				Lic2:                   utils.ToString(data.GenrateInfo.Lic2),
				CreatorGenerate:        utils.ToTimeString(data.GenrateInfo.CreatorGenerate),
			}
			// 将 `ApiLicenseInfo` 添加到 `OARequestID` 对应的数组中
			oaRequestID := utils.ToInt64(data.LicInfo.OARequestID)
			oaRequestIDMap[oaRequestID] = append(oaRequestIDMap[oaRequestID], ApiLicenseInfo)
		}
	}

	//获取指定的license缓存信息
	//data, err := global.LicCache.GetPaginatedData(page, pageSize)

	//返回[][]data 的方式
	// var datas [][]api.AllLicenseInfoResponse
	// for _, lic := range data {
	// 	var dataTemp []api.AllLicenseInfoResponse
	// 	for _, v := range lic {
	// 		data := api.AllLicenseInfoResponse{
	// 			UniqueID:               v.UniqueID.String,
	// 			OARequestID:            v.OARequestID.Int64,
	// 			OARequestName:          utils.ToString(v.OARequestName),
	// 			OARequestNameNew:       utils.ToString(v.OARequestNameNew),
	// 			OARequestNameHTMLNew:   utils.ToString(v.OARequestNameHTMLNew),
	// 			OAGLXMId:               utils.ToInt64(v.OAGLXMId),
	// 			OAGLXMName:             utils.ToString(v.OAGLXMName),
	// 			OASQSJ:                 utils.ToTimeString(v.OASQSJ),
	// 			OASalespersonName:      utils.ToString(v.OASalespersonName),
	// 			OAXSJSYX:               utils.ToString(v.OAXSJSYX),
	// 			OAOperationsPersonName: utils.ToString(v.OAOperationsPersonName),
	// 			OAJFJSYX:               utils.ToString(v.OAJFJSYX),
	// 			OASYDW:                 utils.ToString(v.OASYDW),
	// 			OAXMXXMS:               utils.ToString(v.OAXMXXMS),
	// 			OAJDS:                  utils.ToInt64(v.OAJDS),
	// 			OANodeCount:            utils.ToInt64(v.OANodeCount),
	// 			OAProductCode:          utils.ToString(v.OAProductCode),
	// 			OAProductName:          utils.ToString(v.OAProductName),
	// 			OAProductVersion:       utils.ToString(v.OAProductVersion),
	// 			OACPU:                  utils.ToString(v.OACPU),
	// 			OAOperatingSystem:      utils.ToString(v.OAOperatingSystem),
	// 			OAMainMAC:              utils.ToString(v.OAMainMAC),
	// 			OASecondMAC:            utils.ToString(v.OASecondMAC),
	// 			OACreationDate:         utils.ToString(v.OACreationDate),
	// 			OACreationTime:         utils.ToString(v.OACreationTime),
	// 			OALastOperateDate:      utils.ToString(v.OALastOperateDate),
	// 			OALastOperateTime:      utils.ToString(v.OALastOperateTime),
	// 			CaptureTime:            utils.ToTimeString(v.CaptureTime),
	// 			DelTime:                utils.ToTimeString(v.DelTime),
	// 			LastOperateTime:        utils.ToTimeString(v.LastOperateTime),
	// 			LicenseUniqueID:        utils.ToString(v.LicenseUniqueID),
	// 			LicenseFlage:           utils.ToString(v.LicenseFlage),
	// 			Lic1:                   utils.ToString(v.Lic1),
	// 			Lic2:                   utils.ToString(v.Lic2),
	// 			CreatorGenerate:        utils.ToString(v.CreatorGenerate),
	// 		}
	// 		dataTemp = append(dataTemp, data)
	// 	}
	// 	datas = append(datas, dataTemp)
	// }

	// 将 `oaRequestIDMap` 中的所有 `ApiLicenseInfoTemp` 列表添加到 `datas` 中
	for _, apiLicenseInfoTemp := range oaRequestIDMap {
		datas = append(datas, apiLicenseInfoTemp)
	}
	// 对 datas 的第一维进行排序
	sort.Slice(datas, func(i, j int) bool {
		// 假设你需要根据每个数组第一个元素的 OACreationDate 和 OACreationTime 来排序
		if datas[i][0].OACreationDate == datas[j][0].OACreationDate {
			return datas[i][0].OACreationTime > datas[j][0].OACreationTime
		}
		return datas[i][0].OACreationDate > datas[j][0].OACreationDate
	})
	c.JSON(http.StatusOK, gin.H{
		"data":     datas,
		"page":     page,
		"pageSize": pageSize,
		"total":    Total,
	})

}

func GenerateOALicenseStrController(c *gin.Context) {
	var request api.GenerateLicenseStrRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		global.Logger.Errorln("解析request失败 ：  ", err.Error())
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("解析请求失败: ", err.Error()),
		})
		return
	}
	//生成单独的license
	if request.UniqueID != "" {

		if err := generateLicenseStrSub(request.UniqueID); err != nil {
			global.Logger.Errorf("请联系管理员, LicenseInfo%v生成失败:  %v\n", request.UniqueID, err.Error())
			c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("请联系管理员, LicenseInfo%v生成失败： %v", request.UniqueID, err.Error())})
			return
		}
	} else if request.OARequestId != "" {
		//一个OARequestId会有多条数据UniqueID
		OALics, _, err := models.GetOALicenseInfo(0, 0, "", "", "", request.OARequestId)
		if err != nil || OALics == nil {
			global.Logger.Errorln("LicenseInfo数据查询失败：  ", err.Error())
			c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
			return
		}
		//生成license，已生成的不管
		for _, v := range *OALics {
			if v.GenrateInfo.LicenseFlage.String == "未生成" {
				err := generateLicenseStrSub(utils.ToString(v.LicInfo.UniqueID))
				if err != nil {
					global.Logger.Errorf("请联系管理员, LicenseInfo%v生成失败:  %v\n", v.LicInfo.UniqueID, err.Error())
					c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("请联系管理员, LicenseInfo%v生成失败： %v", v.LicInfo.UniqueID, err.Error())})
					return
				}
			}
		}

	} else {
		global.Logger.Errorln("未指定明确License行 ")
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("未指定明确License行 ")})
		return
	}

	//刷新缓存
	// layout := "2006-01-02 15:04:05"
	// startTime, _ := time.Parse(layout, "2023-07-30 14:00:00")
	// endTime, _ := time.Parse(layout, "2023-08-26 16:00:00")
	// if err := global.LicCache.RefreshCache(global.XuguDB, startTime, endTime, 0, 20); err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据刷新缓存失败：  ", err.Error())
	// 	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据刷新缓存失败: ", err.Error())})
	// 	return
	// }
	// fmt.Printf("LicenseInfo数据刷新缓存成功 %#v\n", global.LicCache.GetData())

	// applications, _, err := models.GetOALicenseInfo(0, 1, "", request.UniqueID, "")
	// if err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据查询失败：  ", err.Error())
	// 	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
	// 	return
	// }
	// pj := license.ProjectInfo{
	// 	ProjectName:  utils.ToString((*applications)[0].LicInfo.OAProductName),
	// 	UserName:     utils.ToString((*applications)[0].LicInfo.OAProductVersion),
	// 	UserAddr:     "未填写",
	// 	SerialNumber: "未填写",
	// }
	// ei := license.EnvironmentInfo{
	// 	CpuSN:       "未填写",
	// 	BaseboardSN: "未填写",
	// 	MacAddr:     utils.ToString((*applications)[0].LicInfo.OAMainMAC),
	// 	DiskID:      "未填写",
	// 	IPAddr:      "未填写",
	// }
	// LicType := utils.SwitchLicenseType(utils.ToString((*applications)[0].LicInfo.OAProductName))
	// lI := license.LicenseInfo{
	// 	GenDate:        "2024-07-15",
	// 	ExpireDate:     "9999-12-31",
	// 	LicenseType:    LicType,
	// 	LicenseVersion: 1,
	// 	HardType:       3,
	// }

	//这里调用的是license模块中的生成license的方法
	// res := true
	// if res {
	// 	//生成副主节点license
	// 	if (*applications)[0].LicInfo.OASecondMAC.String != "" {
	// 		// var licStr2 []byte
	// 		// ei.MacAddr = applications[0].SecondaryMasterMacAddress
	// 		// licStr2 = license.GenerateLicense(pj, ei, lI)
	// 		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"))
	// 	} else {
	// 		//fmt.Println("licStr licStr2", licStr, licStr2)
	// 		//插入到数据库
	// 		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"), nil)
	// 	}
	// } else {
	// 	licStr := license.GenerateLicense(pj, ei, lI)

	// 	//生成副主节点license
	// 	if (*applications)[0].LicInfo.OASecondMAC.String != "" {
	// 		var licStr2 []byte
	// 		ei.MacAddr = (*applications)[0].LicInfo.OASecondMAC.String
	// 		licStr2 = license.GenerateLicense(pj, ei, lI)
	// 		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), licStr, licStr2)
	// 	} else {
	// 		//插入到数据库
	// 		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), licStr, nil)
	// 	}

	// }
	// if err != nil {
	// 	fmt.Println(err)
	// 	if err := c.ShouldBindJSON(&request); err != nil {
	// 		c.JSON(400, gin.H{
	// 			"error": err.Error(),
	// 		})
	// 		return
	// 	}
	// }
	// if err != nil {
	// 	fmt.Println(err)
	// 	if err := c.ShouldBindJSON(&request); err != nil {
	// 		global.Logger.Errorln("LicenseInfo数据查询失败： ", err.Error())
	// 		c.JSON(400, gin.H{
	// 			"error": fmt.Sprintf("数据查询失败: ", err.Error()),
	// 		})
	// 		return
	// 	}
	// }

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "License生成成功！",
	})
	//xlsx.ExcelToMail(lic, licStr, licStr2)
}

func generateLicenseStrSub(UniqueID string) error {
	var applications *[]models.OALicenseInfo
	var err error
	if UniqueID != "" {

		applications, _, err = models.GetOALicenseInfo(0, 1, "", UniqueID, "", "")
		if err != nil {
			global.Logger.Errorln("LicenseInfo数据查询失败：  ", err.Error())
			//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
			return errors.Errorf("LicenseInfo数据查询失败：: %v", err.Error())
		}
	}
	// (*applications)[0].LicInfo.UniqueID.String = ""
	// (*applications)[0].LicInfo.UniqueID.Valid = false
	// (*applications)[0].GenrateInfo.LicenseUniqueID.String = ""
	// (*applications)[0].GenrateInfo.LicenseUniqueID.Valid = false
	fmt.Printf("applications%#v\n", applications)
	//检测该数据是否与oa库数据库一致
	isCheck, err := models.CheckLicenseInfoInOADB(&(*applications)[0].LicInfo)
	if err != nil {
		global.Logger.Errorln("LicenseInfo数据对比oa库 查询失败：  ", err.Error())
		//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
		return errors.Errorf("LicenseInfo数据对比oa库 查询失败 %v", err.Error())
	}
	if !isCheck {
		global.Logger.Errorln("LicenseInfo数据对比oa库 不一致")
		return errors.Errorf("LicenseInfo数据对比oa库 数据不一致 \n")
	}

	//checkTemp := CompareOALicenseInfo(&(*applications)[0], OALicenseInfo)
	//如果不一致，则修改源数据
	// if checkTemp != true {
	// 	global.Logger.Errorln("LicenseInfo数据对比oa库 不一致")
	// 	//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
	// 	OALicenseInfo.LicInfo.UniqueID = (*applications)[0].LicInfo.UniqueID
	// 	if err := models.UpdatelicenseInfoRow(*OALicenseInfo); err != nil {
	// 		global.Logger.Errorln("LicenseInfo数据对比oa库 不一致,更新数据库失败：  ", err.Error())
	// 		return errors.Errorf("LicenseInfo数据对比oa库 不一致,更新数据库失败：%v", err.Error())
	// 	}

	// //刷新缓存
	// layout := "2006-01-02 15:04:05"
	// startTime, _ := time.Parse(layout, "2023-07-30 14:00:00")
	// endTime, _ := time.Parse(layout, "2023-08-26 16:00:00")
	// if err := global.LicCache.RefreshCache(global.XuguDB, startTime, endTime, 0, 20); err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据刷新缓存失败：  ", err.Error())

	// 	return errors.Errorf("LicenseInfo数据刷新缓存失败：")
	// }

	// return errors.Errorf("LicenseInfo数据对比oa库 不一致,清刷新页面")
	//}
	// pj := license.ProjectInfo{
	// 	ProjectName:  utils.ToString((*applications)[0].LicInfo.OAProductName),
	// 	UserName:     utils.ToString((*applications)[0].LicInfo.OAProductVersion),
	// 	UserAddr:     "未填写",
	// 	SerialNumber: "未填写",
	// }
	// ei := license.EnvironmentInfo{
	// 	CpuSN:       "未填写",
	// 	BaseboardSN: "未填写",
	// 	MacAddr:     utils.ToString((*applications)[0].LicInfo.OAMainMAC),
	// 	DiskID:      "未填写",
	// 	IPAddr:      "未填写",
	// }
	// LicType := utils.SwitchLicenseType(utils.ToString((*applications)[0].LicInfo.OAProductName))
	// lI := license.LicenseInfo{
	// 	GenDate:        "2024-07-15",
	// 	ExpireDate:     "9999-12-31",
	// 	LicenseType:    LicType,
	// 	LicenseVersion: 1,
	// 	HardType:       3,
	// }

	//生成副主节点license
	if applications == nil {
		global.Logger.Errorln("LicenseInfo数据生成失败 ，数据查询为空  ")
		//c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("LicenseInfo数据生成失败 ，数据查询为空: ", err.Error())})
		return errors.Errorf("LicenseInfo数据生成失败 ，数据查询为空 ")
	}

	if (*applications)[0].LicInfo.OASecondMAC.String != "" {
		// var licStr2 []byte
		// ei.MacAddr = applications[0].SecondaryMasterMacAddress
		// licStr2 = license.GenerateLicense(pj, ei, lI)
		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"))
		if err != nil {
			global.Logger.Errorln("LicenseInfo生成插入失败：  ", err.Error())
			//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
			return errors.Errorf("LicenseInfo生成插入失败：: ", err.Error())
		}
	} else {
		//fmt.Println("licStr licStr2", licStr, licStr2)
		//插入到数据库
		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"), nil)
		if err != nil {
			global.Logger.Errorln("LicenseInfo2生成插入失败：  ", err.Error())
			//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
			return errors.Errorf("LicenseInfo2生成插入失败：: ", err.Error())
		}
	}
	return nil
}

// func CheckDistributeOALicenseToOaDbController(c *gin.Context) {
// 	var CheckDisLicense struct {
// 		LicUniqueID string `json:"lic_unique_id"`
// 	}

// 	var request CheckDisLicense
// 	if err := c.ShouldBindJSON(&request); err != nil {
// 		global.Logger.Errorln("license分发请求解析失败  %s", err.Error())
// 		c.JSON(400, gin.H{
// 			"error": fmt.Sprintf("license分发请求解析失败  %s", err.Error()),
// 		})
// 		return
// 	}
// 	//检测该数据是否与oa库数据库一致
// 	OALicenseInfo, err := models.CheckLicenseInfoInOADB((*applications)[0].LicInfo.ID)
// 	if err != nil {
// 		global.Logger.Errorln("LicenseInfo数据对比oa库 查询失败：  ", err.Error())
// 		//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
// 		return errors.Errorf("LicenseInfo数据对比oa库 查询失败 %v", err.Error())
// 	}

// 	checkTemp := CompareOALicenseInfo(&(*applications)[0], OALicenseInfo)
// 	//如果不一致，则修改源数据
// }

/*
对单条lic或是申请单的处理
检测lic是否以及分发过给用户
*/
func DistributeOALicenseController(c *gin.Context) {

	//判断是否发邮件
	//数据库查询license信息
	var request api.DistributeLicenseRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		global.Logger.Errorln("license分发请求解析失败  %s", err.Error())
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("license分发请求解析失败  %s", err.Error()),
		})
		return
	}

	var licToUser []string
	if request.OaRequestId != "" {
		//获取该license申请单的所有子信息
		datas, _, err := models.GetOALicenseInfo(0, 0, "", "", "", request.OaRequestId)
		if err != nil {
			global.Logger.Errorln("license分发请求查询license申请单的所有子信息失败  %s", err.Error())
			c.JSON(400, gin.H{
				"error": fmt.Sprintf("license分发请求解析失败  %s", err.Error()),
			})
			return
		}

		for _, oaLicInfo := range *datas {
			users, err := checkDistributeToUser(&oaLicInfo, request.UserUniqueIDs, request.UserNames)
			if err != nil {
				global.Logger.Errorln("license分发请求检测是否已发放给用户失败  %s", err.Error())
				c.JSON(400, gin.H{
					"error": fmt.Sprintf("license分发请求解析失败  %s", err.Error()),
				})
				return
			}

			if len(users) != 0 {
				c.JSON(400, gin.H{
					"success": false,
					"error":   fmt.Sprintf("该license已经分发给了该用户: %s\n", licToUser),
				})
				return
			}

		}

	} else if request.LicenseUniqueID != "" {
		//查询该license是否已经分发给了该用户
		for i, v := range request.UserUniqueIDs {
			fmt.Println("request.UserUniqueIDs", request.LicenseUniqueID, v)
			if isTurn, err := models.CheckLicenseToUser(request.LicenseUniqueID, v); err != nil {
				global.Logger.Errorln("该license查询是否分发给用户失败 ", v, err.Error())
				c.JSON(400, gin.H{
					"success": false,
					"error":   fmt.Sprintf("该license查询是否分发给用户失败: %s", v, err.Error()),
				})
				return
			} else if isTurn {
				global.Logger.Info("该license已经分发给了该用户 ", v)
				licToUser = append(licToUser, request.UserNames[i])
			}

		}

	}

	applications, _, err := models.GetOALicenseInfo(1, 1, "", request.LicenseUniqueID, "", "")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"success": false,
			"error": err.Error()})
		return
	}

	//如果lic1为空则报错
	if (*applications)[0].GenrateInfo.Lic1.String == "" {
		global.Logger.Errorln("license未生成 ")
		c.JSON(http.StatusBadRequest, gin.H{"success": false,
			"error": "license未生成"})
		return
	}

	//邮箱不空则发送
	var EmailArray []string
	if request.Emails != "" {
		fmt.Println("request.Emails", request.Emails)
		EmailArray = strings.Split(request.Emails, ",")
		fmt.Println("EmailArray", EmailArray)

		em, err := email.BuildEmail(&(*applications)[0], EmailArray, (*applications)[0].GenrateInfo.Lic1.String, (*applications)[0].GenrateInfo.Lic2.String)
		if err != nil {
			global.Logger.Errorln("邮件生成失败", err.Error())

			c.JSON(400, gin.H{
				"success": false,
				"error":   fmt.Sprintf("邮件生成失败: ", err.Error()),
			})
			return
		}

		err = email.SendEmail(em)
		if err != nil {
			global.Logger.Errorln("邮件发送失败", err.Error())
			c.JSON(400, gin.H{
				"success": false,
				"error":   fmt.Sprintf("邮件发送失败: ", err.Error()),
			})
			return
		}
	}

	for i, v := range request.UserUniqueIDs {
		err = models.InsertlicenseRecordByUserRow((*applications)[0].LicInfo.UniqueID.String, v, request.UserAccounts[i], request.OperatorUniqueID)
		if err != nil {
			global.Logger.Errorln("数据库插入失败： ", err.Error())
			c.JSON(400, gin.H{
				"success": false,
				"error":   fmt.Sprintf("插入失败: ", err.Error()),
			})
			return
		}
	}

	if len(EmailArray) != 0 {

		for _, v := range EmailArray {
			err = models.InsertlicenseRecordByEmailRow((*applications)[0].LicInfo.UniqueID.String, v, request.OperatorUniqueID)
			if err != nil {
				global.Logger.Errorln("数据库插入失败： ", err.Error())
				c.JSON(400, gin.H{
					"error": fmt.Sprintf("插入失败: ", err.Error()),
				})
				return
			}
		}
	}

	//刷新缓存
	// layout := "2006-01-02 15:04:05"
	// startTime, _ := time.Parse(layout, "2023-07-30 14:00:00")
	// endTime, _ := time.Parse(layout, "2023-08-26 16:00:00")
	// if err := global.LicCache.RefreshCache(global.XuguDB, startTime, endTime, 0, 20); err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据刷新缓存失败：  ", err.Error())
	// 	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据刷新缓存失败: ", err.Error())})
	// 	return
	// }

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    "分发成功！",
	})
}

// 获取分发历史
func GetlicenseRecordInfo(c *gin.Context) {
	// type licenseRecordInfoRequest struct {
	// 	UniqueID string `json:"uniqueID"`
	// 	Id       int    `json:"id"`
	// }

	var request api.GetDistributeHistoryRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		global.Logger.Errorln("解析请求失败 ", err.Error())

		c.JSON(400, gin.H{
			"error": fmt.Sprintf("解析请求失败: ", err.Error()),
		})
		return
	}

	LicUers, err := models.GetlicenseRecordByUser(request.UniqueID)
	if err != nil {
		global.Logger.Errorln("数据查询失败 ", err.Error())

		c.JSON(400, gin.H{
			"error": fmt.Sprintf("数据查询失败: ", err.Error()),
		})
		return
	}
	LicEmails, err := models.GetlicenseRecordByEmail(request.UniqueID)
	if err != nil {
		global.Logger.Errorln("数据查询失败 ", err.Error())

		c.JSON(400, gin.H{
			"error": fmt.Sprintf("数据查询失败: ", err.Error()),
		})
		return
	}
	licR := models.LicenseRecord{
		LicenseRecordToUser:   LicUers,
		LicenseRecordToEmails: LicEmails,
	}
	fmt.Println("分发历史applications", licR)
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    licR,
	})
}

// 更新license信息
func UpdateLicense(c *gin.Context) {

	var license api.UpdateLicenseInfoRequest
	// 绑定JSON数据到License结构体
	if err := c.ShouldBindJSON(&license); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   err.Error(),
		})
		return
	}
	//	fmt.Printf(" license.ApplicationDate: %#v ", license)
	err := models.UpdatelicenseInfoRow(models.OALicenseInfo{
		LicInfo: models.TargetOALicenseInfo{
			UniqueID: sql.NullString{
				String: license.UniqueID,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OARequestName: sql.NullString{
				String: license.Creator,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OACreationDate: sql.NullString{
				String: license.ApplicationDate,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OAGLXMName: sql.NullString{
				String: license.AssociatedProject,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OANodeCount: sql.NullInt64{
				Int64: license.NodeCount,
				Valid: true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OASalespersonName: sql.NullString{
				String: license.SalesPerson,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OAOperationsPersonName: sql.NullString{
				String: license.SupportPerson,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OAXSJSYX: sql.NullString{
				String: license.SalesEmail,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OAJFJSYX: sql.NullString{
				String: license.SupportEmail,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OAJDS: sql.NullInt64{
				Int64: license.TotalNodes,
				Valid: true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OAProductName: sql.NullString{
				String: license.ProductName,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OAProductVersion: sql.NullString{
				String: license.Version,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
			OASYDW: sql.NullString{
				String: license.Company,
				Valid:  true, // 因为你有一个有效的字符串，所以设置为 true
			},
		},
	})
	if err != nil {
		global.Logger.Errorln("数据插入失败 ", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": fmt.Sprintf("数据插入失败: ", err.Error())})
		return
	}

	//刷新缓存
	// layout := "2006-01-02 15:04:05"
	// startTime, _ := time.Parse(layout, "2023-07-30 14:00:00")
	// endTime, _ := time.Parse(layout, "2023-08-26 16:00:00")
	// if err := global.LicCache.RefreshCache(global.XuguDB, startTime, endTime, 0, 20); err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据刷新缓存失败：  ", err.Error())
	// 	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据刷新缓存失败: ", err.Error())})
	// 	return
	// }

	c.JSON(http.StatusOK, gin.H{
		"success": true,
	})
}

// 删除一行lincese信息
func DelLicenseInfoRow(c *gin.Context) {
	// 解析 JSON 请求体
	var request UniqueIDRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		c.JSON(400, gin.H{
			"error": err.Error(),
		})
		return
	}
	err := models.DelLicenseInfoRow(request.UniqueID)
	if err != nil {
		global.Logger.Errorln("删除一行License信息失败  ", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("删除失败: ", err.Error())})
		return
	}

	//刷新缓存
	// layout := "2006-01-02 15:04:05"
	// startTime, _ := time.Parse(layout, "2023-07-30 14:00:00")
	// endTime, _ := time.Parse(layout, "2023-08-26 16:00:00")
	// if err := global.LicCache.RefreshCache(global.XuguDB, startTime, endTime, 0, 20); err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据刷新缓存失败：  ", err.Error())
	// 	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据刷新缓存失败: ", err.Error())})
	// 	return
	// }

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    "删除成功",
	})

}

// 主动抓取一次license信息到支撑库
func CaptureLicenseOnceToDb(c *gin.Context) {
	if err := capture.CaptureOnce(global.OaDB, global.XuguDB); err != nil {
		global.Logger.Errorln("主动抓取license信息到支撑库失败：  ", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("主动抓取license信息数据失败: %s", err.Error())})
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"success": true,
	})
}

func SearchLicInfoToDb(c *gin.Context) {

	// var request string
	// if err := c.ShouldBindJSON(&request); err != nil {
	// 	c.JSON(400, gin.H{
	// 		"error": err.Error(),
	// 	})
	// 	return
	// }
	request := c.Param("data")

	if datas, err := models.SearchLicInfoToDb(request); err != nil {
		global.Logger.Errorln("搜索license信息失败：  ", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("搜索license信息失败失败: %s", err.Error())})
		return
	} else {
		c.JSON(http.StatusOK, gin.H{
			"success": true,
			"data":    datas,
		})
	}

}