[ADD]提交Gin-xdorg源码

api/v1/exa_breakpoint_continue.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"io/ioutil"
+	"strconv"
+)
+
+// @Tags ExaFileUploadAndDownload
+// @Summary 断点续传到服务器
+// @Security ApiKeyAuth
+// @accept multipart/form-data
+// @Produce  application/json
+// @Param file formData file true "an example for breakpoint resume, 断点续传示例"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"切片创建成功"}"
+// @Router /fileUploadAndDownload/breakpointContinue [post]
+func BreakpointContinue(c *gin.Context) {
+	fileMd5 := c.Request.FormValue("fileMd5")
+	fileName := c.Request.FormValue("fileName")
+	chunkMd5 := c.Request.FormValue("chunkMd5")
+	chunkNumber, _ := strconv.Atoi(c.Request.FormValue("chunkNumber"))
+	chunkTotal, _ := strconv.Atoi(c.Request.FormValue("chunkTotal"))
+	_, FileHeader, err := c.Request.FormFile("file")
+	if err != nil {
+		global.GVA_LOG.Error("接收文件失败!", zap.Any("err", err))
+		response.FailWithMessage("接收文件失败", c)
+		return
+	}
+	f, err := FileHeader.Open()
+	if err != nil {
+		global.GVA_LOG.Error("文件读取失败!", zap.Any("err", err))
+		response.FailWithMessage("文件读取失败", c)
+		return
+	}
+	defer f.Close()
+	cen, _ := ioutil.ReadAll(f)
+	if !utils.CheckMd5(cen, chunkMd5) {
+		global.GVA_LOG.Error("检查md5失败!", zap.Any("err", err))
+		response.FailWithMessage("检查md5失败", c)
+		return
+	}
+	err, file := service.FindOrCreateFile(fileMd5, fileName, chunkTotal)
+	if err != nil {
+		global.GVA_LOG.Error("查找或创建记录失败!", zap.Any("err", err))
+		response.FailWithMessage("查找或创建记录失败", c)
+		return
+	}
+	err, pathc := utils.BreakPointContinue(cen, fileName, chunkNumber, chunkTotal, fileMd5)
+	if err != nil {
+		global.GVA_LOG.Error("断点续传失败!", zap.Any("err", err))
+		response.FailWithMessage("断点续传失败", c)
+		return
+	}
+
+	if err = service.CreateFileChunk(file.ID, pathc, chunkNumber); err != nil {
+		global.GVA_LOG.Error("创建文件记录失败!", zap.Any("err", err))
+		response.FailWithMessage("创建文件记录失败", c)
+		return
+	}
+	response.OkWithMessage("切片创建成功", c)
+}
+
+// @Tags ExaFileUploadAndDownload
+// @Summary 查找文件
+// @Security ApiKeyAuth
+// @accept multipart/form-data
+// @Produce  application/json
+// @Param file formData file true "Find the file, 查找文件"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"查找成功"}"
+// @Router /fileUploadAndDownload/findFile [post]
+func FindFile(c *gin.Context) {
+	fileMd5 := c.Query("fileMd5")
+	fileName := c.Query("fileName")
+	chunkTotal, _ := strconv.Atoi(c.Query("chunkTotal"))
+	err, file := service.FindOrCreateFile(fileMd5, fileName, chunkTotal)
+	if err != nil {
+		global.GVA_LOG.Error("查找失败!", zap.Any("err", err))
+		response.FailWithMessage("查找失败", c)
+	} else {
+		response.OkWithDetailed(response.FileResponse{File: file}, "查找成功", c)
+	}
+}
+
+// @Tags ExaFileUploadAndDownload
+// @Summary 创建文件
+// @Security ApiKeyAuth
+// @accept multipart/form-data
+// @Produce  application/json
+// @Param file formData file true "上传文件完成"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"file uploaded, 文件创建成功"}"
+// @Router /fileUploadAndDownload/findFile [post]
+func BreakpointContinueFinish(c *gin.Context) {
+	fileMd5 := c.Query("fileMd5")
+	fileName := c.Query("fileName")
+	err, filePath := utils.MakeFile(fileName, fileMd5)
+	if err != nil {
+		global.GVA_LOG.Error("文件创建失败!", zap.Any("err", err))
+		response.FailWithDetailed(response.FilePathResponse{FilePath: filePath}, "文件创建失败", c)
+	} else {
+		response.OkWithDetailed(response.FilePathResponse{FilePath: filePath}, "文件创建成功", c)
+	}
+}
+
+// @Tags ExaFileUploadAndDownload
+// @Summary 删除切片
+// @Security ApiKeyAuth
+// @accept multipart/form-data
+// @Produce  application/json
+// @Param file formData file true "删除缓存切片"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"缓存切片删除成功"}"
+// @Router /fileUploadAndDownload/removeChunk [post]
+func RemoveChunk(c *gin.Context) {
+	fileMd5 := c.Query("fileMd5")
+	fileName := c.Query("fileName")
+	filePath := c.Query("filePath")
+	err := utils.RemoveChunk(fileMd5)
+	err = service.DeleteFileChunk(fileMd5, fileName, filePath)
+	if err != nil {
+		global.GVA_LOG.Error("缓存切片删除失败!", zap.Any("err", err))
+		response.FailWithDetailed(response.FilePathResponse{FilePath: filePath}, "缓存切片删除失败", c)
+	} else {
+		response.OkWithDetailed(response.FilePathResponse{FilePath: filePath}, "缓存切片删除成功", c)
+	}
+}

api/v1/exa_customer.go

+package v1
+
+import (
+	"fmt"
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags ExaCustomer
+// @Summary 创建客户
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.ExaCustomer true "客户用户名, 客户手机号码"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"创建成功"}"
+// @Router /customer/customer [post]
+func CreateExaCustomer(c *gin.Context) {
+	var customer model.ExaCustomer
+	_ = c.ShouldBindJSON(&customer)
+	if err := utils.Verify(customer, utils.CustomerVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	customer.SysUserID = getUserID(c)
+	customer.SysUserAuthorityID = getUserAuthorityId(c)
+	if err := service.CreateExaCustomer(customer); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Any("err", err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+// @Tags ExaCustomer
+// @Summary 删除客户
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.ExaCustomer true "客户ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /customer/customer [delete]
+func DeleteExaCustomer(c *gin.Context) {
+	var customer model.ExaCustomer
+	_ = c.ShouldBindJSON(&customer)
+	if err := utils.Verify(customer.GVA_MODEL, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.DeleteExaCustomer(customer); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+// @Tags ExaCustomer
+// @Summary 更新客户信息
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.ExaCustomer true "客户ID, 客户信息"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"更新成功"}"
+// @Router /customer/customer [put]
+func UpdateExaCustomer(c *gin.Context) {
+	var customer model.ExaCustomer
+	_ = c.ShouldBindJSON(&customer)
+	if err := utils.Verify(customer.GVA_MODEL, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := utils.Verify(customer, utils.CustomerVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.UpdateExaCustomer(&customer); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Any("err", err))
+		response.FailWithMessage("更新失败!", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+// @Tags ExaCustomer
+// @Summary 获取单一客户信息
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.ExaCustomer true "客户ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /customer/customer [get]
+func GetExaCustomer(c *gin.Context) {
+	var customer model.ExaCustomer
+	_ = c.ShouldBindQuery(&customer)
+	if err := utils.Verify(customer.GVA_MODEL, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	err, data := service.GetExaCustomer(customer.ID)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.ExaCustomerResponse{Customer: data}, "获取成功", c)
+	}
+}
+
+// @Tags ExaCustomer
+// @Summary 分页获取权限客户列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.PageInfo true "页码, 每页大小"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /customer/customerList [get]
+func GetExaCustomerList(c *gin.Context) {
+	var pageInfo request.PageInfo
+	_ = c.ShouldBindQuery(&pageInfo)
+	if err := utils.Verify(pageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	err, customerList, total := service.GetCustomerInfoList(getUserAuthorityId(c), pageInfo)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage(fmt.Sprintf("获取失败：%v", err), c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     customerList,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

api/v1/exa_excel.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// /excel/importExcel 接口，与upload接口作用类似，只是把文件存到resource/excel目录下，用于导入Excel时存放Excel文件(ExcelImport.xlsx)
+// /excel/loadExcel接口，用于读取resource/excel目录下的文件((ExcelImport.xlsx)并加载为[]model.SysBaseMenu类型的示例数据
+// /excel/exportExcel 接口，用于读取前端传来的tableData，生成Excel文件并返回
+// /excel/downloadTemplate 接口，用于下载resource/excel目录下的 ExcelTemplate.xlsx 文件，作为导入的模板
+
+// @Tags excel
+// @Summary 导出Excel
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce  application/octet-stream
+// @Param data body model.ExcelInfo true "导出Excel文件信息"
+// @Success 200
+// @Router /excel/exportExcel [post]
+func ExportExcel(c *gin.Context) {
+	var excelInfo model.ExcelInfo
+	_ = c.ShouldBindJSON(&excelInfo)
+	filePath := global.GVA_CONFIG.Excel.Dir + excelInfo.FileName
+	err := service.ParseInfoList2Excel(excelInfo.InfoList, filePath)
+	if err != nil {
+		global.GVA_LOG.Error("转换Excel失败!", zap.Any("err", err))
+		response.FailWithMessage("转换Excel失败", c)
+		return
+	}
+	c.Writer.Header().Add("success", "true")
+	c.File(filePath)
+}
+
+// @Tags excel
+// @Summary 导入Excel文件
+// @Security ApiKeyAuth
+// @accept multipart/form-data
+// @Produce  application/json
+// @Param file formData file true "导入Excel文件"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"导入成功"}"
+// @Router /excel/importExcel [post]
+func ImportExcel(c *gin.Context) {
+	_, header, err := c.Request.FormFile("file")
+	if err != nil {
+		global.GVA_LOG.Error("接收文件失败!", zap.Any("err", err))
+		response.FailWithMessage("接收文件失败", c)
+		return
+	}
+	_ = c.SaveUploadedFile(header, global.GVA_CONFIG.Excel.Dir+"ExcelImport.xlsx")
+	response.OkWithMessage("导入成功", c)
+}
+
+// @Tags excel
+// @Summary 加载Excel数据
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"加载数据成功"}"
+// @Router /excel/loadExcel [get]
+func LoadExcel(c *gin.Context) {
+	menus, err := service.ParseExcel2InfoList()
+	if err != nil {
+		global.GVA_LOG.Error("加载数据失败", zap.Any("err", err))
+		response.FailWithMessage("加载数据失败", c)
+		return
+	}
+	response.OkWithDetailed(response.PageResult{
+		List:     menus,
+		Total:    int64(len(menus)),
+		Page:     1,
+		PageSize: 999,
+	}, "加载数据成功", c)
+}
+
+// @Tags excel
+// @Summary 下载模板
+// @Security ApiKeyAuth
+// @accept multipart/form-data
+// @Produce  application/json
+// @Param fileName query string true "模板名称"
+// @Success 200
+// @Router /excel/downloadTemplate [get]
+func DownloadTemplate(c *gin.Context) {
+	fileName := c.Query("fileName")
+	filePath := global.GVA_CONFIG.Excel.Dir + fileName
+	ok, err := utils.PathExists(filePath)
+	if !ok || err != nil {
+		global.GVA_LOG.Error("文件不存在", zap.Any("err", err))
+		response.FailWithMessage("文件不存在", c)
+		return
+	}
+	c.Writer.Header().Add("success", "true")
+	c.File(filePath)
+}

api/v1/exa_file_upload_download.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags ExaFileUploadAndDownload
+// @Summary 上传文件示例
+// @Security ApiKeyAuth
+// @accept multipart/form-data
+// @Produce  application/json
+// @Param file formData file true "上传文件示例"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"上传成功"}"
+// @Router /fileUploadAndDownload/upload [post]
+func UploadFile(c *gin.Context) {
+	var file model.ExaFileUploadAndDownload
+	noSave := c.DefaultQuery("noSave", "0")
+	_, header, err := c.Request.FormFile("file")
+	if err != nil {
+		global.GVA_LOG.Error("接收文件失败!", zap.Any("err", err))
+		response.FailWithMessage("接收文件失败", c)
+		return
+	}
+	err, file = service.UploadFile(header, noSave) // 文件上传后拿到文件路径
+	if err != nil {
+		global.GVA_LOG.Error("修改数据库链接失败!", zap.Any("err", err))
+		response.FailWithMessage("修改数据库链接失败", c)
+		return
+	}
+	response.OkWithDetailed(response.ExaFileResponse{File: file}, "上传成功", c)
+}
+
+// @Tags ExaFileUploadAndDownload
+// @Summary 删除文件
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Param data body model.ExaFileUploadAndDownload true "传入文件里面id即可"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /fileUploadAndDownload/deleteFile [post]
+func DeleteFile(c *gin.Context) {
+	var file model.ExaFileUploadAndDownload
+	_ = c.ShouldBindJSON(&file)
+	if err := service.DeleteFile(file); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+		return
+	}
+	response.OkWithMessage("删除成功", c)
+}
+
+// @Tags ExaFileUploadAndDownload
+// @Summary 分页文件列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.PageInfo true "页码, 每页大小"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /fileUploadAndDownload/getFileList [post]
+func GetFileList(c *gin.Context) {
+	var pageInfo request.PageInfo
+	_ = c.ShouldBindJSON(&pageInfo)
+	err, list, total := service.GetFileRecordInfoList(pageInfo)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

api/v1/exa_simple_uploader.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags SimpleUploader
+// @Summary 断点续传插件版示例
+// @Security ApiKeyAuth
+// @accept multipart/form-data
+// @Produce  application/json
+// @Param file formData file true "断点续传插件版示例"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"切片创建成功"}"
+// @Router /simpleUploader/upload [post]
+func SimpleUploaderUpload(c *gin.Context) {
+	var chunk model.ExaSimpleUploader
+	_, header, err := c.Request.FormFile("file")
+	chunk.Filename = c.PostForm("filename")
+	chunk.ChunkNumber = c.PostForm("chunkNumber")
+	chunk.CurrentChunkSize = c.PostForm("currentChunkSize")
+	chunk.Identifier = c.PostForm("identifier")
+	chunk.TotalSize = c.PostForm("totalSize")
+	chunk.TotalChunks = c.PostForm("totalChunks")
+	var chunkDir = "./chunk/" + chunk.Identifier + "/"
+	hasDir, _ := utils.PathExists(chunkDir)
+	if !hasDir {
+		if err := utils.CreateDir(chunkDir); err != nil {
+			global.GVA_LOG.Error("创建目录失败!", zap.Any("err", err))
+		}
+	}
+	chunkPath := chunkDir + chunk.Filename + chunk.ChunkNumber
+	err = c.SaveUploadedFile(header, chunkPath)
+	if err != nil {
+		global.GVA_LOG.Error("切片创建失败!", zap.Any("err", err))
+		response.FailWithMessage("切片创建失败", c)
+		return
+	}
+	chunk.CurrentChunkPath = chunkPath
+	err = service.SaveChunk(chunk)
+	if err != nil {
+		global.GVA_LOG.Error("切片创建失败!", zap.Any("err", err))
+		response.FailWithMessage("切片创建失败", c)
+		return
+	} else {
+		response.OkWithMessage("切片创建成功", c)
+	}
+}
+
+// @Tags SimpleUploader
+// @Summary 断点续传插件版示例
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Param md5 query string true "md5"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"查询成功"}"
+// @Router /simpleUploader/checkFileMd5 [get]
+func CheckFileMd5(c *gin.Context) {
+	md5 := c.Query("md5")
+	err, chunks, isDone := service.CheckFileMd5(md5)
+	if err != nil {
+		global.GVA_LOG.Error("md5读取失败!", zap.Any("err", err))
+		response.FailWithMessage("md5读取失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{
+			"chunks": chunks,
+			"isDone": isDone,
+		}, "查询成功", c)
+	}
+}
+
+// @Tags SimpleUploader
+// @Summary 合并文件
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Param md5 query string true "md5"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"合并成功"}"
+// @Router /simpleUploader/mergeFileMd5 [get]
+func MergeFileMd5(c *gin.Context) {
+	md5 := c.Query("md5")
+	fileName := c.Query("fileName")
+	err := service.MergeFileMd5(md5, fileName)
+	if err != nil {
+		global.GVA_LOG.Error("md5读取失败!", zap.Any("err", err))
+		response.FailWithMessage("md5读取失败", c)
+	} else {
+		response.OkWithMessage("合并成功", c)
+	}
+}

api/v1/sys_api.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags SysApi
+// @Summary 创建基础api
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysApi true "api路径, api中文描述, api组, 方法"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"创建成功"}"
+// @Router /api/createApi [post]
+func CreateApi(c *gin.Context) {
+	var api model.SysApi
+	_ = c.ShouldBindJSON(&api)
+	if err := utils.Verify(api, utils.ApiVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.CreateApi(api); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Any("err", err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+// @Tags SysApi
+// @Summary 删除api
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysApi true "ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /api/deleteApi [post]
+func DeleteApi(c *gin.Context) {
+	var api model.SysApi
+	_ = c.ShouldBindJSON(&api)
+	if err := utils.Verify(api.GVA_MODEL, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.DeleteApi(api); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+// @Tags SysApi
+// @Summary 分页获取API列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.SearchApiParams true "分页获取API列表"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /api/getApiList [post]
+func GetApiList(c *gin.Context) {
+	var pageInfo request.SearchApiParams
+	_ = c.ShouldBindJSON(&pageInfo)
+	if err := utils.Verify(pageInfo.PageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, list, total := service.GetAPIInfoList(pageInfo.SysApi, pageInfo.PageInfo, pageInfo.OrderKey, pageInfo.Desc); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}
+
+// @Tags SysApi
+// @Summary 根据id获取api
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GetById true "根据id获取api"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /api/getApiById [post]
+func GetApiById(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
+	}
+	err, api := service.GetApiById(idInfo.ID)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithData(response.SysAPIResponse{Api: api}, c)
+	}
+}
+
+// @Tags SysApi
+// @Summary 创建基础api
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysApi true "api路径, api中文描述, api组, 方法"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"修改成功"}"
+// @Router /api/updateApi [post]
+func UpdateApi(c *gin.Context) {
+	var api model.SysApi
+	_ = c.ShouldBindJSON(&api)
+	if err := utils.Verify(api, utils.ApiVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.UpdateApi(api); err != nil {
+		global.GVA_LOG.Error("修改失败!", zap.Any("err", err))
+		response.FailWithMessage("修改失败", c)
+	} else {
+		response.OkWithMessage("修改成功", c)
+	}
+}
+
+// @Tags SysApi
+// @Summary 获取所有的Api 不分页
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /api/getAllApis [post]
+func GetAllApis(c *gin.Context) {
+	if err, apis := service.GetAllApis(); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.SysAPIListResponse{Apis: apis}, "获取成功", c)
+	}
+}
+
+// @Tags SysApi
+// @Summary 删除选中Api
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.IdsReq true "ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /api/deleteApisByIds [delete]
+func DeleteApisByIds(c *gin.Context) {
+	var ids request.IdsReq
+	_ = c.ShouldBindJSON(&ids)
+	if err := service.DeleteApisByIds(ids); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}

api/v1/sys_authority.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags Authority
+// @Summary 创建角色
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysAuthority true "权限id, 权限名, 父角色id"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"创建成功"}"
+// @Router /authority/createAuthority [post]
+func CreateAuthority(c *gin.Context) {
+	var authority model.SysAuthority
+	_ = c.ShouldBindJSON(&authority)
+	if err := utils.Verify(authority, utils.AuthorityVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, authBack := service.CreateAuthority(authority); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Any("err", err))
+		response.FailWithMessage("创建失败"+err.Error(), c)
+	} else {
+		response.OkWithDetailed(response.SysAuthorityResponse{Authority: authBack}, "创建成功", c)
+	}
+}
+
+// @Tags Authority
+// @Summary 拷贝角色
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body response.SysAuthorityCopyResponse true "旧角色id, 新权限id, 新权限名, 新父角色id"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"拷贝成功"}"
+// @Router /authority/copyAuthority [post]
+func CopyAuthority(c *gin.Context) {
+	var copyInfo response.SysAuthorityCopyResponse
+	_ = c.ShouldBindJSON(&copyInfo)
+	if err := utils.Verify(copyInfo, utils.OldAuthorityVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := utils.Verify(copyInfo.Authority, utils.AuthorityVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, authBack := service.CopyAuthority(copyInfo); err != nil {
+		global.GVA_LOG.Error("拷贝失败!", zap.Any("err", err))
+		response.FailWithMessage("拷贝失败"+err.Error(), c)
+	} else {
+		response.OkWithDetailed(response.SysAuthorityResponse{Authority: authBack}, "拷贝成功", c)
+	}
+}
+
+// @Tags Authority
+// @Summary 删除角色
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysAuthority true "删除角色"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /authority/deleteAuthority [post]
+func DeleteAuthority(c *gin.Context) {
+	var authority model.SysAuthority
+	_ = c.ShouldBindJSON(&authority)
+	if err := utils.Verify(authority, utils.AuthorityIdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.DeleteAuthority(&authority); err != nil { // 删除角色之前需要判断是否有用户正在使用此角色
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败"+err.Error(), c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+// @Tags Authority
+// @Summary 更新角色信息
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysAuthority true "权限id, 权限名, 父角色id"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"更新成功"}"
+// @Router /authority/updateAuthority [post]
+func UpdateAuthority(c *gin.Context) {
+	var auth model.SysAuthority
+	_ = c.ShouldBindJSON(&auth)
+	if err := utils.Verify(auth, utils.AuthorityVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, authority := service.UpdateAuthority(auth); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Any("err", err))
+		response.FailWithMessage("更新失败"+err.Error(), c)
+	} else {
+		response.OkWithDetailed(response.SysAuthorityResponse{Authority: authority}, "更新成功", c)
+	}
+}
+
+// @Tags Authority
+// @Summary 分页获取角色列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.PageInfo true "页码, 每页大小"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /authority/getAuthorityList [post]
+func GetAuthorityList(c *gin.Context) {
+	var pageInfo request.PageInfo
+	_ = c.ShouldBindJSON(&pageInfo)
+	if err := utils.Verify(pageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, list, total := service.GetAuthorityInfoList(pageInfo); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败"+err.Error(), c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}
+
+// @Tags Authority
+// @Summary 设置角色资源权限
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysAuthority true "设置角色资源权限"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"设置成功"}"
+// @Router /authority/setDataAuthority [post]
+func SetDataAuthority(c *gin.Context) {
+	var auth model.SysAuthority
+	_ = c.ShouldBindJSON(&auth)
+	if err := utils.Verify(auth, utils.AuthorityIdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.SetDataAuthority(auth); err != nil {
+		global.GVA_LOG.Error("设置失败!", zap.Any("err", err))
+		response.FailWithMessage("设置失败"+err.Error(), c)
+	} else {
+		response.OkWithMessage("设置成功", c)
+	}
+}

api/v1/sys_auto_code.go

+package v1
+
+import (
+	"errors"
+	"fmt"
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"net/url"
+	"os"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags AutoCode
+// @Summary 预览创建后的代码
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.AutoCodeStruct true "预览创建代码"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"创建成功"}"
+// @Router /autoCode/preview [post]
+func PreviewTemp(c *gin.Context) {
+	var a model.AutoCodeStruct
+	_ = c.ShouldBindJSON(&a)
+	if err := utils.Verify(a, utils.AutoCodeVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	autoCode, err := service.PreviewTemp(a)
+	if err != nil {
+		global.GVA_LOG.Error("预览失败!", zap.Any("err", err))
+		response.FailWithMessage("预览失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"autoCode": autoCode}, "预览成功", c)
+	}
+}
+
+// @Tags AutoCode
+// @Summary 自动代码模板
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.AutoCodeStruct true "创建自动代码"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"创建成功"}"
+// @Router /autoCode/createTemp [post]
+func CreateTemp(c *gin.Context) {
+	var a model.AutoCodeStruct
+	_ = c.ShouldBindJSON(&a)
+	if err := utils.Verify(a, utils.AutoCodeVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if a.AutoCreateApiToSql {
+		if err := service.AutoCreateApi(&a); err != nil {
+			global.GVA_LOG.Error("自动化创建失败!请自行清空垃圾数据!", zap.Any("err", err))
+			c.Writer.Header().Add("success", "false")
+			c.Writer.Header().Add("msg", url.QueryEscape("自动化创建失败!请自行清空垃圾数据!"))
+			return
+		}
+	}
+	err := service.CreateTemp(a)
+	if err != nil {
+		if errors.Is(err, model.AutoMoveErr) {
+			c.Writer.Header().Add("success", "false")
+			c.Writer.Header().Add("msgtype", "success")
+			c.Writer.Header().Add("msg", url.QueryEscape(err.Error()))
+		} else {
+			c.Writer.Header().Add("success", "false")
+			c.Writer.Header().Add("msg", url.QueryEscape(err.Error()))
+			_ = os.Remove("./ginvueadmin.zip")
+		}
+
+	} else {
+		c.Writer.Header().Add("Content-Disposition", fmt.Sprintf("attachment; filename=%s", "ginvueadmin.zip")) // fmt.Sprintf("attachment; filename=%s", filename)对下载的文件重命名
+		c.Writer.Header().Add("Content-Type", "application/json")
+		c.Writer.Header().Add("success", "true")
+		c.File("./ginvueadmin.zip")
+		_ = os.Remove("./ginvueadmin.zip")
+	}
+}
+
+// @Tags AutoCode
+// @Summary 获取当前数据库所有表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /autoCode/getTables [get]
+func GetTables(c *gin.Context) {
+	dbName := c.DefaultQuery("dbName", global.GVA_CONFIG.Mysql.Dbname)
+	err, tables := service.GetTables(dbName)
+	if err != nil {
+		global.GVA_LOG.Error("查询table失败!", zap.Any("err", err))
+		response.FailWithMessage("查询table失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"tables": tables}, "获取成功", c)
+	}
+}
+
+// @Tags AutoCode
+// @Summary 获取当前所有数据库
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /autoCode/getDatabase [get]
+func GetDB(c *gin.Context) {
+	if err, dbs := service.GetDB(); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"dbs": dbs}, "获取成功", c)
+	}
+}
+
+// @Tags AutoCode
+// @Summary 获取当前表所有字段
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /autoCode/getColumn [get]
+func GetColumn(c *gin.Context) {
+	dbName := c.DefaultQuery("dbName", global.GVA_CONFIG.Mysql.Dbname)
+	tableName := c.Query("tableName")
+	if err, columns := service.GetColumn(tableName, dbName); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"columns": columns}, "获取成功", c)
+	}
+}

api/v1/sys_captcha.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model/response"
+	"github.com/gin-gonic/gin"
+	"github.com/mojocn/base64Captcha"
+	"go.uber.org/zap"
+)
+
+var store = base64Captcha.DefaultMemStore
+
+// @Tags Base
+// @Summary 生成验证码
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"验证码获取成功"}"
+// @Router /base/captcha [post]
+func Captcha(c *gin.Context) {
+	//字符,公式,验证码配置
+	// 生成默认数字的driver
+	driver := base64Captcha.NewDriverDigit(global.GVA_CONFIG.Captcha.ImgHeight, global.GVA_CONFIG.Captcha.ImgWidth, global.GVA_CONFIG.Captcha.KeyLong, 0.7, 80)
+	cp := base64Captcha.NewCaptcha(driver, store)
+	if id, b64s, err := cp.Generate(); err != nil {
+		global.GVA_LOG.Error("验证码获取失败!", zap.Any("err", err))
+		response.FailWithMessage("验证码获取失败", c)
+	} else {
+		response.OkWithDetailed(response.SysCaptchaResponse{
+			CaptchaId: id,
+			PicPath:   b64s,
+		}, "验证码获取成功", c)
+	}
+}

api/v1/sys_casbin.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags Casbin
+// @Summary 更新角色api权限
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.CasbinInReceive true "权限id, 权限模型列表"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"更新成功"}"
+// @Router /casbin/UpdateCasbin [post]
+func UpdateCasbin(c *gin.Context) {
+	var cmr request.CasbinInReceive
+	_ = c.ShouldBindJSON(&cmr)
+	if err := utils.Verify(cmr, utils.AuthorityIdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.UpdateCasbin(cmr.AuthorityId, cmr.CasbinInfos); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Any("err", err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+// @Tags Casbin
+// @Summary 获取权限列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.CasbinInReceive true "权限id, 权限模型列表"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /casbin/getPolicyPathByAuthorityId [post]
+func GetPolicyPathByAuthorityId(c *gin.Context) {
+	var casbin request.CasbinInReceive
+	_ = c.ShouldBindJSON(&casbin)
+	if err := utils.Verify(casbin, utils.AuthorityIdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	paths := service.GetPolicyPathByAuthorityId(casbin.AuthorityId)
+	response.OkWithDetailed(response.PolicyPathResponse{Paths: paths}, "获取成功", c)
+}

api/v1/sys_dictionary.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags SysDictionary
+// @Summary 创建SysDictionary
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysDictionary true "SysDictionary模型"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"创建成功"}"
+// @Router /sysDictionary/createSysDictionary [post]
+func CreateSysDictionary(c *gin.Context) {
+	var dictionary model.SysDictionary
+	_ = c.ShouldBindJSON(&dictionary)
+	if err := service.CreateSysDictionary(dictionary); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Any("err", err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+// @Tags SysDictionary
+// @Summary 删除SysDictionary
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysDictionary true "SysDictionary模型"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /sysDictionary/deleteSysDictionary [delete]
+func DeleteSysDictionary(c *gin.Context) {
+	var dictionary model.SysDictionary
+	_ = c.ShouldBindJSON(&dictionary)
+	if err := service.DeleteSysDictionary(dictionary); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+// @Tags SysDictionary
+// @Summary 更新SysDictionary
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysDictionary true "SysDictionary模型"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"更新成功"}"
+// @Router /sysDictionary/updateSysDictionary [put]
+func UpdateSysDictionary(c *gin.Context) {
+	var dictionary model.SysDictionary
+	_ = c.ShouldBindJSON(&dictionary)
+	if err := service.UpdateSysDictionary(&dictionary); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Any("err", err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+// @Tags SysDictionary
+// @Summary 用id查询SysDictionary
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysDictionary true "ID或字典英名"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"查询成功"}"
+// @Router /sysDictionary/findSysDictionary [get]
+func FindSysDictionary(c *gin.Context) {
+	var dictionary model.SysDictionary
+	_ = c.ShouldBindQuery(&dictionary)
+	if err, sysDictionary := service.GetSysDictionary(dictionary.Type, dictionary.ID); err != nil {
+		global.GVA_LOG.Error("查询失败!", zap.Any("err", err))
+		response.FailWithMessage("查询失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"resysDictionary": sysDictionary}, "查询成功", c)
+	}
+}
+
+// @Tags SysDictionary
+// @Summary 分页获取SysDictionary列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.SysDictionarySearch true "页码, 每页大小, 搜索条件"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /sysDictionary/getSysDictionaryList [get]
+func GetSysDictionaryList(c *gin.Context) {
+	var pageInfo request.SysDictionarySearch
+	_ = c.ShouldBindQuery(&pageInfo)
+	if err := utils.Verify(pageInfo.PageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, list, total := service.GetSysDictionaryInfoList(pageInfo); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

api/v1/sys_dictionary_detail.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags SysDictionaryDetail
+// @Summary 创建SysDictionaryDetail
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysDictionaryDetail true "SysDictionaryDetail模型"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"创建成功"}"
+// @Router /sysDictionaryDetail/createSysDictionaryDetail [post]
+func CreateSysDictionaryDetail(c *gin.Context) {
+	var detail model.SysDictionaryDetail
+	_ = c.ShouldBindJSON(&detail)
+	if err := service.CreateSysDictionaryDetail(detail); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Any("err", err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+// @Tags SysDictionaryDetail
+// @Summary 删除SysDictionaryDetail
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysDictionaryDetail true "SysDictionaryDetail模型"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /sysDictionaryDetail/deleteSysDictionaryDetail [delete]
+func DeleteSysDictionaryDetail(c *gin.Context) {
+	var detail model.SysDictionaryDetail
+	_ = c.ShouldBindJSON(&detail)
+	if err := service.DeleteSysDictionaryDetail(detail); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+// @Tags SysDictionaryDetail
+// @Summary 更新SysDictionaryDetail
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysDictionaryDetail true "更新SysDictionaryDetail"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"更新成功"}"
+// @Router /sysDictionaryDetail/updateSysDictionaryDetail [put]
+func UpdateSysDictionaryDetail(c *gin.Context) {
+	var detail model.SysDictionaryDetail
+	_ = c.ShouldBindJSON(&detail)
+	if err := service.UpdateSysDictionaryDetail(&detail); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Any("err", err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+// @Tags SysDictionaryDetail
+// @Summary 用id查询SysDictionaryDetail
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysDictionaryDetail true "用id查询SysDictionaryDetail"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"查询成功"}"
+// @Router /sysDictionaryDetail/findSysDictionaryDetail [get]
+func FindSysDictionaryDetail(c *gin.Context) {
+	var detail model.SysDictionaryDetail
+	_ = c.ShouldBindQuery(&detail)
+	if err := utils.Verify(detail, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, resysDictionaryDetail := service.GetSysDictionaryDetail(detail.ID); err != nil {
+		global.GVA_LOG.Error("查询失败!", zap.Any("err", err))
+		response.FailWithMessage("查询失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"resysDictionaryDetail": resysDictionaryDetail}, "查询成功", c)
+	}
+}
+
+// @Tags SysDictionaryDetail
+// @Summary 分页获取SysDictionaryDetail列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.SysDictionaryDetailSearch true "页码, 每页大小, 搜索条件"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /sysDictionaryDetail/getSysDictionaryDetailList [get]
+func GetSysDictionaryDetailList(c *gin.Context) {
+	var pageInfo request.SysDictionaryDetailSearch
+	_ = c.ShouldBindQuery(&pageInfo)
+	if err, list, total := service.GetSysDictionaryDetailInfoList(pageInfo); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

api/v1/sys_email.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags System
+// @Summary 发送测试邮件
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"发送成功"}"
+// @Router /email/emailTest [post]
+func EmailTest(c *gin.Context) {
+	if err := service.EmailTest(); err != nil {
+		global.GVA_LOG.Error("发送失败!", zap.Any("err", err))
+		response.FailWithMessage("发送失败", c)
+	} else {
+		response.OkWithData("发送成功", c)
+	}
+}

api/v1/sys_initdb.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"go.uber.org/zap"
+
+	"github.com/gin-gonic/gin"
+)
+
+// @Tags InitDB
+// @Summary 初始化用户数据库
+// @Produce  application/json
+// @Param data body request.InitDB true "初始化数据库参数"
+// @Success 200 {string} string "{"code":0,"data":{},"msg":"自动创建数据库成功"}"
+// @Router /init/initdb [post]
+func InitDB(c *gin.Context) {
+	if global.GVA_DB != nil {
+		global.GVA_LOG.Error("非法访问")
+		response.FailWithMessage("非法访问", c)
+		return
+	}
+	var dbInfo request.InitDB
+	if err := c.ShouldBindJSON(&dbInfo); err != nil {
+		global.GVA_LOG.Error("参数校验不通过", zap.Any("err", err))
+		response.FailWithMessage("参数校验不通过", c)
+		return
+	}
+	if err := service.InitDB(dbInfo); err != nil {
+		global.GVA_LOG.Error("自动创建数据库失败", zap.Any("err", err))
+		response.FailWithMessage("自动创建数据库失败，请查看后台日志", c)
+		return
+	}
+	response.OkWithData("自动创建数据库成功", c)
+}
+
+// @Tags CheckDB
+// @Summary 初始化用户数据库
+// @Produce  application/json
+// @Success 200 {string} string "{"code":0,"data":{},"msg":"探测完成"}"
+// @Router /init/checkdb [post]
+func CheckDB(c *gin.Context) {
+	if global.GVA_DB != nil {
+		global.GVA_LOG.Info("数据库无需初始化")
+		response.OkWithDetailed(gin.H{
+			"needInit": false,
+		}, "数据库无需初始化", c)
+		return
+	} else {
+		global.GVA_LOG.Info("前往初始化数据库")
+		response.OkWithDetailed(gin.H{
+			"needInit": true,
+		}, "前往初始化数据库", c)
+		return
+	}
+}

api/v1/sys_jwt_blacklist.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags Jwt
+// @Summary jwt加入黑名单
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"拉黑成功"}"
+// @Router /jwt/jsonInBlacklist [post]
+func JsonInBlacklist(c *gin.Context) {
+	token := c.Request.Header.Get("x-token")
+	jwt := model.JwtBlacklist{Jwt: token}
+	if err := service.JsonInBlacklist(jwt); err != nil {
+		global.GVA_LOG.Error("jwt作废失败!", zap.Any("err", err))
+		response.FailWithMessage("jwt作废失败", c)
+	} else {
+		response.OkWithMessage("jwt作废成功", c)
+	}
+}

api/v1/sys_menu.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags AuthorityMenu
+// @Summary 获取用户动态路由
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Param data body request.Empty true "空"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /menu/getMenu [post]
+func GetMenu(c *gin.Context) {
+	if err, menus := service.GetMenuTree(getUserAuthorityId(c)); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.SysMenusResponse{Menus: menus}, "获取成功", c)
+	}
+}
+
+// @Tags AuthorityMenu
+// @Summary 获取用户动态路由
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Param data body request.Empty true "空"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /menu/getBaseMenuTree [post]
+func GetBaseMenuTree(c *gin.Context) {
+	if err, menus := service.GetBaseMenuTree(); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.SysBaseMenusResponse{Menus: menus}, "获取成功", c)
+	}
+}
+
+// @Tags AuthorityMenu
+// @Summary 增加menu和角色关联关系
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.AddMenuAuthorityInfo true "角色ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"添加成功"}"
+// @Router /menu/addMenuAuthority [post]
+func AddMenuAuthority(c *gin.Context) {
+	var authorityMenu request.AddMenuAuthorityInfo
+	_ = c.ShouldBindJSON(&authorityMenu)
+	if err := utils.Verify(authorityMenu, utils.AuthorityIdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.AddMenuAuthority(authorityMenu.Menus, authorityMenu.AuthorityId); err != nil {
+		global.GVA_LOG.Error("添加失败!", zap.Any("err", err))
+		response.FailWithMessage("添加失败", c)
+	} else {
+		response.OkWithMessage("添加成功", c)
+	}
+}
+
+// @Tags AuthorityMenu
+// @Summary 获取指定角色menu
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GetAuthorityId true "角色ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /menu/GetMenuAuthority [post]
+func GetMenuAuthority(c *gin.Context) {
+	var param request.GetAuthorityId
+	_ = c.ShouldBindJSON(&param)
+	if err := utils.Verify(param, utils.AuthorityIdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, menus := service.GetMenuAuthority(&param); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithDetailed(response.SysMenusResponse{Menus: menus}, "获取失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"menus": menus}, "获取成功", c)
+	}
+}
+
+// @Tags Menu
+// @Summary 新增菜单
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysBaseMenu true "路由path, 父菜单ID, 路由name, 对应前端文件路径, 排序标记"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"添加成功"}"
+// @Router /menu/addBaseMenu [post]
+func AddBaseMenu(c *gin.Context) {
+	var menu model.SysBaseMenu
+	_ = c.ShouldBindJSON(&menu)
+	if err := utils.Verify(menu, utils.MenuVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := utils.Verify(menu.Meta, utils.MenuMetaVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.AddBaseMenu(menu); err != nil {
+		global.GVA_LOG.Error("添加失败!", zap.Any("err", err))
+
+		response.FailWithMessage("添加失败", c)
+	} else {
+		response.OkWithMessage("添加成功", c)
+	}
+}
+
+// @Tags Menu
+// @Summary 删除菜单
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GetById true "菜单id"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /menu/deleteBaseMenu [post]
+func DeleteBaseMenu(c *gin.Context) {
+	var menu request.GetById
+	_ = c.ShouldBindJSON(&menu)
+	if err := utils.Verify(menu, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.DeleteBaseMenu(menu.ID); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+// @Tags Menu
+// @Summary 更新菜单
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysBaseMenu true "路由path, 父菜单ID, 路由name, 对应前端文件路径, 排序标记"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"更新成功"}"
+// @Router /menu/updateBaseMenu [post]
+func UpdateBaseMenu(c *gin.Context) {
+	var menu model.SysBaseMenu
+	_ = c.ShouldBindJSON(&menu)
+	if err := utils.Verify(menu, utils.MenuVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := utils.Verify(menu.Meta, utils.MenuMetaVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err := service.UpdateBaseMenu(menu); err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Any("err", err))
+		response.FailWithMessage("更新失败", c)
+	} else {
+		response.OkWithMessage("更新成功", c)
+	}
+}
+
+// @Tags Menu
+// @Summary 根据id获取菜单
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GetById true "菜单id"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /menu/getBaseMenuById [post]
+func GetBaseMenuById(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
+	}
+	if err, menu := service.GetBaseMenuById(idInfo.ID); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.SysBaseMenuResponse{Menu: menu}, "获取成功", c)
+	}
+}
+
+// @Tags Menu
+// @Summary 分页获取基础menu列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.PageInfo true "页码, 每页大小"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /menu/getMenuList [post]
+func GetMenuList(c *gin.Context) {
+	var pageInfo request.PageInfo
+	_ = c.ShouldBindJSON(&pageInfo)
+	if err := utils.Verify(pageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, menuList, total := service.GetInfoList(); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     menuList,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

api/v1/sys_operation_record.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags SysOperationRecord
+// @Summary 创建SysOperationRecord
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysOperationRecord true "创建SysOperationRecord"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /sysOperationRecord/createSysOperationRecord [post]
+func CreateSysOperationRecord(c *gin.Context) {
+	var sysOperationRecord model.SysOperationRecord
+	_ = c.ShouldBindJSON(&sysOperationRecord)
+	if err := service.CreateSysOperationRecord(sysOperationRecord); err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Any("err", err))
+		response.FailWithMessage("创建失败", c)
+	} else {
+		response.OkWithMessage("创建成功", c)
+	}
+}
+
+// @Tags SysOperationRecord
+// @Summary 删除SysOperationRecord
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysOperationRecord true "SysOperationRecord模型"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /sysOperationRecord/deleteSysOperationRecord [delete]
+func DeleteSysOperationRecord(c *gin.Context) {
+	var sysOperationRecord model.SysOperationRecord
+	_ = c.ShouldBindJSON(&sysOperationRecord)
+	if err := service.DeleteSysOperationRecord(sysOperationRecord); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+// @Tags SysOperationRecord
+// @Summary 批量删除SysOperationRecord
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.IdsReq true "批量删除SysOperationRecord"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"批量删除成功"}"
+// @Router /sysOperationRecord/deleteSysOperationRecordByIds [delete]
+func DeleteSysOperationRecordByIds(c *gin.Context) {
+	var IDS request.IdsReq
+	_ = c.ShouldBindJSON(&IDS)
+	if err := service.DeleteSysOperationRecordByIds(IDS); err != nil {
+		global.GVA_LOG.Error("批量删除失败!", zap.Any("err", err))
+		response.FailWithMessage("批量删除失败", c)
+	} else {
+		response.OkWithMessage("批量删除成功", c)
+	}
+}
+
+// @Tags SysOperationRecord
+// @Summary 用id查询SysOperationRecord
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysOperationRecord true "Id"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"查询成功"}"
+// @Router /sysOperationRecord/findSysOperationRecord [get]
+func FindSysOperationRecord(c *gin.Context) {
+	var sysOperationRecord model.SysOperationRecord
+	_ = c.ShouldBindQuery(&sysOperationRecord)
+	if err := utils.Verify(sysOperationRecord, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, resysOperationRecord := service.GetSysOperationRecord(sysOperationRecord.ID); err != nil {
+		global.GVA_LOG.Error("查询失败!", zap.Any("err", err))
+		response.FailWithMessage("查询失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"resysOperationRecord": resysOperationRecord}, "查询成功", c)
+	}
+}
+
+// @Tags SysOperationRecord
+// @Summary 分页获取SysOperationRecord列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.SysOperationRecordSearch true "页码, 每页大小, 搜索条件"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /sysOperationRecord/getSysOperationRecordList [get]
+func GetSysOperationRecordList(c *gin.Context) {
+	var pageInfo request.SysOperationRecordSearch
+	_ = c.ShouldBindQuery(&pageInfo)
+	if err, list, total := service.GetSysOperationRecordInfoList(pageInfo); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}

api/v1/sys_system.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"os"
+	"os/exec"
+	"runtime"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// @Tags System
+// @Summary 获取配置文件内容
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /system/getSystemConfig [post]
+func GetSystemConfig(c *gin.Context) {
+	if err, config := service.GetSystemConfig(); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.SysConfigResponse{Config: config}, "获取成功", c)
+	}
+}
+
+// @Tags System
+// @Summary 设置配置文件内容
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Param data body model.System true "设置配置文件内容"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"设置成功"}"
+// @Router /system/setSystemConfig [post]
+func SetSystemConfig(c *gin.Context) {
+	var sys model.System
+	_ = c.ShouldBindJSON(&sys)
+	if err := service.SetSystemConfig(sys); err != nil {
+		global.GVA_LOG.Error("设置失败!", zap.Any("err", err))
+		response.FailWithMessage("设置失败", c)
+	} else {
+		response.OkWithData("设置成功", c)
+	}
+}
+
+// @Tags System
+// @Summary 重启系统
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Success 200 {string} string "{"code":0,"data":{},"msg":"重启系统成功"}"
+// @Router /system/reloadSystem [post]
+func ReloadSystem(c *gin.Context) {
+	if runtime.GOOS == "windows" {
+		response.FailWithMessage("系统不支持", c)
+		return
+	}
+	pid := os.Getpid()
+	cmd := exec.Command("kill", "-1", strconv.Itoa(pid))
+	err := cmd.Run()
+	if err != nil {
+		global.GVA_LOG.Error("重启系统失败!", zap.Any("err", err))
+		response.FailWithMessage("重启系统失败", c)
+		return
+	}
+	response.OkWithMessage("重启系统成功", c)
+	return
+}
+
+// @Tags System
+// @Summary 获取服务器信息
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /system/getServerInfo [post]
+func GetServerInfo(c *gin.Context) {
+	if server, err := service.GetServerInfo(); err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+		return
+	} else {
+		response.OkWithDetailed(gin.H{"server": server}, "获取成功", c)
+	}
+
+}

api/v1/sys_user.go

+package v1
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/middleware"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"time"
+
+	"github.com/dgrijalva/jwt-go"
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis"
+	"go.uber.org/zap"
+)
+
+// @Tags Base
+// @Summary 用户登录
+// @Produce  application/json
+// @Param data body request.Login true "用户名, 密码, 验证码"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"登陆成功"}"
+// @Router /base/login [post]
+func Login(c *gin.Context) {
+	var L request.Login
+	_ = c.ShouldBindJSON(&L)
+	if err := utils.Verify(L, utils.LoginVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if store.Verify(L.CaptchaId, L.Captcha, true) {
+		U := &model.SysUser{Username: L.Username, Password: L.Password}
+		if err, user := service.Login(U); err != nil {
+			global.GVA_LOG.Error("登陆失败! 用户名不存在或者密码错误", zap.Any("err", err))
+			response.FailWithMessage("用户名不存在或者密码错误", c)
+		} else {
+			tokenNext(c, *user)
+		}
+	} else {
+		response.FailWithMessage("验证码错误", c)
+	}
+}
+
+// 登录以后签发jwt
+func tokenNext(c *gin.Context, user model.SysUser) {
+	j := &middleware.JWT{SigningKey: []byte(global.GVA_CONFIG.JWT.SigningKey)} // 唯一签名
+	claims := request.CustomClaims{
+		UUID:        user.UUID,
+		ID:          user.ID,
+		NickName:    user.NickName,
+		Username:    user.Username,
+		AuthorityId: user.AuthorityId,
+		BufferTime:  global.GVA_CONFIG.JWT.BufferTime, // 缓冲时间1天 缓冲时间内会获得新的token刷新令牌 此时一个用户会存在两个有效令牌 但是前端只留一个 另一个会丢失
+		StandardClaims: jwt.StandardClaims{
+			NotBefore: time.Now().Unix() - 1000,                              // 签名生效时间
+			ExpiresAt: time.Now().Unix() + global.GVA_CONFIG.JWT.ExpiresTime, // 过期时间 7天  配置文件
+			Issuer:    "xdorg",                                              // 签名的发行者
+		},
+	}
+	token, err := j.CreateToken(claims)
+	if err != nil {
+		global.GVA_LOG.Error("获取token失败", zap.Any("err", err))
+		response.FailWithMessage("获取token失败", c)
+		return
+	}
+	if !global.GVA_CONFIG.System.UseMultipoint {
+		response.OkWithDetailed(response.LoginResponse{
+			User:      user,
+			Token:     token,
+			ExpiresAt: claims.StandardClaims.ExpiresAt * 1000,
+		}, "登录成功", c)
+		return
+	}
+	if err, jwtStr := service.GetRedisJWT(user.Username); err == redis.Nil {
+		if err := service.SetRedisJWT(token, user.Username); err != nil {
+			global.GVA_LOG.Error("设置登录状态失败", zap.Any("err", err))
+			response.FailWithMessage("设置登录状态失败", c)
+			return
+		}
+		response.OkWithDetailed(response.LoginResponse{
+			User:      user,
+			Token:     token,
+			ExpiresAt: claims.StandardClaims.ExpiresAt * 1000,
+		}, "登录成功", c)
+	} else if err != nil {
+		global.GVA_LOG.Error("设置登录状态失败", zap.Any("err", err))
+		response.FailWithMessage("设置登录状态失败", c)
+	} else {
+		var blackJWT model.JwtBlacklist
+		blackJWT.Jwt = jwtStr
+		if err := service.JsonInBlacklist(blackJWT); err != nil {
+			response.FailWithMessage("jwt作废失败", c)
+			return
+		}
+		if err := service.SetRedisJWT(token, user.Username); err != nil {
+			response.FailWithMessage("设置登录状态失败", c)
+			return
+		}
+		response.OkWithDetailed(response.LoginResponse{
+			User:      user,
+			Token:     token,
+			ExpiresAt: claims.StandardClaims.ExpiresAt * 1000,
+		}, "登录成功", c)
+	}
+}
+
+// @Tags SysUser
+// @Summary 用户注册账号
+// @Produce  application/json
+// @Param data body model.SysUser true "用户名, 昵称, 密码, 角色ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"注册成功"}"
+// @Router /user/register [post]
+func Register(c *gin.Context) {
+	var R request.Register
+	_ = c.ShouldBindJSON(&R)
+	if err := utils.Verify(R, utils.RegisterVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	user := &model.SysUser{Username: R.Username, NickName: R.NickName, Password: R.Password, HeaderImg: R.HeaderImg, AuthorityId: R.AuthorityId}
+	err, userReturn := service.Register(*user)
+	if err != nil {
+		global.GVA_LOG.Error("注册失败", zap.Any("err", err))
+		response.FailWithDetailed(response.SysUserResponse{User: userReturn}, "注册失败", c)
+	} else {
+		response.OkWithDetailed(response.SysUserResponse{User: userReturn}, "注册成功", c)
+	}
+}
+
+// @Tags SysUser
+// @Summary 用户修改密码
+// @Security ApiKeyAuth
+// @Produce  application/json
+// @Param data body request.ChangePasswordStruct true "用户名, 原密码, 新密码"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"修改成功"}"
+// @Router /user/changePassword [put]
+func ChangePassword(c *gin.Context) {
+	var user request.ChangePasswordStruct
+	_ = c.ShouldBindJSON(&user)
+	if err := utils.Verify(user, utils.ChangePasswordVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	U := &model.SysUser{Username: user.Username, Password: user.Password}
+	if err, _ := service.ChangePassword(U, user.NewPassword); err != nil {
+		global.GVA_LOG.Error("修改失败", zap.Any("err", err))
+		response.FailWithMessage("修改失败，原密码与当前账户不符", c)
+	} else {
+		response.OkWithMessage("修改成功", c)
+	}
+}
+
+// @Tags SysUser
+// @Summary 分页获取用户列表
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.PageInfo true "页码, 每页大小"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
+// @Router /user/getUserList [post]
+func GetUserList(c *gin.Context) {
+	var pageInfo request.PageInfo
+	_ = c.ShouldBindJSON(&pageInfo)
+	if err := utils.Verify(pageInfo, utils.PageInfoVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, list, total := service.GetUserInfoList(pageInfo); err != nil {
+		global.GVA_LOG.Error("获取失败", zap.Any("err", err))
+		response.FailWithMessage("获取失败", c)
+	} else {
+		response.OkWithDetailed(response.PageResult{
+			List:     list,
+			Total:    total,
+			Page:     pageInfo.Page,
+			PageSize: pageInfo.PageSize,
+		}, "获取成功", c)
+	}
+}
+
+// @Tags SysUser
+// @Summary 设置用户权限
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.SetUserAuth true "用户UUID, 角色ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"修改成功"}"
+// @Router /user/setUserAuthority [post]
+func SetUserAuthority(c *gin.Context) {
+	var sua request.SetUserAuth
+	_ = c.ShouldBindJSON(&sua)
+	if UserVerifyErr := utils.Verify(sua, utils.SetUserAuthorityVerify); UserVerifyErr != nil {
+		response.FailWithMessage(UserVerifyErr.Error(), c)
+		return
+	}
+	if err := service.SetUserAuthority(sua.UUID, sua.AuthorityId); err != nil {
+		global.GVA_LOG.Error("修改失败", zap.Any("err", err))
+		response.FailWithMessage("修改失败", c)
+	} else {
+		response.OkWithMessage("修改成功", c)
+	}
+}
+
+// @Tags SysUser
+// @Summary 删除用户
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body request.GetById true "用户ID"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
+// @Router /user/deleteUser [delete]
+func DeleteUser(c *gin.Context) {
+	var reqId request.GetById
+	_ = c.ShouldBindJSON(&reqId)
+	if err := utils.Verify(reqId, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	jwtId := getUserID(c)
+	if jwtId == uint(reqId.ID) {
+		response.FailWithMessage("删除失败, 自杀失败", c)
+		return
+	}
+	if err := service.DeleteUser(reqId.ID); err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Any("err", err))
+		response.FailWithMessage("删除失败", c)
+	} else {
+		response.OkWithMessage("删除成功", c)
+	}
+}
+
+// @Tags SysUser
+// @Summary 设置用户信息
+// @Security ApiKeyAuth
+// @accept application/json
+// @Produce application/json
+// @Param data body model.SysUser true "ID, 用户名, 昵称, 头像链接"
+// @Success 200 {string} string "{"success":true,"data":{},"msg":"设置成功"}"
+// @Router /user/setUserInfo [put]
+func SetUserInfo(c *gin.Context) {
+	var user model.SysUser
+	_ = c.ShouldBindJSON(&user)
+	if err := utils.Verify(user, utils.IdVerify); err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	if err, ReqUser := service.SetUserInfo(user); err != nil {
+		global.GVA_LOG.Error("设置失败", zap.Any("err", err))
+		response.FailWithMessage("设置失败", c)
+	} else {
+		response.OkWithDetailed(gin.H{"userInfo": ReqUser}, "设置成功", c)
+	}
+}
+
+// 从Gin的Context中获取从jwt解析出来的用户ID
+func getUserID(c *gin.Context) uint {
+	if claims, exists := c.Get("claims"); !exists {
+		global.GVA_LOG.Error("从Gin的Context中获取从jwt解析出来的用户ID失败, 请检查路由是否使用jwt中间件")
+		return 0
+	} else {
+		waitUse := claims.(*request.CustomClaims)
+		return waitUse.ID
+	}
+}
+
+// 从Gin的Context中获取从jwt解析出来的用户UUID
+func getUserUuid(c *gin.Context) string {
+	if claims, exists := c.Get("claims"); !exists {
+		global.GVA_LOG.Error("从Gin的Context中获取从jwt解析出来的用户UUID失败, 请检查路由是否使用jwt中间件")
+		return ""
+	} else {
+		waitUse := claims.(*request.CustomClaims)
+		return waitUse.UUID.String()
+	}
+}
+
+// 从Gin的Context中获取从jwt解析出来的用户角色id
+func getUserAuthorityId(c *gin.Context) string {
+	if claims, exists := c.Get("claims"); !exists {
+		global.GVA_LOG.Error("从Gin的Context中获取从jwt解析出来的用户UUID失败, 请检查路由是否使用jwt中间件")
+		return ""
+	} else {
+		waitUse := claims.(*request.CustomClaims)
+		return waitUse.AuthorityId
+	}
+}

config.yaml

+aliyun-oss:
+  access-key-id: yourAccessKeyId
+  access-key-secret: yourAccessKeySecret
+  bucket-name: yourBucketName
+  bucket-url: yourBucketUrl
+  endpoint: yourEndpoint
+aliyunoss:
+  endpoint: yourEndpoint
+  access-key-id: yourAccessKeyId
+  access-key-secret: yourAccessKeySecret
+  bucket-name: yourBucketName
+  bucket-url: yourBucketUrl
+autocode:
+  root: D:\code\goCode\src\codechina.csdn.net\gin-xdorg
+  server: /server
+  server-api: /api/v1
+  server-initialize: /initialize
+  server-model: /model
+  server-request: /model/request/
+  server-router: /router
+  server-service: /service
+  web: /web/src
+  web-api: /api
+  web-form: /view
+  web-table: /view
+  web-flow: /view
+captcha:
+  key-long: 6
+  img-width: 240
+  img-height: 80
+casbin:
+  model-path: ./resource/rbac_model.conf
+email:
+  to: xxxxxx@qq.com
+  port: 465
+  from: xxxxxx@163.com
+  host: smtp.163.com
+  is-ssl: true
+  secret: xxx
+  nickname: test
+excel:
+  dir: ./resource/excel/
+jwt:
+  signing-key: XDORG
+  expires-time: 604800
+  buffer-time: 86400
+local:
+  path: uploads/file
+mysql:
+  path: 127.0.0.1:3306
+  config: charset=utf8mb4&parseTime=True&loc=Local
+  db-name: xdorg
+  username: root
+  password: daixuan
+  max-idle-conns: 0
+  max-open-conns: 0
+  log-mode: false
+  log-zap: ""
+qiniu:
+  zone: ZoneHuadong
+  bucket: qm-plus-img
+  img-path: http://qmplusimg.henrongyi.top
+  use-https: false
+  access-key: 25j8dYBZ2wuiy0yhwShytjZDTX662b8xiFguwxzZ
+  secret-key: pgdbqEsf7ooZh7W3xokP833h3dZ_VecFXPDeG5JY
+  use-cdn-domains: false
+redis:
+  db: 0
+  addr: 127.0.0.1:6379
+  password: ""
+system:
+  env: public
+  addr: 8888
+  db-type: mysql
+  oss-type: local
+  use-multipoint: false
+tencent-cos:
+  base-url: https://codechina.csdn.net/xdorg
+  bucket: xxxxx-10005608
+  path-prefix: gin-xdorg
+  region: ap-shanghai
+  secret-id: xxxxxxxx
+  secret-key: xxxxxxxx
+tencentcos:
+  bucket: xxxxx-10005608
+  region: ap-shanghai
+  secret-id: xxxxxxxx
+  secret-key: xxxxxxxx
+  base-url: https://gin.vue.admin
+  path-prefix: gin-xdorg
+timer:
+  start: false
+  spec: '@daily'
+  detail:
+  - tableName: sys_operation_records
+    compareField: created_at
+    interval: 2160h
+zap:
+  level: info
+  format: console
+  prefix: '[GIN-XDORG]'
+  director: log
+  link-name: latest_log
+  showLine: true
+  encode-level: LowercaseColorLevelEncoder
+  stacktrace-key: stacktrace
+  log-in-console: true

config/auto_code.go

+package config
+
+type Autocode struct {
+	Root        string `mapstructure:"root" json:"root" yaml:"root"`
+	Server      string `mapstructure:"server" json:"server" yaml:"server"`
+	SApi        string `mapstructure:"server-api" json:"serverApi" yaml:"server-api"`
+	SInitialize string `mapstructure:"server-initialize" json:"serverInitialize" yaml:"server-initialize"`
+	SModel      string `mapstructure:"server-model" json:"serverModel" yaml:"server-model"`
+	SRequest    string `mapstructure:"server-request" json:"serverRequest"  yaml:"server-request"`
+	SRouter     string `mapstructure:"server-router" json:"serverRouter" yaml:"server-router"`
+	SService    string `mapstructure:"server-service" json:"serverService" yaml:"server-service"`
+	Web         string `mapstructure:"web" json:"web" yaml:"web"`
+	WApi        string `mapstructure:"web-api" json:"webApi" yaml:"web-api"`
+	WForm       string `mapstructure:"web-form" json:"webForm" yaml:"web-form"`
+	WTable      string `mapstructure:"web-table" json:"webTable" yaml:"web-table"`
+	WFlow       string `mapstructure:"web-flow" json:"webFlow" yaml:"web-flow"`
+}

config/captcha.go

+package config
+
+type Captcha struct {
+	KeyLong   int `mapstructure:"key-long" json:"keyLong" yaml:"key-long"`       // 验证码长度
+	ImgWidth  int `mapstructure:"img-width" json:"imgWidth" yaml:"img-width"`    // 图片宽度
+	ImgHeight int `mapstructure:"img-height" json:"imgHeight" yaml:"img-height"` // 图片高度
+}

config/casbin.go

+package config
+
+type Casbin struct {
+	ModelPath string `mapstructure:"model-path" json:"modelPath" yaml:"model-path"` // Model路径
+}

config/config.go

+package config
+
+type Server struct {
+	JWT     JWT     `mapstructure:"jwt" json:"jwt" yaml:"jwt"`
+	Zap     Zap     `mapstructure:"zap" json:"zap" yaml:"zap"`
+	Redis   Redis   `mapstructure:"redis" json:"redis" yaml:"redis"`
+	Email   Email   `mapstructure:"email" json:"email" yaml:"email"`
+	Casbin  Casbin  `mapstructure:"casbin" json:"casbin" yaml:"casbin"`
+	System  System  `mapstructure:"system" json:"system" yaml:"system"`
+	Captcha Captcha `mapstructure:"captcha" json:"captcha" yaml:"captcha"`
+	// auto
+	AutoCode Autocode `mapstructure:"autoCode" json:"autoCode" yaml:"autoCode"`
+	// gorm
+	Mysql Mysql `mapstructure:"mysql" json:"mysql" yaml:"mysql"`
+	// oss
+	Local      Local      `mapstructure:"local" json:"local" yaml:"local"`
+	Qiniu      Qiniu      `mapstructure:"qiniu" json:"qiniu" yaml:"qiniu"`
+	AliyunOSS  AliyunOSS  `mapstructure:"aliyun-oss" json:"aliyunOSS" yaml:"aliyun-oss"`
+	TencentCOS TencentCOS `mapstructure:"tencent-cos" json:"tencentCOS" yaml:"tencent-cos"`
+	Excel      Excel      `mapstructure:"excel" json:"excel" yaml:"excel"`
+	Timer      Timer      `mapstructure:"timer" json:"timer" yaml:"timer"`
+}

config/email.go

+package config
+
+type Email struct {
+	To       string `mapstructure:"to" json:"to" yaml:"to"`                   // 收件人
+	Port     int    `mapstructure:"port" json:"port" yaml:"port"`             // 端口
+	From     string `mapstructure:"from" json:"from" yaml:"from"`             // 收件人
+	Host     string `mapstructure:"host" json:"host" yaml:"host"`             // 服务器地址
+	IsSSL    bool   `mapstructure:"is-ssl" json:"isSSL" yaml:"is-ssl"`        // 是否SSL
+	Secret   string `mapstructure:"secret" json:"secret" yaml:"secret"`       // 密钥
+	Nickname string `mapstructure:"nickname" json:"nickname" yaml:"nickname"` // 昵称
+}

config/excel.go

+package config
+
+type Excel struct {
+	Dir string `mapstructure:"dir" json:"dir" yaml:"dir"`
+}

config/gorm.go

+package config
+
+type Mysql struct {
+	Path         string `mapstructure:"path" json:"path" yaml:"path"` // 服务器地址:端口
+	Config       string `mapstructure:"config" json:"config" yaml:"config"`
+	Dbname       string `mapstructure:"db-name" json:"dbname" yaml:"db-name"`     // 数据库名
+	Username     string `mapstructure:"username" json:"username" yaml:"username"` // 数据库用户名
+	Password     string `mapstructure:"password" json:"password" yaml:"password"` // 数据库密码
+	MaxIdleConns int    `mapstructure:"max-idle-conns" json:"maxIdleConns" yaml:"max-idle-conns"`
+	MaxOpenConns int    `mapstructure:"max-open-conns" json:"maxOpenConns" yaml:"max-open-conns"`
+	LogMode      bool   `mapstructure:"log-mode" json:"logMode" yaml:"log-mode"`
+	LogZap       string `mapstructure:"log-zap" json:"logZap" yaml:"log-zap"`
+}
+
+func (m *Mysql) Dsn() string {
+	return m.Username + ":" + m.Password + "@tcp(" + m.Path + ")/" + m.Dbname + "?" + m.Config
+}

config/jwt.go

+package config
+
+type JWT struct {
+	SigningKey  string `mapstructure:"signing-key" json:"signingKey" yaml:"signing-key"`    // jwt签名
+	ExpiresTime int64  `mapstructure:"expires-time" json:"expiresTime" yaml:"expires-time"` // 过期时间
+	BufferTime  int64  `mapstructure:"buffer-time" json:"bufferTime" yaml:"buffer-time"`    // 缓冲时间
+}

config/oss.go

+package config
+
+type Local struct {
+	Path string `mapstructure:"path" json:"path" yaml:"path"` // 本地文件路径
+}
+
+type Qiniu struct {
+	Zone          string `mapstructure:"zone" json:"zone" yaml:"zone"`                                // 存储区域
+	Bucket        string `mapstructure:"bucket" json:"bucket" yaml:"bucket"`                          // 空间名称
+	ImgPath       string `mapstructure:"img-path" json:"imgPath" yaml:"img-path"`                     // CDN加速域名
+	UseHTTPS      bool   `mapstructure:"use-https" json:"useHttps" yaml:"use-https"`                  // 是否使用https
+	AccessKey     string `mapstructure:"access-key" json:"accessKey" yaml:"access-key"`               // accessKey
+	SecretKey     string `mapstructure:"secret-key" json:"secretKey" yaml:"secret-key"`               // secretKey
+	UseCdnDomains bool   `mapstructure:"use-cdn-domains" json:"useCdnDomains" yaml:"use-cdn-domains"` // 上传是否使用CDN上传加速
+}
+
+type AliyunOSS struct {
+	Endpoint        string `mapstructure:"endpoint" json:"endpoint" yaml:"endpoint"`
+	AccessKeyId     string `mapstructure:"access-key-id" json:"accessKeyId" yaml:"access-key-id"`
+	AccessKeySecret string `mapstructure:"access-key-secret" json:"accessKeySecret" yaml:"access-key-secret"`
+	BucketName      string `mapstructure:"bucket-name" json:"bucketName" yaml:"bucket-name"`
+	BucketUrl       string `mapstructure:"bucket-url" json:"bucketUrl" yaml:"bucket-url"`
+}
+type TencentCOS struct {
+	Bucket     string `mapstructure:"bucket" json:"bucket" yaml:"bucket"`
+	Region     string `mapstructure:"region" json:"region" yaml:"region"`
+	SecretID   string `mapstructure:"secret-id" json:"secretID" yaml:"secret-id"`
+	SecretKey  string `mapstructure:"secret-key" json:"secretKey" yaml:"secret-key"`
+	BaseURL    string `mapstructure:"base-url" json:"baseURL" yaml:"base-url"`
+	PathPrefix string `mapstructure:"path-prefix" json:"pathPrefix" yaml:"path-prefix"`
+}

config/redis.go

+package config
+
+type Redis struct {
+	DB       int    `mapstructure:"db" json:"db" yaml:"db"`
+	Addr     string `mapstructure:"addr" json:"addr" yaml:"addr"`             // 服务器地址:端口
+	Password string `mapstructure:"password" json:"password" yaml:"password"` // 密码
+}

config/system.go

+package config
+
+type System struct {
+	Env           string `mapstructure:"env" json:"env" yaml:"env"`                                 // 环境值
+	Addr          int    `mapstructure:"addr" json:"addr" yaml:"addr"`                              // 端口值
+	DbType        string `mapstructure:"db-type" json:"dbType" yaml:"db-type"`                      // 数据库类型:mysql(默认)|sqlite|sqlserver|postgresql
+	OssType       string `mapstructure:"oss-type" json:"ossType" yaml:"oss-type"`                   // Oss类型
+	UseMultipoint bool   `mapstructure:"use-multipoint" json:"useMultipoint" yaml:"use-multipoint"` // 多点登录拦截
+}

config/timer.go

+package config
+
+type Timer struct {
+	Start  bool     `mapstructure:"start" json:"start" yaml:"start"`
+	Spec   string   `mapstructure:"spec" json:"spec" yaml:"spec"`
+	Detail []Detail `mapstructure:"detail" json:"detail" yaml:"detail"`
+}
+
+type Detail struct {
+	TableName    string `mapstructure:"tableName" json:"tableName" yaml:"tableName"`
+	CompareField string `mapstructure:"compareField" json:"compareField" yaml:"compareField"`
+	Interval     string `mapstructure:"interval" json:"interval" yaml:"interval"`
+}

config/zap.go

+package config
+
+type Zap struct {
+	Level         string `mapstructure:"level" json:"level" yaml:"level"`                           // 级别
+	Format        string `mapstructure:"format" json:"format" yaml:"format"`                        // 输出
+	Prefix        string `mapstructure:"prefix" json:"prefix" yaml:"prefix"`                        // 日志前缀
+	Director      string `mapstructure:"director" json:"director"  yaml:"director"`                 // 日志文件夹
+	LinkName      string `mapstructure:"link-name" json:"linkName" yaml:"link-name"`                // 软链接名称
+	ShowLine      bool   `mapstructure:"show-line" json:"showLine" yaml:"showLine"`                 // 显示行
+	EncodeLevel   string `mapstructure:"encode-level" json:"encodeLevel" yaml:"encode-level"`       // 编码级
+	StacktraceKey string `mapstructure:"stacktrace-key" json:"stacktraceKey" yaml:"stacktrace-key"` // 栈名
+	LogInConsole  bool   `mapstructure:"log-in-console" json:"logInConsole" yaml:"log-in-console"`  // 输出控制台
+}

core/server.go

+package core
+
+import (
+	"fmt"
+	"gin-xdorg/global"
+	"gin-xdorg/initialize"
+	"go.uber.org/zap"
+	"time"
+)
+
+type server interface {
+	ListenAndServe() error
+}
+
+func RunWindowsServer() {
+	if global.GVA_CONFIG.System.UseMultipoint {
+		// 初始化redis服务
+		initialize.Redis()
+	}
+	Router := initialize.Routers()
+	Router.Static("/form-generator", "./resource/page")
+
+	address := fmt.Sprintf(":%d", global.GVA_CONFIG.System.Addr)
+	s := initServer(address, Router)
+	// 保证文本顺序输出
+	// In order to ensure that the text order output can be deleted
+	time.Sleep(10 * time.Microsecond)
+	global.GVA_LOG.Info("server run success on ", zap.String("address", address))
+
+	fmt.Printf(`
+	欢迎使用 gin-xdorg
+	当前版本: V1.0
+	微信公众号: 编程者联盟
+	默认自动化文档地址: http://127.0.0.1%s/swagger/index.html
+	默认前端文件运行地址: http://127.0.0.1:8080
+`, address)
+	global.GVA_LOG.Error(s.ListenAndServe().Error())
+}

core/server_other.go

+// +build !windows
+
+package core
+
+import (
+	"github.com/fvbock/endless"
+	"github.com/gin-gonic/gin"
+	"time"
+)
+
+func initServer(address string, router *gin.Engine) server {
+	s := endless.NewServer(address, router)
+	s.ReadHeaderTimeout = 10 * time.Millisecond
+	s.WriteTimeout = 10 * time.Second
+	s.MaxHeaderBytes = 1 << 20
+	return s
+}

core/server_win.go

+// +build windows
+
+package core
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"time"
+)
+
+func initServer(address string, router *gin.Engine) server {
+	return &http.Server{
+		Addr:           address,
+		Handler:        router,
+		ReadTimeout:    10 * time.Second,
+		WriteTimeout:   10 * time.Second,
+		MaxHeaderBytes: 1 << 20,
+	}
+}

core/viper.go

+package core
+
+import (
+	"flag"
+	"fmt"
+	"gin-xdorg/global"
+	_ "gin-xdorg/packfile"
+	"gin-xdorg/utils"
+	"os"
+	"path/filepath"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/spf13/viper"
+)
+
+func Viper(path ...string) *viper.Viper {
+	var config string
+	if len(path) == 0 {
+		flag.StringVar(&config, "c", "", "choose config file.")
+		flag.Parse()
+		if config == "" { // 优先级: 命令行 > 环境变量 > 默认值
+			if configEnv := os.Getenv(utils.ConfigEnv); configEnv == "" {
+				config = utils.ConfigFile
+				fmt.Printf("您正在使用config的默认值,config的路径为%v\n", utils.ConfigFile)
+			} else {
+				config = configEnv
+				fmt.Printf("您正在使用GVA_CONFIG环境变量,config的路径为%v\n", config)
+			}
+		} else {
+			fmt.Printf("您正在使用命令行的-c参数传递的值,config的路径为%v\n", config)
+		}
+	} else {
+		config = path[0]
+		fmt.Printf("您正在使用func Viper()传递的值,config的路径为%v\n", config)
+	}
+
+	v := viper.New()
+	v.SetConfigFile(config)
+	err := v.ReadInConfig()
+	if err != nil {
+		panic(fmt.Errorf("Fatal error config file: %s \n", err))
+	}
+	v.WatchConfig()
+
+	v.OnConfigChange(func(e fsnotify.Event) {
+		fmt.Println("config file changed:", e.Name)
+		if err := v.Unmarshal(&global.GVA_CONFIG); err != nil {
+			fmt.Println(err)
+		}
+	})
+	if err := v.Unmarshal(&global.GVA_CONFIG); err != nil {
+		fmt.Println(err)
+	}
+	global.GVA_CONFIG.AutoCode.Root, _ = filepath.Abs("..")
+	return v
+}

core/zap.go

+package core
+
+import (
+	"fmt"
+	"gin-xdorg/global"
+	"gin-xdorg/utils"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"os"
+	"time"
+)
+
+var level zapcore.Level
+
+func Zap() (logger *zap.Logger) {
+	if ok, _ := utils.PathExists(global.GVA_CONFIG.Zap.Director); !ok { // 判断是否有Director文件夹
+		fmt.Printf("create %v directory\n", global.GVA_CONFIG.Zap.Director)
+		_ = os.Mkdir(global.GVA_CONFIG.Zap.Director, os.ModePerm)
+	}
+
+	switch global.GVA_CONFIG.Zap.Level { // 初始化配置文件的Level
+	case "debug":
+		level = zap.DebugLevel
+	case "info":
+		level = zap.InfoLevel
+	case "warn":
+		level = zap.WarnLevel
+	case "error":
+		level = zap.ErrorLevel
+	case "dpanic":
+		level = zap.DPanicLevel
+	case "panic":
+		level = zap.PanicLevel
+	case "fatal":
+		level = zap.FatalLevel
+	default:
+		level = zap.InfoLevel
+	}
+
+	if level == zap.DebugLevel || level == zap.ErrorLevel {
+		logger = zap.New(getEncoderCore(), zap.AddStacktrace(level))
+	} else {
+		logger = zap.New(getEncoderCore())
+	}
+	if global.GVA_CONFIG.Zap.ShowLine {
+		logger = logger.WithOptions(zap.AddCaller())
+	}
+	return logger
+}
+
+// getEncoderConfig 获取zapcore.EncoderConfig
+func getEncoderConfig() (config zapcore.EncoderConfig) {
+	config = zapcore.EncoderConfig{
+		MessageKey:     "message",
+		LevelKey:       "level",
+		TimeKey:        "time",
+		NameKey:        "logger",
+		CallerKey:      "caller",
+		StacktraceKey:  global.GVA_CONFIG.Zap.StacktraceKey,
+		LineEnding:     zapcore.DefaultLineEnding,
+		EncodeLevel:    zapcore.LowercaseLevelEncoder,
+		EncodeTime:     CustomTimeEncoder,
+		EncodeDuration: zapcore.SecondsDurationEncoder,
+		EncodeCaller:   zapcore.FullCallerEncoder,
+	}
+	switch {
+	case global.GVA_CONFIG.Zap.EncodeLevel == "LowercaseLevelEncoder": // 小写编码器(默认)
+		config.EncodeLevel = zapcore.LowercaseLevelEncoder
+	case global.GVA_CONFIG.Zap.EncodeLevel == "LowercaseColorLevelEncoder": // 小写编码器带颜色
+		config.EncodeLevel = zapcore.LowercaseColorLevelEncoder
+	case global.GVA_CONFIG.Zap.EncodeLevel == "CapitalLevelEncoder": // 大写编码器
+		config.EncodeLevel = zapcore.CapitalLevelEncoder
+	case global.GVA_CONFIG.Zap.EncodeLevel == "CapitalColorLevelEncoder": // 大写编码器带颜色
+		config.EncodeLevel = zapcore.CapitalColorLevelEncoder
+	default:
+		config.EncodeLevel = zapcore.LowercaseLevelEncoder
+	}
+	return config
+}
+
+// getEncoder 获取zapcore.Encoder
+func getEncoder() zapcore.Encoder {
+	if global.GVA_CONFIG.Zap.Format == "json" {
+		return zapcore.NewJSONEncoder(getEncoderConfig())
+	}
+	return zapcore.NewConsoleEncoder(getEncoderConfig())
+}
+
+// getEncoderCore 获取Encoder的zapcore.Core
+func getEncoderCore() (core zapcore.Core) {
+	writer, err := utils.GetWriteSyncer() // 使用file-rotatelogs进行日志分割
+	if err != nil {
+		fmt.Printf("Get Write Syncer Failed err:%v", err.Error())
+		return
+	}
+	return zapcore.NewCore(getEncoder(), writer, level)
+}
+
+// 自定义日志输出时间格式
+func CustomTimeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
+	enc.AppendString(t.Format(global.GVA_CONFIG.Zap.Prefix + "2006/01/02 - 15:04:05.000"))
+}

global/global.go

+package global
+
+import (
+	"gin-xdorg/utils/timer"
+
+	"go.uber.org/zap"
+
+	"gin-xdorg/config"
+
+	"github.com/go-redis/redis"
+	"github.com/spf13/viper"
+	"gorm.io/gorm"
+)
+
+var (
+	GVA_DB     *gorm.DB
+	GVA_REDIS  *redis.Client
+	GVA_CONFIG config.Server
+	GVA_VP     *viper.Viper
+	//GVA_LOG    *oplogging.Logger
+	GVA_LOG   *zap.Logger
+	GVA_Timer timer.Timer = timer.NewTimerTask()
+)

global/model.go

+package global
+
+import (
+	"gorm.io/gorm"
+	"time"
+)
+
+type GVA_MODEL struct {
+	ID        uint           `gorm:"primarykey"` // 主键ID
+	CreatedAt time.Time      // 创建时间
+	UpdatedAt time.Time      // 更新时间
+	DeletedAt gorm.DeletedAt `gorm:"index" json:"-"` // 删除时间
+}

go.mod

+module gin-xdorg
+
+go 1.14
+
+require (
+	github.com/360EntSecGroup-Skylar/excelize/v2 v2.3.2
+	github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect
+	github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751
+	github.com/aliyun/aliyun-oss-go-sdk v2.1.6+incompatible
+	github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f // indirect
+	github.com/casbin/casbin/v2 v2.25.6
+	github.com/casbin/gorm-adapter/v3 v3.2.6
+	github.com/dgrijalva/jwt-go v3.2.0+incompatible
+	github.com/fastly/go-utils v0.0.0-20180712184237-d95a45783239 // indirect
+	github.com/fsnotify/fsnotify v1.4.9
+	github.com/fvbock/endless v0.0.0-20170109170031-447134032cb6
+	github.com/gin-gonic/gin v1.6.3
+	github.com/go-ole/go-ole v1.2.4 // indirect
+	github.com/go-openapi/spec v0.19.7 // indirect
+	github.com/go-openapi/swag v0.19.8 // indirect
+	github.com/go-playground/validator/v10 v10.3.0 // indirect
+	github.com/go-redis/redis v6.15.7+incompatible
+	github.com/go-sql-driver/mysql v1.5.0
+	github.com/golang/protobuf v1.4.2 // indirect
+	github.com/gookit/color v1.3.1
+	github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869 // indirect
+	github.com/jordan-wright/email v0.0.0-20200824153738-3f5bafa1cd84
+	github.com/json-iterator/go v1.1.10 // indirect
+	github.com/lestrrat-go/file-rotatelogs v2.3.0+incompatible
+	github.com/lestrrat-go/strftime v1.0.3 // indirect
+	github.com/mailru/easyjson v0.7.1 // indirect
+	github.com/mitchellh/mapstructure v1.2.2 // indirect
+	github.com/mojocn/base64Captcha v1.3.1
+	github.com/onsi/ginkgo v1.7.0 // indirect
+	github.com/onsi/gomega v1.4.3 // indirect
+	github.com/pelletier/go-toml v1.6.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/qiniu/api.v7/v7 v7.4.1
+	github.com/robfig/cron/v3 v3.0.1
+	github.com/satori/go.uuid v1.2.0
+	github.com/shirou/gopsutil v3.21.1+incompatible
+	github.com/spf13/afero v1.2.2 // indirect
+	github.com/spf13/cast v1.3.1 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/spf13/viper v1.7.0
+	github.com/swaggo/gin-swagger v1.2.0
+	github.com/swaggo/swag v1.6.7
+	github.com/tebeka/strftime v0.1.3 // indirect
+	github.com/tencentyun/cos-go-sdk-v5 v0.7.19
+	github.com/unrolled/secure v1.0.7
+	go.uber.org/zap v1.10.0
+	golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2 // indirect
+	golang.org/x/tools v0.0.0-20200324003944-a576cf524670 // indirect
+	google.golang.org/protobuf v1.24.0 // indirect
+	gopkg.in/ini.v1 v1.55.0 // indirect
+	gopkg.in/yaml.v2 v2.3.0 // indirect
+	gorm.io/driver/mysql v1.0.1
+	gorm.io/gorm v1.20.7
+)

initialize/gorm.go

+package initialize
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/initialize/internal"
+	"gin-xdorg/model"
+	"os"
+
+	"go.uber.org/zap"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+//@author: SliverHorn
+//@function: Gorm
+//@description: 初始化数据库并产生数据库全局变量
+//@return: *gorm.DB
+
+func Gorm() *gorm.DB {
+	switch global.GVA_CONFIG.System.DbType {
+	case "mysql":
+		return GormMysql()
+	default:
+		return GormMysql()
+	}
+}
+
+// MysqlTables
+//@author: SliverHorn
+//@function: MysqlTables
+//@description: 注册数据库表专用
+//@param: db *gorm.DB
+
+func MysqlTables(db *gorm.DB) {
+	err := db.AutoMigrate(
+		model.SysUser{},
+		model.SysAuthority{},
+		model.SysApi{},
+		model.SysBaseMenu{},
+		model.SysBaseMenuParameter{},
+		model.JwtBlacklist{},
+		model.SysDictionary{},
+		model.SysDictionaryDetail{},
+		model.ExaFileUploadAndDownload{},
+		model.ExaFile{},
+		model.ExaFileChunk{},
+		model.ExaSimpleUploader{},
+		model.ExaCustomer{},
+		model.SysOperationRecord{},
+
+		// Code generated by gin-xdorg Begin; DO NOT EDIT.
+		// Code generated by gin-xdorg End; DO NOT EDIT.
+	)
+	if err != nil {
+		global.GVA_LOG.Error("register table failed", zap.Any("err", err))
+		os.Exit(0)
+	}
+	global.GVA_LOG.Info("register table success")
+}
+
+//
+//@author: SliverHorn
+//@function: GormMysql
+//@description: 初始化Mysql数据库
+//@return: *gorm.DB
+
+func GormMysql() *gorm.DB {
+	m := global.GVA_CONFIG.Mysql
+	if m.Dbname == "" {
+		return nil
+	}
+	dsn := m.Username + ":" + m.Password + "@tcp(" + m.Path + ")/" + m.Dbname + "?" + m.Config
+	mysqlConfig := mysql.Config{
+		DSN:                       dsn,   // DSN data source name
+		DefaultStringSize:         191,   // string 类型字段的默认长度
+		DisableDatetimePrecision:  true,  // 禁用 datetime 精度，MySQL 5.6 之前的数据库不支持
+		DontSupportRenameIndex:    true,  // 重命名索引时采用删除并新建的方式，MySQL 5.7 之前的数据库和 MariaDB 不支持重命名索引
+		DontSupportRenameColumn:   true,  // 用 `change` 重命名列，MySQL 8 之前的数据库和 MariaDB 不支持重命名列
+		SkipInitializeWithVersion: false, // 根据版本自动配置
+	}
+	if db, err := gorm.Open(mysql.New(mysqlConfig), gormConfig(m.LogMode)); err != nil {
+		//global.GVA_LOG.Error("MySQL启动异常", zap.Any("err", err))
+		//os.Exit(0)
+		//return nil
+		return nil
+	} else {
+		sqlDB, _ := db.DB()
+		sqlDB.SetMaxIdleConns(m.MaxIdleConns)
+		sqlDB.SetMaxOpenConns(m.MaxOpenConns)
+		return db
+	}
+}
+
+//@author: SliverHorn
+//@function: gormConfig
+//@description: 根据配置决定是否开启日志
+//@param: mod bool
+//@return: *gorm.Config
+
+func gormConfig(mod bool) *gorm.Config {
+	var config = &gorm.Config{DisableForeignKeyConstraintWhenMigrating: true}
+	switch global.GVA_CONFIG.Mysql.LogZap {
+	case "silent", "Silent":
+		config.Logger = internal.Default.LogMode(logger.Silent)
+	case "error", "Error":
+		config.Logger = internal.Default.LogMode(logger.Error)
+	case "warn", "Warn":
+		config.Logger = internal.Default.LogMode(logger.Warn)
+	case "info", "Info":
+		config.Logger = internal.Default.LogMode(logger.Info)
+	case "zap", "Zap":
+		config.Logger = internal.Default.LogMode(logger.Info)
+	default:
+		if mod {
+			config.Logger = internal.Default.LogMode(logger.Info)
+			break
+		}
+		config.Logger = internal.Default.LogMode(logger.Silent)
+	}
+	return config
+}

initialize/internal/logger.go

+package internal
+
+import (
+	"context"
+	"fmt"
+	"gin-xdorg/global"
+	"go.uber.org/zap"
+	"gorm.io/gorm/logger"
+	"gorm.io/gorm/utils"
+	"io/ioutil"
+	"log"
+	"os"
+	"time"
+)
+
+// writer log writer interface
+type writer interface {
+	Printf(string, ...interface{})
+}
+
+type config struct {
+	SlowThreshold time.Duration
+	Colorful      bool
+	LogLevel      logger.LogLevel
+}
+
+var (
+	Discard = New(log.New(ioutil.Discard, "", log.LstdFlags), config{})
+	Default = New(log.New(os.Stdout, "\r\n", log.LstdFlags), config{
+		SlowThreshold: 200 * time.Millisecond,
+		LogLevel:      logger.Warn,
+		Colorful:      true,
+	})
+	Recorder = traceRecorder{Interface: Default, BeginAt: time.Now()}
+)
+
+func New(writer writer, config config) logger.Interface {
+	var (
+		infoStr      = "%s\n[info] "
+		warnStr      = "%s\n[warn] "
+		errStr       = "%s\n[error] "
+		traceStr     = "%s\n[%.3fms] [rows:%v] %s"
+		traceWarnStr = "%s %s\n[%.3fms] [rows:%v] %s"
+		traceErrStr  = "%s %s\n[%.3fms] [rows:%v] %s"
+	)
+
+	if config.Colorful {
+		infoStr = logger.Green + "%s\n" + logger.Reset + logger.Green + "[info] " + logger.Reset
+		warnStr = logger.BlueBold + "%s\n" + logger.Reset + logger.Magenta + "[warn] " + logger.Reset
+		errStr = logger.Magenta + "%s\n" + logger.Reset + logger.Red + "[error] " + logger.Reset
+		traceStr = logger.Green + "%s\n" + logger.Reset + logger.Yellow + "[%.3fms] " + logger.BlueBold + "[rows:%v]" + logger.Reset + " %s"
+		traceWarnStr = logger.Green + "%s " + logger.Yellow + "%s\n" + logger.Reset + logger.RedBold + "[%.3fms] " + logger.Yellow + "[rows:%v]" + logger.Magenta + " %s" + logger.Reset
+		traceErrStr = logger.RedBold + "%s " + logger.MagentaBold + "%s\n" + logger.Reset + logger.Yellow + "[%.3fms] " + logger.BlueBold + "[rows:%v]" + logger.Reset + " %s"
+	}
+
+	return &customLogger{
+		writer:       writer,
+		config:       config,
+		infoStr:      infoStr,
+		warnStr:      warnStr,
+		errStr:       errStr,
+		traceStr:     traceStr,
+		traceWarnStr: traceWarnStr,
+		traceErrStr:  traceErrStr,
+	}
+}
+
+type customLogger struct {
+	writer
+	config
+	infoStr, warnStr, errStr            string
+	traceStr, traceErrStr, traceWarnStr string
+}
+
+// LogMode log mode
+func (c *customLogger) LogMode(level logger.LogLevel) logger.Interface {
+	newLogger := *c
+	newLogger.LogLevel = level
+	return &newLogger
+}
+
+// Info print info
+func (c *customLogger) Info(ctx context.Context, message string, data ...interface{}) {
+	if c.LogLevel >= logger.Info {
+		c.Printf(c.infoStr+message, append([]interface{}{utils.FileWithLineNum()}, data...)...)
+	}
+}
+
+// Warn print warn messages
+func (c *customLogger) Warn(ctx context.Context, message string, data ...interface{}) {
+	if c.LogLevel >= logger.Warn {
+		c.Printf(c.warnStr+message, append([]interface{}{utils.FileWithLineNum()}, data...)...)
+	}
+}
+
+// Error print error messages
+func (c *customLogger) Error(ctx context.Context, message string, data ...interface{}) {
+	if c.LogLevel >= logger.Error {
+		c.Printf(c.errStr+message, append([]interface{}{utils.FileWithLineNum()}, data...)...)
+	}
+}
+
+// Trace print sql message
+func (c *customLogger) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
+	if c.LogLevel > 0 {
+		elapsed := time.Since(begin)
+		switch {
+		case err != nil && c.LogLevel >= logger.Error:
+			sql, rows := fc()
+			if rows == -1 {
+				c.Printf(c.traceErrStr, utils.FileWithLineNum(), err, float64(elapsed.Nanoseconds())/1e6, "-", sql)
+			} else {
+				c.Printf(c.traceErrStr, utils.FileWithLineNum(), err, float64(elapsed.Nanoseconds())/1e6, rows, sql)
+			}
+		case elapsed > c.SlowThreshold && c.SlowThreshold != 0 && c.LogLevel >= logger.Warn:
+			sql, rows := fc()
+			slowLog := fmt.Sprintf("SLOW SQL >= %v", c.SlowThreshold)
+			if rows == -1 {
+				c.Printf(c.traceWarnStr, utils.FileWithLineNum(), slowLog, float64(elapsed.Nanoseconds())/1e6, "-", sql)
+			} else {
+				c.Printf(c.traceWarnStr, utils.FileWithLineNum(), slowLog, float64(elapsed.Nanoseconds())/1e6, rows, sql)
+			}
+		case c.LogLevel >= logger.Info:
+			sql, rows := fc()
+			if rows == -1 {
+				c.Printf(c.traceStr, utils.FileWithLineNum(), float64(elapsed.Nanoseconds())/1e6, "-", sql)
+			} else {
+				c.Printf(c.traceStr, utils.FileWithLineNum(), float64(elapsed.Nanoseconds())/1e6, rows, sql)
+			}
+		}
+	}
+}
+
+func (c *customLogger) Printf(message string, data ...interface{}) {
+	if global.GVA_CONFIG.Mysql.LogZap != "" {
+		switch len(data) {
+		case 0:
+			global.GVA_LOG.Info(message)
+		case 1:
+			global.GVA_LOG.Info("gorm", zap.Any("src", data[0]))
+		case 2:
+			global.GVA_LOG.Info("gorm", zap.Any("src", data[0]), zap.Any("duration", data[1]))
+		case 3:
+			global.GVA_LOG.Info("gorm", zap.Any("src", data[0]), zap.Any("duration", data[1]), zap.Any("rows", data[2]))
+		case 4:
+			global.GVA_LOG.Info("gorm", zap.Any("src", data[0]), zap.Any("duration", data[1]), zap.Any("rows", data[2]), zap.Any("sql", data[3]))
+		}
+		return
+	}
+	switch len(data) {
+	case 0:
+		c.writer.Printf(message, "")
+	case 1:
+		c.writer.Printf(message, data[0])
+	case 2:
+		c.writer.Printf(message, data[0], data[1])
+	case 3:
+		c.writer.Printf(message, data[0], data[1], data[2])
+	case 4:
+		c.writer.Printf(message, data[0], data[1], data[2], data[3])
+	case 5:
+		c.writer.Printf(message, data[0], data[1], data[2], data[3], data[4])
+	}
+}
+
+type traceRecorder struct {
+	logger.Interface
+	BeginAt      time.Time
+	SQL          string
+	RowsAffected int64
+	Err          error
+}
+
+func (t traceRecorder) New() *traceRecorder {
+	return &traceRecorder{Interface: t.Interface, BeginAt: time.Now()}
+}
+
+func (t *traceRecorder) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
+	t.BeginAt = begin
+	t.SQL, t.RowsAffected = fc()
+	t.Err = err
+}

initialize/redis.go

+package initialize
+
+import (
+	"gin-xdorg/global"
+	"github.com/go-redis/redis"
+	"go.uber.org/zap"
+)
+
+func Redis() {
+	redisCfg := global.GVA_CONFIG.Redis
+	client := redis.NewClient(&redis.Options{
+		Addr:     redisCfg.Addr,
+		Password: redisCfg.Password, // no password set
+		DB:       redisCfg.DB,       // use default DB
+	})
+	pong, err := client.Ping().Result()
+	if err != nil {
+		global.GVA_LOG.Error("redis connect ping failed, err:", zap.Any("err", err))
+	} else {
+		global.GVA_LOG.Info("redis connect ping response:", zap.String("pong", pong))
+		global.GVA_REDIS = client
+	}
+}

initialize/router.go

+package initialize
+
+import (
+	_ "gin-xdorg/docs"
+	"gin-xdorg/global"
+	"gin-xdorg/middleware"
+	"gin-xdorg/router"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/swaggo/gin-swagger"
+	"github.com/swaggo/gin-swagger/swaggerFiles"
+)
+
+// 初始化总路由
+
+func Routers() *gin.Engine {
+	var Router = gin.Default()
+	Router.StaticFS(global.GVA_CONFIG.Local.Path, http.Dir(global.GVA_CONFIG.Local.Path)) // 为用户头像和文件提供静态地址
+	// Router.Use(middleware.LoadTls())  // 打开就能玩https了
+	global.GVA_LOG.Info("use middleware logger")
+	// 跨域
+	//Router.Use(middleware.Cors()) // 如需跨域可以打开
+	global.GVA_LOG.Info("use middleware cors")
+	Router.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
+	global.GVA_LOG.Info("register swagger handler")
+	// 方便统一添加路由组前缀 多服务器上线使用
+	PublicGroup := Router.Group("")
+	{
+		router.InitBaseRouter(PublicGroup) // 注册基础功能路由 不做鉴权
+		router.InitInitRouter(PublicGroup) // 自动初始化相关
+	}
+	PrivateGroup := Router.Group("")
+	PrivateGroup.Use(middleware.JWTAuth()).Use(middleware.CasbinHandler())
+	{
+		router.InitApiRouter(PrivateGroup)                   // 注册功能api路由
+		router.InitJwtRouter(PrivateGroup)                   // jwt相关路由
+		router.InitUserRouter(PrivateGroup)                  // 注册用户路由
+		router.InitMenuRouter(PrivateGroup)                  // 注册menu路由
+		router.InitEmailRouter(PrivateGroup)                 // 邮件相关路由
+		router.InitSystemRouter(PrivateGroup)                // system相关路由
+		router.InitCasbinRouter(PrivateGroup)                // 权限相关路由
+		router.InitCustomerRouter(PrivateGroup)              // 客户路由
+		router.InitAutoCodeRouter(PrivateGroup)              // 创建自动化代码
+		router.InitAuthorityRouter(PrivateGroup)             // 注册角色路由
+		router.InitSimpleUploaderRouter(PrivateGroup)        // 断点续传（插件版）
+		router.InitSysDictionaryRouter(PrivateGroup)         // 字典管理
+		router.InitSysOperationRecordRouter(PrivateGroup)    // 操作记录
+		router.InitSysDictionaryDetailRouter(PrivateGroup)   // 字典详情管理
+		router.InitFileUploadAndDownloadRouter(PrivateGroup) // 文件上传下载功能路由
+		router.InitExcelRouter(PrivateGroup)                 // 表格导入导出
+
+		// Code generated by gin-xdorg Begin; DO NOT EDIT.
+		// Code generated by gin-xdorg End; DO NOT EDIT.
+	}
+	global.GVA_LOG.Info("router register success")
+	return Router
+}

initialize/timer.go

+package initialize
+
+import (
+	"fmt"
+	"gin-xdorg/config"
+	"gin-xdorg/global"
+	"gin-xdorg/utils"
+)
+
+func Timer() {
+	if global.GVA_CONFIG.Timer.Start {
+		for _, detail := range global.GVA_CONFIG.Timer.Detail {
+			fmt.Println(detail)
+			go func(detail config.Detail) {
+				global.GVA_Timer.AddTaskByFunc("ClearDB", global.GVA_CONFIG.Timer.Spec, func() {
+					err := utils.ClearTable(global.GVA_DB, detail.TableName, detail.CompareField, detail.Interval)
+					if err != nil {
+						fmt.Println("timer error:", err)
+					}
+				})
+			}(detail)
+		}
+	}
+}

initialize/validator.go

+package initialize
+
+import "gin-xdorg/utils"
+
+func init() {
+	_ = utils.RegisterRule("PageVerify",
+		utils.Rules{
+			"Page":     {utils.NotEmpty()},
+			"PageSize": {utils.NotEmpty()},
+		},
+	)
+	_ = utils.RegisterRule("IdVerify",
+		utils.Rules{
+			"Id": {utils.NotEmpty()},
+		},
+	)
+	_ = utils.RegisterRule("AuthorityIdVerify",
+		utils.Rules{
+			"AuthorityId": {utils.NotEmpty()},
+		},
+	)
+}

log/2021-05-11.log

+[GIN-XDORG]2021/05/11 - 22:35:42.821	info	register table success
+[GIN-XDORG]2021/05/11 - 22:35:42.822	info	use middleware logger
+[GIN-XDORG]2021/05/11 - 22:35:42.823	info	use middleware cors
+[GIN-XDORG]2021/05/11 - 22:35:42.823	info	register swagger handler
+[GIN-XDORG]2021/05/11 - 22:35:42.833	info	router register success
+[GIN-XDORG]2021/05/11 - 22:35:42.834	info	server run success on 	{"address": ":8888"}

main.go

+package main
+
+import (
+	"gin-xdorg/core"
+	"gin-xdorg/global"
+	"gin-xdorg/initialize"
+)
+
+// @title Swagger Example API
+// @version 0.0.1
+// @description This is a sample Server pets
+// @securityDefinitions.apikey ApiKeyAuth
+// @in header
+// @name x-token
+// @BasePath /
+func main() {
+	global.GVA_VP = core.Viper()      // 初始化Viper
+	global.GVA_LOG = core.Zap()       // 初始化zap日志库
+	global.GVA_DB = initialize.Gorm() // gorm连接数据库
+	initialize.Timer()
+	if global.GVA_DB != nil {
+		initialize.MysqlTables(global.GVA_DB) // 初始化表
+		// 程序结束前关闭数据库链接
+		db, _ := global.GVA_DB.DB()
+		defer db.Close()
+	}
+	core.RunWindowsServer()
+}

middleware/casbin_rbac.go

+package middleware
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"github.com/gin-gonic/gin"
+)
+
+// 拦截器
+func CasbinHandler() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		claims, _ := c.Get("claims")
+		waitUse := claims.(*request.CustomClaims)
+		// 获取请求的URI
+		obj := c.Request.URL.RequestURI()
+		// 获取请求方法
+		act := c.Request.Method
+		// 获取用户的角色
+		sub := waitUse.AuthorityId
+		e := service.Casbin()
+		// 判断策略中是否存在
+		success, _ := e.Enforce(sub, obj, act)
+		if global.GVA_CONFIG.System.Env == "develop" || success {
+			c.Next()
+		} else {
+			response.FailWithDetailed(gin.H{}, "权限不足", c)
+			c.Abort()
+			return
+		}
+	}
+}

middleware/cors.go

+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+// 处理跨域请求,支持options访问
+func Cors() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		method := c.Request.Method
+		origin := c.Request.Header.Get("Origin")
+		c.Header("Access-Control-Allow-Origin", origin)
+		c.Header("Access-Control-Allow-Headers", "Content-Type,AccessToken,X-CSRF-Token, Authorization, Token,X-Token,X-User-Id")
+		c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS,DELETE,PUT")
+		c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type")
+		c.Header("Access-Control-Allow-Credentials", "true")
+
+		// 放行所有OPTIONS方法
+		if method == "OPTIONS" {
+			c.AbortWithStatus(http.StatusNoContent)
+		}
+		// 处理请求
+		c.Next()
+	}
+}

middleware/email.go

+package middleware
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/service"
+	"gin-xdorg/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"io/ioutil"
+	"strconv"
+	"time"
+)
+
+func ErrorToEmail() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var username string
+		if claims, ok := c.Get("claims"); ok {
+			waitUse := claims.(*request.CustomClaims)
+			username = waitUse.Username
+		} else {
+			id, _ := strconv.Atoi(c.Request.Header.Get("x-user-id"))
+			err, user := service.FindUserById(id)
+			if err != nil {
+				username = "Unknown"
+			}
+			username = user.Username
+		}
+		body, _ := ioutil.ReadAll(c.Request.Body)
+		record := model.SysOperationRecord{
+			Ip:     c.ClientIP(),
+			Method: c.Request.Method,
+			Path:   c.Request.URL.Path,
+			Agent:  c.Request.UserAgent(),
+			Body:   string(body),
+		}
+		now := time.Now()
+
+		c.Next()
+
+		latency := time.Now().Sub(now)
+		status := c.Writer.Status()
+		record.ErrorMessage = c.Errors.ByType(gin.ErrorTypePrivate).String()
+		str := "接收到的请求为" + record.Body + "\n" + "请求方式为" + record.Method + "\n" + "报错信息如下" + record.ErrorMessage + "\n" + "耗时" + latency.String() + "\n"
+		if status != 200 {
+			subject := username + "" + record.Ip + "调用了" + record.Path + "报错了"
+			if err := utils.ErrorToEmail(subject, str); err != nil {
+				global.GVA_LOG.Error("ErrorToEmail Failed, err:", zap.Any("err", err))
+			}
+		}
+	}
+}

middleware/error.go

+package middleware
+
+import (
+	"gin-xdorg/global"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"os"
+	"runtime/debug"
+	"strings"
+)
+
+// GinRecovery recover掉项目可能出现的panic，并使用zap记录相关日志
+func GinRecovery(stack bool) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		defer func() {
+			if err := recover(); err != nil {
+				// Check for a broken connection, as it is not really a
+				// condition that warrants a panic stack trace.
+				var brokenPipe bool
+				if ne, ok := err.(*net.OpError); ok {
+					if se, ok := ne.Err.(*os.SyscallError); ok {
+						if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
+							brokenPipe = true
+						}
+					}
+				}
+
+				httpRequest, _ := httputil.DumpRequest(c.Request, false)
+				if brokenPipe {
+					global.GVA_LOG.Error(c.Request.URL.Path,
+						zap.Any("error", err),
+						zap.String("request", string(httpRequest)),
+					)
+					// If the connection is dead, we can't write a status to it.
+					_ = c.Error(err.(error)) // nolint: errcheck
+					c.Abort()
+					return
+				}
+
+				if stack {
+					global.GVA_LOG.Error("[Recovery from panic]",
+						zap.Any("error", err),
+						zap.String("request", string(httpRequest)),
+						zap.String("stack", string(debug.Stack())),
+					)
+				} else {
+					global.GVA_LOG.Error("[Recovery from panic]",
+						zap.Any("error", err),
+						zap.String("request", string(httpRequest)),
+					)
+				}
+				c.AbortWithStatus(http.StatusInternalServerError)
+			}
+		}()
+		c.Next()
+	}
+}

middleware/jwt.go

+package middleware
+
+import (
+	"errors"
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/model/response"
+	"gin-xdorg/service"
+	"github.com/dgrijalva/jwt-go"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"strconv"
+	"time"
+)
+
+func JWTAuth() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 我们这里jwt鉴权取头部信息 x-token 登录时回返回token信息 这里前端需要把token存储到cookie或者本地localStorage中 不过需要跟后端协商过期时间 可以约定刷新令牌或者重新登录
+		token := c.Request.Header.Get("x-token")
+		if token == "" {
+			response.FailWithDetailed(gin.H{"reload": true}, "未登录或非法访问", c)
+			c.Abort()
+			return
+		}
+		if service.IsBlacklist(token) {
+			response.FailWithDetailed(gin.H{"reload": true}, "您的帐户异地登陆或令牌失效", c)
+			c.Abort()
+			return
+		}
+		j := NewJWT()
+		// parseToken 解析token包含的信息
+		claims, err := j.ParseToken(token)
+		if err != nil {
+			if err == TokenExpired {
+				response.FailWithDetailed(gin.H{"reload": true}, "授权已过期", c)
+				c.Abort()
+				return
+			}
+			response.FailWithDetailed(gin.H{"reload": true}, err.Error(), c)
+			c.Abort()
+			return
+		}
+		if err, _ = service.FindUserByUuid(claims.UUID.String()); err != nil {
+			_ = service.JsonInBlacklist(model.JwtBlacklist{Jwt: token})
+			response.FailWithDetailed(gin.H{"reload": true}, err.Error(), c)
+			c.Abort()
+		}
+		if claims.ExpiresAt-time.Now().Unix() < claims.BufferTime {
+			claims.ExpiresAt = time.Now().Unix() + global.GVA_CONFIG.JWT.ExpiresTime
+			newToken, _ := j.CreateToken(*claims)
+			newClaims, _ := j.ParseToken(newToken)
+			c.Header("new-token", newToken)
+			c.Header("new-expires-at", strconv.FormatInt(newClaims.ExpiresAt, 10))
+			if global.GVA_CONFIG.System.UseMultipoint {
+				err, RedisJwtToken := service.GetRedisJWT(newClaims.Username)
+				if err != nil {
+					global.GVA_LOG.Error("get redis jwt failed", zap.Any("err", err))
+				} else { // 当之前的取成功时才进行拉黑操作
+					_ = service.JsonInBlacklist(model.JwtBlacklist{Jwt: RedisJwtToken})
+				}
+				// 无论如何都要记录当前的活跃状态
+				_ = service.SetRedisJWT(newToken, newClaims.Username)
+			}
+		}
+		c.Set("claims", claims)
+		c.Next()
+	}
+}
+
+type JWT struct {
+	SigningKey []byte
+}
+
+var (
+	TokenExpired     = errors.New("Token is expired")
+	TokenNotValidYet = errors.New("Token not active yet")
+	TokenMalformed   = errors.New("That's not even a token")
+	TokenInvalid     = errors.New("Couldn't handle this token:")
+)
+
+func NewJWT() *JWT {
+	return &JWT{
+		[]byte(global.GVA_CONFIG.JWT.SigningKey),
+	}
+}
+
+// 创建一个token
+func (j *JWT) CreateToken(claims request.CustomClaims) (string, error) {
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString(j.SigningKey)
+}
+
+// 解析 token
+func (j *JWT) ParseToken(tokenString string) (*request.CustomClaims, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &request.CustomClaims{}, func(token *jwt.Token) (i interface{}, e error) {
+		return j.SigningKey, nil
+	})
+	if err != nil {
+		if ve, ok := err.(*jwt.ValidationError); ok {
+			if ve.Errors&jwt.ValidationErrorMalformed != 0 {
+				return nil, TokenMalformed
+			} else if ve.Errors&jwt.ValidationErrorExpired != 0 {
+				// Token is expired
+				return nil, TokenExpired
+			} else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 {
+				return nil, TokenNotValidYet
+			} else {
+				return nil, TokenInvalid
+			}
+		}
+	}
+	if token != nil {
+		if claims, ok := token.Claims.(*request.CustomClaims); ok && token.Valid {
+			return claims, nil
+		}
+		return nil, TokenInvalid
+
+	} else {
+		return nil, TokenInvalid
+
+	}
+
+}
+
+// 更新token
+//func (j *JWT) RefreshToken(tokenString string) (string, error) {
+//	jwt.TimeFunc = func() time.Time {
+//		return time.Unix(0, 0)
+//	}
+//	token, err := jwt.ParseWithClaims(tokenString, &request.CustomClaims{}, func(token *jwt.Token) (interface{}, error) {
+//		return j.SigningKey, nil
+//	})
+//	if err != nil {
+//		return "", err
+//	}
+//	if claims, ok := token.Claims.(*request.CustomClaims); ok && token.Valid {
+//		jwt.TimeFunc = time.Now
+//		claims.StandardClaims.ExpiresAt = time.Now().Unix() + 60*60*24*7
+//		return j.CreateToken(*claims)
+//	}
+//	return "", TokenInvalid
+//}

middleware/loadtls.go

+package middleware
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/unrolled/secure"
+)
+
+// 用https把这个中间件在router里面use一下就好
+
+func LoadTls() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		middleware := secure.New(secure.Options{
+			SSLRedirect: true,
+			SSLHost:     "localhost:443",
+		})
+		err := middleware.Process(c.Writer, c.Request)
+		if err != nil {
+			// 如果出现错误，请不要继续
+			fmt.Println(err)
+			return
+		}
+		// 继续往下处理
+		c.Next()
+	}
+}

middleware/need_init.go

+package middleware
+
+import (
+	"gin-xdorg/global"
+	"gin-xdorg/model/response"
+	"github.com/gin-gonic/gin"
+)
+
+// 处理跨域请求,支持options访问
+func NeedInit() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if global.GVA_DB == nil {
+			response.OkWithDetailed(gin.H{
+				"needInit": true,
+			}, "前往初始化数据库", c)
+			c.Abort()
+		} else {
+			c.Next()
+		}
+		// 处理请求
+	}
+}

middleware/operation.go

+package middleware
+
+import (
+	"bytes"
+	"gin-xdorg/global"
+	"gin-xdorg/model"
+	"gin-xdorg/model/request"
+	"gin-xdorg/service"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+func OperationRecord() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var body []byte
+		var userId int
+		if c.Request.Method != http.MethodGet {
+			var err error
+			body, err = ioutil.ReadAll(c.Request.Body)
+			if err != nil {
+				global.GVA_LOG.Error("read body from request error:", zap.Any("err", err))
+			} else {
+				c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(body))
+			}
+		}
+		if claims, ok := c.Get("claims"); ok {
+			waitUse := claims.(*request.CustomClaims)
+			userId = int(waitUse.ID)
+		} else {
+			id, err := strconv.Atoi(c.Request.Header.Get("x-user-id"))
+			if err != nil {
+				userId = 0
+			}
+			userId = id
+		}
+		record := model.SysOperationRecord{
+			Ip:     c.ClientIP(),
+			Method: c.Request.Method,
+			Path:   c.Request.URL.Path,
+			Agent:  c.Request.UserAgent(),
+			Body:   string(body),
+			UserID: userId,
+		}
+		// 存在某些未知错误 TODO
+		//values := c.Request.Header.Values("content-type")
+		//if len(values) >0 && strings.Contains(values[0], "boundary") {
+		//	record.Body = "file"
+		//}
+		writer := responseBodyWriter{
+			ResponseWriter: c.Writer,
+			body:           &bytes.Buffer{},
+		}
+		c.Writer = writer
+		now := time.Now()
+
+		c.Next()
+
+		latency := time.Now().Sub(now)
+		record.ErrorMessage = c.Errors.ByType(gin.ErrorTypePrivate).String()
+		record.Status = c.Writer.Status()
+		record.Latency = latency
+		record.Resp = writer.body.String()
+
+		if err := service.CreateSysOperationRecord(record); err != nil {
+			global.GVA_LOG.Error("create operation record error:", zap.Any("err", err))
+		}
+	}
+}
+
+type responseBodyWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+func (r responseBodyWriter) Write(b []byte) (int, error) {
+	r.body.Write(b)
+	return r.ResponseWriter.Write(b)
+}

model/exa_breakpoint_continue.go

+package model
+
+import (
+	"gin-xdorg/global"
+)
+
+// file struct, 文件结构体
+type ExaFile struct {
+	global.GVA_MODEL
+	FileName     string
+	FileMd5      string
+	FilePath     string
+	ExaFileChunk []ExaFileChunk
+	ChunkTotal   int
+	IsFinish     bool
+}
+
+// file chunk struct, 切片结构体
+type ExaFileChunk struct {
+	global.GVA_MODEL
+	ExaFileID       uint
+	FileChunkNumber int
+	FileChunkPath   string
+}

model/exa_customer.go

+package model
+
+import (
+	"gin-xdorg/global"
+)
+
+type ExaCustomer struct {
+	global.GVA_MODEL
+	CustomerName       string  `json:"customerName" form:"customerName" gorm:"comment:客户名"`                // 客户名
+	CustomerPhoneData  string  `json:"customerPhoneData" form:"customerPhoneData" gorm:"comment:客户手机号"`    // 客户手机号
+	SysUserID          uint    `json:"sysUserId" form:"sysUserId" gorm:"comment:管理ID"`                     // 管理ID
+	SysUserAuthorityID string  `json:"sysUserAuthorityID" form:"sysUserAuthorityID" gorm:"comment:管理角色ID"` // 管理角色ID
+	SysUser            SysUser `json:"sysUser" form:"sysUser" gorm:"comment:管理详情"`                         // 管理详情
+}

model/exa_excel.go

+package model
+
+type ExcelInfo struct {
+	FileName string        `json:"fileName"` // 文件名
+	InfoList []SysBaseMenu `json:"infoList"`
+}

model/exa_file_upload_download.go

+package model
+
+import (
+	"gin-xdorg/global"
+)
+
+type ExaFileUploadAndDownload struct {
+	global.GVA_MODEL
+	Name string `json:"name" gorm:"comment:文件名"` // 文件名
+	Url  string `json:"url" gorm:"comment:文件地址"` // 文件地址
+	Tag  string `json:"tag" gorm:"comment:文件标签"` // 文件标签
+	Key  string `json:"key" gorm:"comment:编号"`   // 编号
+}

model/exa_simple_uploader.go

+package model
+
+type ExaSimpleUploader struct {
+	ChunkNumber      string `json:"chunkNumber" gorm:"comment:当前切片标记"`
+	CurrentChunkSize string `json:"currentChunkSize" gorm:"comment:当前切片容量"`
+	CurrentChunkPath string `json:"currentChunkPath" gorm:"comment:切片本地路径"`
+	TotalSize        string `json:"totalSize" gorm:"comment:总容量"`
+	Identifier       string `json:"identifier" gorm:"comment:文件标识（md5）"`
+	Filename         string `json:"filename" gorm:"comment:文件名"`
+	TotalChunks      string `json:"totalChunks" gorm:"comment:切片总数"`
+	IsDone           bool   `json:"isDone" gorm:"comment:是否上传完成"`
+	FilePath         string `json:"filePath" gorm:"comment:文件本地路径"`
+}

model/request/common.go

+package request
+
+// Paging common input parameter structure
+type PageInfo struct {
+	Page     int `json:"page" form:"page"`         // 页码
+	PageSize int `json:"pageSize" form:"pageSize"` // 每页大小
+}
+
+// Find by id structure
+type GetById struct {
+	ID float64 `json:"id" form:"id"`
+}
+
+type IdsReq struct {
+	Ids []int `json:"ids" form:"ids"`
+}
+
+// Get role by id structure
+type GetAuthorityId struct {
+	AuthorityId string // 角色ID
+}
+
+type Empty struct{}

model/request/jwt.go

+package request
+
+import (
+	"github.com/dgrijalva/jwt-go"
+	uuid "github.com/satori/go.uuid"
+)
+
+// Custom claims structure
+type CustomClaims struct {
+	UUID        uuid.UUID
+	ID          uint
+	Username    string
+	NickName    string
+	AuthorityId string
+	BufferTime  int64
+	jwt.StandardClaims
+}

model/request/sys_api.go

+package request
+
+import "gin-xdorg/model"
+
+// api分页条件查询及排序结构体
+type SearchApiParams struct {
+	model.SysApi
+	PageInfo
+	OrderKey string `json:"orderKey"` // 排序
+	Desc     bool   `json:"desc"`     // 排序方式:升序false(默认)|降序true
+}

model/request/sys_autocode.go

+package request
+
+type DBReq struct {
+	Database string `json:"database" gorm:"column:database"`
+}
+
+type TableReq struct {
+	TableName string `json:"tableName"`
+}
+
+type ColumnReq struct {
+	ColumnName    string `json:"columnName" gorm:"column:column_name"`
+	DataType      string `json:"dataType" gorm:"column:data_type"`
+	DataTypeLong  string `json:"dataTypeLong" gorm:"column:data_type_long"`
+	ColumnComment string `json:"columnComment" gorm:"column:column_comment"`
+}

model/request/sys_casbin.go

+package request
+
+// Casbin info structure
+type CasbinInfo struct {
+	Path   string `json:"path"`   // 路径
+	Method string `json:"method"` // 方法
+}
+
+// Casbin structure for input parameters
+type CasbinInReceive struct {
+	AuthorityId string       `json:"authorityId"` // 权限id
+	CasbinInfos []CasbinInfo `json:"casbinInfos"`
+}

model/request/sys_dictionary.go

+package request
+
+import "gin-xdorg/model"
+
+type SysDictionarySearch struct {
+	model.SysDictionary
+	PageInfo
+}

model/request/sys_dictionary_detail.go

+package request
+
+import "gin-xdorg/model"
+
+type SysDictionaryDetailSearch struct {
+	model.SysDictionaryDetail
+	PageInfo
+}

model/request/sys_init.go

+package request
+
+type InitDB struct {
+	Host     string `json:"host"`                        // 服务器地址
+	Port     string `json:"port"`                        // 数据库连接端口
+	UserName string `json:"userName" binding:"required"` // 数据库用户名
+	Password string `json:"password"`                    // 数据库密码
+	DBName   string `json:"dbName" binding:"required"`   // 数据库名
+}

model/request/sys_menu.go

+package request
+
+import "gin-xdorg/model"
+
+// Add menu authority info structure
+type AddMenuAuthorityInfo struct {
+	Menus       []model.SysBaseMenu
+	AuthorityId string // 角色ID
+}

model/request/sys_operation_record.go

+package request
+
+import "gin-xdorg/model"
+
+type SysOperationRecordSearch struct {
+	model.SysOperationRecord
+	PageInfo
+}

model/request/sys_user.go

+package request
+
+import uuid "github.com/satori/go.uuid"
+
+// User register structure
+type Register struct {
+	Username    string `json:"userName"`
+	Password    string `json:"passWord"`
+	NickName    string `json:"nickName" gorm:"default:'QMPlusUser'"`
+	HeaderImg   string `json:"headerImg" gorm:"default:'http://www.henrongyi.top/avatar/lufu.jpg'"`
+	AuthorityId string `json:"authorityId" gorm:"default:888"`
+}
+
+// User login structure
+type Login struct {
+	Username  string `json:"username"`  // 用户名
+	Password  string `json:"password"`  // 密码
+	Captcha   string `json:"captcha"`   // 验证码
+	CaptchaId string `json:"captchaId"` // 验证码ID
+}
+
+// Modify password structure
+type ChangePasswordStruct struct {
+	Username    string `json:"username"`    // 用户名
+	Password    string `json:"password"`    // 密码
+	NewPassword string `json:"newPassword"` // 新密码
+}
+
+// Modify  user's auth structure
+type SetUserAuth struct {
+	UUID        uuid.UUID `json:"uuid"`        // 用户UUID
+	AuthorityId string    `json:"authorityId"` // 角色ID
+}

model/response/common.go

+package response
+
+type PageResult struct {
+	List     interface{} `json:"list"`
+	Total    int64       `json:"total"`
+	Page     int         `json:"page"`
+	PageSize int         `json:"pageSize"`
+}

model/response/exa_breakpoint_continue.go

+package response
+
+import "gin-xdorg/model"
+
+type FilePathResponse struct {
+	FilePath string `json:"filePath"`
+}
+
+type FileResponse struct {
+	File model.ExaFile `json:"file"`
+}

model/response/exa_customer.go

+package response
+
+import "gin-xdorg/model"
+
+type ExaCustomerResponse struct {
+	Customer model.ExaCustomer `json:"customer"`
+}

model/response/exa_file_upload_download.go

+package response
+
+import "gin-xdorg/model"
+
+type ExaFileResponse struct {
+	File model.ExaFileUploadAndDownload `json:"file"`
+}

model/response/response.go

+package response
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type Response struct {
+	Code int         `json:"code"`
+	Data interface{} `json:"data"`
+	Msg  string      `json:"msg"`
+}
+
+const (
+	ERROR   = 7
+	SUCCESS = 0
+)
+
+func Result(code int, data interface{}, msg string, c *gin.Context) {
+	// 开始时间
+	c.JSON(http.StatusOK, Response{
+		code,
+		data,
+		msg,
+	})
+}
+
+func Ok(c *gin.Context) {
+	Result(SUCCESS, map[string]interface{}{}, "操作成功", c)
+}
+
+func OkWithMessage(message string, c *gin.Context) {
+	Result(SUCCESS, map[string]interface{}{}, message, c)
+}
+
+func OkWithData(data interface{}, c *gin.Context) {
+	Result(SUCCESS, data, "操作成功", c)
+}
+
+func OkWithDetailed(data interface{}, message string, c *gin.Context) {
+	Result(SUCCESS, data, message, c)
+}
+
+func Fail(c *gin.Context) {
+	Result(ERROR, map[string]interface{}{}, "操作失败", c)
+}
+
+func FailWithMessage(message string, c *gin.Context) {
+	Result(ERROR, map[string]interface{}{}, message, c)
+}
+
+func FailWithDetailed(data interface{}, message string, c *gin.Context) {
+	Result(ERROR, data, message, c)
+}

model/response/sys_api.go

+package response
+
+import "gin-xdorg/model"
+
+type SysAPIResponse struct {
+	Api model.SysApi `json:"api"`
+}
+
+type SysAPIListResponse struct {
+	Apis []model.SysApi `json:"apis"`
+}

model/response/sys_authority.go

+package response
+
+import "gin-xdorg/model"
+
+type SysAuthorityResponse struct {
+	Authority model.SysAuthority `json:"authority"`
+}
+
+type SysAuthorityCopyResponse struct {
+	Authority      model.SysAuthority `json:"authority"`
+	OldAuthorityId string             `json:"oldAuthorityId"`
+}

model/response/sys_captcha.go

+package response
+
+type SysCaptchaResponse struct {
+	CaptchaId string `json:"captchaId"`
+	PicPath   string `json:"picPath"`
+}

model/response/sys_casbin.go

+package response
+
+import "gin-xdorg/model/request"
+
+type PolicyPathResponse struct {
+	Paths []request.CasbinInfo `json:"paths"`
+}

model/response/sys_menu.go

+package response
+
+import "gin-xdorg/model"
+
+type SysMenusResponse struct {
+	Menus []model.SysMenu `json:"menus"`
+}
+
+type SysBaseMenusResponse struct {
+	Menus []model.SysBaseMenu `json:"menus"`
+}
+
+type SysBaseMenuResponse struct {
+	Menu model.SysBaseMenu `json:"menu"`
+}

model/response/sys_system.go

+package response
+
+import "gin-xdorg/config"
+
+type SysConfigResponse struct {
+	Config config.Server `json:"config"`
+}

model/response/sys_user.go

+package response
+
+import (
+	"gin-xdorg/model"
+)
+
+type SysUserResponse struct {
+	User model.SysUser `json:"user"`
+}
+
+type LoginResponse struct {
+	User      model.SysUser `json:"user"`
+	Token     string        `json:"token"`
+	ExpiresAt int64         `json:"expiresAt"`
+}

model/sys_api.go

+package model
+
+import (
+	"gin-xdorg/global"
+)
+
+type SysApi struct {
+	global.GVA_MODEL
+	Path        string `json:"path" gorm:"comment:api路径"`                    // api路径
+	Description string `json:"description" gorm:"comment:api中文描述"`           // api中文描述
+	ApiGroup    string `json:"apiGroup" gorm:"comment:api组"`                 // api组
+	Method      string `json:"method" gorm:"default:POST" gorm:"comment:方法"` // 方法:创建POST(默认)|查看GET|更新PUT|删除DELETE
+}

model/sys_authority.go

+package model
+
+import (
+	"time"
+)
+
+type SysAuthority struct {
+	CreatedAt       time.Time
+	UpdatedAt       time.Time
+	DeletedAt       *time.Time     `sql:"index"`
+	AuthorityId     string         `json:"authorityId" gorm:"not null;unique;primary_key;comment:角色ID;size:90"` // 角色ID
+	AuthorityName   string         `json:"authorityName" gorm:"comment:角色名"` // 角色名
+	ParentId        string         `json:"parentId" gorm:"comment:父角色ID"` // 父角色ID
+	DataAuthorityId []SysAuthority `json:"dataAuthorityId" gorm:"many2many:sys_data_authority_id"`
+	Children        []SysAuthority `json:"children" gorm:"-"`
+	SysBaseMenus    []SysBaseMenu  `json:"menus" gorm:"many2many:sys_authority_menus;"`
+	DefaultRouter   string         `json:"defaultRouter" gorm:"comment:默认菜单;default:dashboard"` // 默认菜单(默认dashboard)
+}

model/sys_authority_menu.go

+package model
+
+type SysMenu struct {
+	SysBaseMenu
+	MenuId      string                 `json:"menuId" gorm:"comment:菜单ID"`
+	AuthorityId string                 `json:"-" gorm:"comment:角色ID"`
+	Children    []SysMenu              `json:"children" gorm:"-"`
+	Parameters  []SysBaseMenuParameter `json:"parameters" gorm:"foreignKey:SysBaseMenuID;references:MenuId"`
+}
+
+func (s SysMenu) TableName() string {
+	return "authority_menu"
+}

model/sys_auto_code.go

+package model
+
+import "errors"
+
+// 初始版本自动化代码工具
+type AutoCodeStruct struct {
+	StructName         string   `json:"structName"`         // Struct名称
+	TableName          string   `json:"tableName"`          // 表名
+	PackageName        string   `json:"packageName"`        // 文件名称
+	Abbreviation       string   `json:"abbreviation"`       // Struct简称
+	Description        string   `json:"description"`        // Struct中文名称
+	AutoCreateApiToSql bool     `json:"autoCreateApiToSql"` // 是否自动创建api
+	AutoMoveFile       bool     `json:"autoMoveFile"`       // 是否自动移动文件
+	Fields             []*Field `json:"fields"`
+}
+
+type Field struct {
+	FieldName       string `json:"fieldName"`       // Field名
+	FieldDesc       string `json:"fieldDesc"`       // 中文名
+	FieldType       string `json:"fieldType"`       // Field数据类型
+	FieldJson       string `json:"fieldJson"`       // FieldJson
+	DataType        string `json:"dataType"`        // 数据库字段类型
+	DataTypeLong    string `json:"dataTypeLong"`    // 数据库字段长度
+	Comment         string `json:"comment"`         // 数据库字段描述
+	ColumnName      string `json:"columnName"`      // 数据库字段
+	FieldSearchType string `json:"fieldSearchType"` // 搜索条件
+	DictType        string `json:"dictType"`        // 字典
+}
+
+var AutoMoveErr error = errors.New("创建代码成功并移动文件成功")

model/sys_base_menu.go

+package model
+
+import (
+	"gin-xdorg/global"
+)
+
+type SysBaseMenu struct {
+	global.GVA_MODEL
+	MenuLevel     uint                   `json:"-"`
+	ParentId      string                 `json:"parentId" gorm:"comment:父菜单ID"`     // 父菜单ID
+	Path          string                 `json:"path" gorm:"comment:路由path"`        // 路由path
+	Name          string                 `json:"name" gorm:"comment:路由name"`        // 路由name
+	Hidden        bool                   `json:"hidden" gorm:"comment:是否在列表隐藏"`     // 是否在列表隐藏
+	Component     string                 `json:"component" gorm:"comment:对应前端文件路径"` // 对应前端文件路径
+	Sort          int                    `json:"sort" gorm:"comment:排序标记"`          // 排序标记
+	Meta          `json:"meta" gorm:"comment:附加属性"`                                 // 附加属性
+	SysAuthoritys []SysAuthority         `json:"authoritys" gorm:"many2many:sys_authority_menus;"`
+	Children      []SysBaseMenu          `json:"children" gorm:"-"`
+	Parameters    []SysBaseMenuParameter `json:"parameters"`
+}
+
+type Meta struct {
+	KeepAlive   bool   `json:"keepAlive" gorm:"comment:是否缓存"`           // 是否缓存
+	DefaultMenu bool   `json:"defaultMenu" gorm:"comment:是否是基础路由（开发中）"` // 是否是基础路由（开发中）
+	Title       string `json:"title" gorm:"comment:菜单名"`                // 菜单名
+	Icon        string `json:"icon" gorm:"comment:菜单图标"`                // 菜单图标
+	CloseTab    bool   `json:"closeTab" gorm:"comment:自动关闭tab"`         // 自动关闭tab
+}
+
+type SysBaseMenuParameter struct {
+	global.GVA_MODEL
+	SysBaseMenuID uint
+	Type          string `json:"type" gorm:"comment:地址栏携带参数为params还是query"` // 地址栏携带参数为params还是query
+	Key           string `json:"key" gorm:"comment:地址栏携带参数的key"`            // 地址栏携带参数的key
+	Value         string `json:"value" gorm:"comment:地址栏携带参数的值"`            // 地址栏携带参数的值
+}

model/sys_casbin.go

+package model
+
+type CasbinModel struct {
+	Ptype       string `json:"ptype" gorm:"column:ptype"`
+	AuthorityId string `json:"rolename" gorm:"column:v0"`
+	Path        string `json:"path" gorm:"column:v1"`
+	Method      string `json:"method" gorm:"column:v2"`
+}

model/sys_dictionary.go

+// 自动生成模板SysDictionary
+package model
+
+import (
+	"gin-xdorg/global"
+)
+
+// 如果含有time.Time 请自行import time包
+type SysDictionary struct {
+	global.GVA_MODEL
+	Name                 string                `json:"name" form:"name" gorm:"column:name;comment:字典名（中）"`   // 字典名（中）
+	Type                 string                `json:"type" form:"type" gorm:"column:type;comment:字典名（英）"`   // 字典名（英）
+	Status               *bool                 `json:"status" form:"status" gorm:"column:status;comment:状态"` // 状态
+	Desc                 string                `json:"desc" form:"desc" gorm:"column:desc;comment:描述"`       // 描述
+	SysDictionaryDetails []SysDictionaryDetail `json:"sysDictionaryDetails" form:"sysDictionaryDetails"`
+}

model/sys_dictionary_detail.go

+// 自动生成模板SysDictionaryDetail
+package model
+
+import (
+	"gin-xdorg/global"
+)
+
+// 如果含有time.Time 请自行import time包
+type SysDictionaryDetail struct {
+	global.GVA_MODEL
+	Label           string `json:"label" form:"label" gorm:"column:label;comment:展示值"`                                  // 展示值
+	Value           int    `json:"value" form:"value" gorm:"column:value;comment:字典值"`                                  // 字典值
+	Status          *bool  `json:"status" form:"status" gorm:"column:status;comment:启用状态"`                              // 启用状态
+	Sort            int    `json:"sort" form:"sort" gorm:"column:sort;comment:排序标记"`                                    // 排序标记
+	SysDictionaryID int    `json:"sysDictionaryID" form:"sysDictionaryID" gorm:"column:sys_dictionary_id;comment:关联标记"` // 关联标记
+}

model/sys_initdb.go

+package model
+
+type InitDBFunc interface {
+	Init() (err error)
+}

model/sys_jwt_blacklist.go

+package model
+
+import (
+	"gin-xdorg/global"
+)
+
+type JwtBlacklist struct {
+	global.GVA_MODEL
+	Jwt string `gorm:"type:text;comment:jwt"`
+}