EasyGoAdmin_Gin_EleVue-3

思考并回答以下问题：

router

router/router.go

/**
 * 系统路由
 * @File : router
 */
package router

import (
    "easygoadmin/app/controller"
    "easygoadmin/app/middleware"
    "fmt"
    "github.com/gin-gonic/gin"
    "html/template"
    "time"
)

// 日期格式转换
func formatAsDate(t time.Time) string {
    year, month, day := t.Date()
    return fmt.Sprintf("%d-%d-%d", year, month, day)
}

func init() {
    fmt.Println("路由已加载")
    // 初始化
    router := gin.Default()
    //// 自定义标识符，因为默认{{}}这种标识在前端框架中也有使用，会产生冲突
    //// 注意：改完标识符之后别忘了把模板里原先的标识符一起改掉
    //router.Delims("{[", "]}")

    // 自定义模板方法
    router.SetFuncMap(template.FuncMap{
        "formatAsDate": formatAsDate,
    })
    //// 指定模板加载目录
    //router.LoadHTMLGlob("views/**")
    // 跨域处理(要在路由组之前全局使用「跨域中间件」, 否则OPTIONS会返回404)
    router.Use(middleware.Cros())
    // 登录验证中间件
    router.Use(middleware.CheckLogin())
    // 鉴权拦截器中间件
    router.Use(middleware.CheckAuth())

    //// 验证登录后放行路由请求
    //router.Use(middleware.CheckLogin())
    //{
    //  // 写路由
    //}

    // 设置静态资源路由
    router.Static("/resource", "./public/resource")
    router.StaticFile("/favicon.ico", "./public/resource/images/favicon.ico")

    /* 文件上传 */
    upload := router.Group("upload")
    {
        // 上传图片
        upload.POST("/uploadImage", controller.Upload.UploadImage)
    }

    // 登录注册
    login := router.Group("/")
    {
        login.GET("/", controller.Login.Login)
        login.GET("/captcha", controller.Login.Captcha)
        login.POST("/login", controller.Login.Login)
        login.Any("/updateUserInfo", controller.Index.UpdateUserInfo)
        login.Any("/updatePwd", controller.Index.UpdatePwd)
        login.GET("/logout", controller.Index.Logout)
    }

    // 系统主页
    index := router.Group("index")
    {
        index.GET("/menu", controller.Index.Menu)
        index.GET("/user", controller.Index.User)
    }

    /* 用户管理 */
    user := router.Group("user")
    {
        user.GET("/list", controller.User.List)
        user.GET("/detail/:id", controller.User.Detail)
        user.POST("/add", controller.User.Add)
        user.PUT("/update", controller.User.Update)
        user.DELETE("/delete/:ids", controller.User.Delete)
        user.PUT("/status", controller.User.Status)
        user.PUT("/resetPwd", controller.User.ResetPwd)
        user.GET("/checkUser", controller.User.CheckUser)
    }

    /* 职级管理 */
    level := router.Group("level")
    {
        level.GET("/list", controller.Level.List)
        level.POST("/add", controller.Level.Add)
        level.PUT("/update", controller.Level.Update)
        level.DELETE("/delete/:ids", controller.Level.Delete)
        level.PUT("/status", controller.Level.Status)
        level.GET("/getLevelList", controller.Level.GetLevelList)
        level.GET("/exportExcel", controller.Level.ExportExcel)
        level.POST("/importExcel", controller.Level.ImportExcel)
        level.GET("/downloadExcel", controller.Level.DownloadExcel)
    }

    /* 岗位管理 */
    position := router.Group("position")
    {
        position.GET("/list", controller.Position.List)
        position.POST("/add", controller.Position.Add)
        position.PUT("/update", controller.Position.Update)
        position.DELETE("/delete/:ids", controller.Position.Delete)
        position.PUT("/status", controller.Position.Status)
        position.GET("/getPositionList", controller.Position.GetPositionList)
    }

    /* 部门管理 */
    dept := router.Group("dept")
    {
        dept.GET("/list", controller.Dept.List)
        dept.POST("/add", controller.Dept.Add)
        dept.PUT("/update", controller.Dept.Update)
        dept.DELETE("/delete/:ids", controller.Dept.Delete)
        dept.GET("/getDeptList", controller.Dept.GetDeptList)
    }

    /* 菜单管理 */
    menu := router.Group("menu")
    {
        menu.GET("/list", controller.Menu.List)
        menu.GET("/detail", controller.Menu.Detail)
        menu.POST("/add", controller.Menu.Add)
        menu.PUT("/update", controller.Menu.Update)
        menu.DELETE("/delete/:ids", controller.Menu.Delete)
    }

    /* 角色路由 */
    role := router.Group("role")
    {
        role.GET("/list", controller.Role.List)
        role.POST("/add", controller.Role.Add)
        role.PUT("/update", controller.Role.Update)
        role.DELETE("/delete/:ids", controller.Role.Delete)
        role.PUT("/status", controller.Role.Status)
        role.GET("/getRoleList", controller.Role.GetRoleList)
    }

    /* 角色菜单权限 */
    roleMenu := router.Group("rolemenu")
    {
        roleMenu.GET("/index/:roleId", controller.RoleMenu.Index)
        roleMenu.POST("/save", controller.RoleMenu.Save)
    }

    /* 登录日志 */
    loginLog := router.Group("loginlog")
    {
        loginLog.GET("/list", controller.LoginLog.List)
        loginLog.DELETE("/delete/:ids", controller.LoginLog.Delete)
    }

    /* 操作日志 */
    operLog := router.Group("operlog")
    {
        operLog.GET("/list", controller.OperLog.List)
    }

    /* 字典管理 */
    dict := router.Group("dict")
    {
        dict.GET("/list", controller.Dict.List)
        dict.POST("/add", controller.Dict.Add)
        dict.PUT("/update", controller.Dict.Update)
        dict.DELETE("/delete/:ids", controller.Dict.Delete)
    }

    /* 字典项管理 */
    dictdata := router.Group("dictdata")
    {
        dictdata.GET("/list", controller.DictData.List)
        dictdata.POST("/add", controller.DictData.Add)
        dictdata.PUT("/update", controller.DictData.Update)
        dictdata.DELETE("/delete/:ids", controller.DictData.Delete)
    }

    /* 配置管理 */
    config := router.Group("config")
    {
        config.GET("/list", controller.Config.List)
        config.POST("/add", controller.Config.Add)
        config.PUT("/update", controller.Config.Update)
        config.DELETE("/delete/:ids", controller.Config.Delete)
    }

    /* 配置项管理 */
    configdata := router.Group("configdata")
    {
        configdata.GET("/list", controller.ConfigData.List)
        configdata.POST("/add", controller.ConfigData.Add)
        configdata.PUT("/update", controller.ConfigData.Update)
        configdata.DELETE("/delete/:ids", controller.ConfigData.Delete)
        configdata.PUT("/status", controller.ConfigData.Status)
    }

    /* 通知管理 */
    notice := router.Group("notice")
    {
        notice.GET("/list", controller.Notice.List)
        notice.POST("/add", controller.Notice.Add)
        notice.PUT("/update", controller.Notice.Update)
        notice.DELETE("/delete/:ids", controller.Notice.Delete)
        notice.PUT("/status", controller.Notice.Status)
    }

    /* 城市管理 */
    city := router.Group("city")
    {
        city.GET("/list", controller.City.List)
        city.POST("/add", controller.City.Add)
        city.PUT("/update", controller.City.Update)
        city.DELETE("/delete/:ids", controller.City.Delete)
        city.POST("/getChilds", controller.City.GetChilds)
    }

    /* 友链管理 */
    link := router.Group("link")
    {
        link.GET("/list", controller.Link.List)
        link.POST("/add", controller.Link.Add)
        link.PUT("/update", controller.Link.Update)
        link.DELETE("/delete/:ids", controller.Link.Delete)
        link.PUT("/status", controller.Link.Status)
    }

    /* 站点管理 */
    item := router.Group("item")
    {
        item.GET("/list", controller.Item.List)
        item.POST("/add", controller.Item.Add)
        item.PUT("/update", controller.Item.Update)
        item.DELETE("/delete/:ids", controller.Item.Delete)
        item.PUT("/status", controller.Item.Status)
        item.GET("/getItemList", controller.Item.GetItemList)
    }

    /* 栏目管理 */
    itemcate := router.Group("itemcate")
    {
        itemcate.GET("/list", controller.ItemCate.List)
        itemcate.POST("/add", controller.ItemCate.Add)
        itemcate.PUT("/update", controller.ItemCate.Update)
        itemcate.DELETE("/delete/:ids", controller.ItemCate.Delete)
        itemcate.GET("/getCateList", controller.ItemCate.GetCateList)
    }

    /* 广告位管理 */
    adsort := router.Group("adsort")
    {
        adsort.GET("/list", controller.AdSort.List)
        adsort.POST("/add", controller.AdSort.Add)
        adsort.PUT("/update", controller.AdSort.Update)
        adsort.DELETE("/delete/:ids", controller.AdSort.Delete)
        adsort.GET("/getAdSortList", controller.AdSort.GetAdSortList)
    }

    /* 广告管理 */
    ad := router.Group("ad")
    {
        ad.GET("/list", controller.Ad.List)
        ad.POST("/add", controller.Ad.Add)
        ad.PUT("/update", controller.Ad.Update)
        ad.DELETE("/delete/:ids", controller.Ad.Delete)
        ad.PUT("/status", controller.Ad.Status)
    }

    /* 会员等级 */
    memberlevel := router.Group("memberlevel")
    {
        memberlevel.GET("/list", controller.MemberLevel.List)
        memberlevel.POST("/add", controller.MemberLevel.Add)
        memberlevel.PUT("/update", controller.MemberLevel.Update)
        memberlevel.DELETE("/delete/:ids", controller.MemberLevel.Delete)
        memberlevel.GET("/getMemberLevelList", controller.MemberLevel.GetMemberLevelList)
    }

    /* 会员管理 */
    member := router.Group("member")
    {
        member.GET("/list", controller.Member.List)
        member.POST("/add", controller.Member.Add)
        member.PUT("/update", controller.Member.Update)
        member.DELETE("/delete/:ids", controller.Member.Delete)
        member.PUT("/status", controller.Member.Status)
    }

    /* 网站设置 */
    configweb := router.Group("configweb")
    {
        configweb.GET("/index", controller.ConfigWeb.Index)
        configweb.PUT("/save", controller.ConfigWeb.Save)
    }

    /* 代码生成器 */
    generate := router.Group("generate")
    {
        generate.GET("/list", controller.Generate.List)
        generate.POST("/generate", controller.Generate.Generate)
        generate.POST("/batchGenerate", controller.Generate.BatchGenerate)
    }

    /* 演示一 */
    example := router.Group("example")
    {
        example.GET("/list", controller.Example.List)
        example.POST("/add", controller.Example.Add)
        example.PUT("/update", controller.Example.Update)
        example.DELETE("/delete/:ids", controller.Example.Delete)

        example.PUT("/status", controller.Example.Status)
        example.PUT("/isVip", controller.Example.IsVip)
    }

    /* 演示二 */
    example2 := router.Group("example2")
    {
        example2.GET("/list", controller.Example2.List)
        example2.POST("/add", controller.Example2.Add)
        example2.PUT("/update", controller.Example2.Update)
        example2.DELETE("/delete/:ids", controller.Example2.Delete)

        example2.PUT("/status", controller.Example2.Status)
    }

    // 启动
    router.Run(":9098")
}

dto

app/dto/level.go

/**
 * 职级Dto
 * @File : level
 */
package dto

// 分页查询
type LevelPageReq struct {
    Name  string `form:"name"`  // 职级名称
    Page  int    `form:"page"`  // 页码
    Limit int    `form:"limit"` // 每页数
}

// 添加职级
type LevelAddReq struct {
    Name   string `form:"name" binding:"required"`
    Status int    `form:"status" binding:"required"`
    Sort   int    `form:"sort"`
}

// 编辑职级
type LevelUpdateReq struct {
    Id     int    `form:"id" binding:"required"`
    Name   string `form:"name" binding:"required"`
    Status int    `form:"status" binding:"required"`
    Sort   int    `form:"sort"`
}

// 设置状态
type LevelStatusReq struct {
    Id     int `form:"id" binding:"required"`
    Status int `form:"status" binding:"required"`
}

controller

app/controller/level.go

/**
 * 职级管理-控制器
 * @File : level
 */
package controller

import (
    "easygoadmin/app/dto"
    "easygoadmin/app/model"
    "easygoadmin/app/service"
    "easygoadmin/utils"
    "easygoadmin/utils/common"
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)

var Level = new(levelCtl)

type levelCtl struct{}

func (c *levelCtl) List(ctx *gin.Context) {
    // 参数绑定
    var req *dto.LevelPageReq
    if err := ctx.ShouldBind(&req); err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }

    // 调用获取列表方法
    list, count, err := service.Level.GetList(req)
    if err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }

    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code:  0,
        Data:  list,
        Msg:   "操作成功",
        Count: count,
    })
}

func (c *levelCtl) Add(ctx *gin.Context) {
    // 参数绑定
    var req *dto.LevelAddReq
    if err := ctx.ShouldBind(&req); err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }

    // 调用添加方法
    rows, err := service.Level.Add(req, utils.Uid(ctx))
    if err != nil || rows == 0 {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }

    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code: 0,
        Msg:  "添加成功",
    })
}

func (c *levelCtl) Update(ctx *gin.Context) {
    // 参数绑定
    var req *dto.LevelUpdateReq
    if err := ctx.ShouldBind(&req); err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }

    // 调用更新方法
    rows, err := service.Level.Update(req, utils.Uid(ctx))
    if err != nil || rows == 0 {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }

    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code: 0,
        Msg:  "更新成功",
    })
}

func (c *levelCtl) Delete(ctx *gin.Context) {
    // 记录ID
    ids := ctx.Param("ids")
    if ids == "" {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  "记录ID不能为空",
        })
        return
    }

    // 调用删除方法
    rows, err := service.Level.Delete(ids)
    if err != nil || rows == 0 {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }

    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code: 0,
        Msg:  "删除成功",
    })
}

func (c *levelCtl) Status(ctx *gin.Context) {
    // 参数绑定
    var req *dto.LevelStatusReq
    if err := ctx.ShouldBind(&req); err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }

    // 调用设置状态方法
    rows, err := service.Level.Status(req, utils.Uid(ctx))
    if err != nil || rows == 0 {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }
    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code: 0,
        Msg:  "设置成功",
    })
}

func (c *levelCtl) GetLevelList(ctx *gin.Context) {
    list := make([]model.Level, 0)
    utils.XormDb.Where("status=1 and mark=1").Asc("sort").Find(&list)
    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code: 0,
        Msg:  "查询成功",
        Data: list,
    })
}

func (c *levelCtl) ImportExcel(ctx *gin.Context) {
    // 接收导入的文件
    _, header, err := ctx.Request.FormFile("file")
    if err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  "文件上传失败",
        })
        return
    }
    // 调用文件上传导入方法
    count, err := service.Level.ImportExcel(header, ctx)
    if err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }
    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code: 0,
        Msg:  fmt.Sprintf("本次共导入【%d】条数据", count),
    })
}

func (c *levelCtl) ExportExcel(ctx *gin.Context) {
    // 参数绑定
    var req dto.LevelPageReq
    if err := ctx.ShouldBind(&req); err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  err.Error(),
        })
        return
    }
    // 调用获取列表方法
    fileURL, err := service.Level.GetExcelList(req)
    if err != nil {
        ctx.JSON(http.StatusOK, common.JsonResult{
            Code: -1,
            Msg:  "导出Excel失败",
        })
        return
    }
    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code: 0,
        Msg:  "导出成功",
        Data: fileURL,
    })
}

func (c *levelCtl) DownloadExcel(ctx *gin.Context) {
    // 模板地址
    fileURL := utils.ImageUrl() + "/level.xlsx"
    // 返回结果
    ctx.JSON(http.StatusOK, common.JsonResult{
        Code: 0,
        Msg:  "下载成功",
        Data: fileURL,
    })
}

service

app/service/level.go

/**
 * 职级-服务类
 * @File : level
 */
package service

import (
    "easygoadmin/app/dto"
    "easygoadmin/app/model"
    "easygoadmin/utils"
    "easygoadmin/utils/gconv"
    "errors"
    "fmt"
    "github.com/gin-gonic/gin"
    "github.com/xuri/excelize/v2"
    "mime/multipart"
    "path/filepath"
    "strconv"
    "strings"
    "time"
)

// 中间件管理服务
var Level = new(levelService)

type levelService struct{}

func (s *levelService) GetList(req *dto.LevelPageReq) ([]model.Level, int64, error) {
    // 初始化查询实例
    query := utils.XormDb.Where("mark=1")
    if req != nil {
        // 职级名称查询
        if req.Name != "" {
            query = query.Where("name like ?", "%"+req.Name+"%")
        }
    }
    // 排序
    query = query.Asc("sort")
    // 分页设置
    offset := (req.Page - 1) * req.Limit
    query = query.Limit(req.Limit, offset)
    // 查询列表
    list := make([]model.Level, 0)
    count, err := query.FindAndCount(&list)
    // 返回结果
    return list, count, err
}

func (s *levelService) Add(req *dto.LevelAddReq, userId int) (int64, error) {
    if utils.AppDebug() {
        return 0, errors.New("演示环境，暂无权限操作")
    }
    // 实例化对象
    var entity model.Level
    entity.Name = req.Name
    entity.Status = req.Status
    entity.Sort = req.Sort
    entity.CreateUser = userId
    entity.CreateTime = time.Now().Unix()
    entity.Mark = 1
    // 插入数据
    return entity.Insert()
}

func (s *levelService) Update(req *dto.LevelUpdateReq, userId int) (int64, error) {
    if utils.AppDebug() {
        return 0, errors.New("演示环境，暂无权限操作")
    }
    // 查询记录
    entity := &model.Level{Id: req.Id}
    has, err := entity.Get()
    if err != nil || !has {
        return 0, errors.New("记录不存在")
    }
    entity.Name = req.Name
    entity.Status = req.Status
    entity.Sort = req.Sort
    entity.UpdateUser = userId
    entity.UpdateTime = time.Now().Unix()
    // 更新记录
    return entity.Update()
}

// 删除
func (s *levelService) Delete(ids string) (int64, error) {
    if utils.AppDebug() {
        return 0, errors.New("演示环境，暂无权限操作")
    }
    // 记录ID
    idsArr := strings.Split(ids, ",")
    if len(idsArr) == 1 {
        // 单个删除
        entity := &model.Level{Id: gconv.Int(ids)}
        rows, err := entity.Delete()
        if err != nil || rows == 0 {
            return 0, errors.New("删除失败")
        }
        return rows, nil
    } else {
        // 批量删除
        return 0, nil
    }
}

func (s *levelService) Status(req *dto.LevelStatusReq, userId int) (int64, error) {
    if utils.AppDebug() {
        return 0, errors.New("演示环境，暂无权限操作")
    }
    // 查询记录是否存在
    info := &model.Level{Id: req.Id}
    has, err := info.Get()
    if err != nil || !has {
        return 0, errors.New("记录不存在")
    }

    // 设置状态
    entity := &model.Level{}
    entity.Id = info.Id
    entity.Status = req.Status
    entity.UpdateUser = userId
    entity.UpdateTime = time.Now().Unix()
    return entity.Update()
}

func (s *levelService) ImportExcel(header *multipart.FileHeader, ctx *gin.Context) (int, error) {
    if utils.AppDebug() {
        return 0, errors.New("演示环境，暂无权限操作")
    }
    // 定义文件名称
    fileName := fmt.Sprintf("%s.xlsx", time.Now().Format("20060102150405"))
    // 文件存储地址
    filePath := filepath.Join(utils.TempPath(), "/", fileName)
    // 保存上传的文件
    _ = ctx.SaveUploadedFile(header, filePath)
    // 读取Excel文件
    file, err := excelize.OpenFile(filePath)
    if err != nil {
        return 0, errors.New("excel文件读取失败")
    }
    // 读取第一张Sheet表
    rows, err := file.Rows("Sheet1")
    if err != nil {
        return 0, errors.New("excel文件读取失败")
    }
    // 计数器
    totalNum := 0
    // Excel文件头，此处必须与Excel模板头保持一致
    excelHeader := []string{"职级名称", "职级状态", "显示顺序"}
    // 循环遍历读取的数据源
    for rows.Next() {
        // Excel列对象
        item, err2 := rows.Columns()
        if err2 != nil {
            return 0, errors.New("excel文件解析异常")
        }
        // 读取的列数与Excel头列数不等则跳过读取下一条
        if len(item) != len(excelHeader) {
            continue
        }
        // 如果是标题栏则跳过
        if item[1] == "职级状态" {
            continue
        }
        // 职级名称
        name := item[0]
        // 职级状态
        status := 1
        if item[1] == "正常" {
            status = 1
        } else {
            status = 2
        }
        // 显示顺序
        sort, _ := strconv.Atoi(item[2])
        // 实例化职级导入对象
        level := model.Level{
            Name:       name,
            Status:     status,
            Sort:       sort,
            CreateUser: utils.Uid(ctx),
            CreateTime: time.Now().Unix(),
            UpdateUser: utils.Uid(ctx),
            UpdateTime: time.Now().Unix(),
            Mark:       1,
        }
        // 插入职级数据
        if _, err := level.Insert(); err != nil {
            return 0, err
        }
        // 计数器+1
        totalNum++
    }
    return totalNum, nil
}

func (s *levelService) GetExcelList(req dto.LevelPageReq) (string, error) {
    // 初始化查询实例
    query := utils.XormDb.Where("mark=1")
    // 职级名称查询
    if req.Name != "" {
        query = query.Where("name like ?", "%"+req.Name+"%")
    }
    // 排序
    query = query.Asc("sort")
    // 查询列表
    list := make([]model.Level, 0)
    err := query.Find(&list)
    if err != nil {
        return "", err
    }

    // 循环遍历处理数据源
    excel := excelize.NewFile()
    excel.SetSheetRow("Sheet1", "A1", &[]string{"ID", "职级名称", "职级状态", "排序", "创建时间"})
    for i, v := range list {
        axis := fmt.Sprintf("A%d", i+2)
        excel.SetSheetRow("Sheet1", axis, &[]interface{}{
            v.Id,
            v.Name,
            v.Status,
            v.Sort,
            time.Unix(v.CreateTime, 0).Format("2006-01-02 15:04:05"),
        })
    }
    // 定义文件名称
    fileName := fmt.Sprintf("%s.xlsx", time.Now().Format("20060102150405"))
    // 设置Excel保存路径
    filePath := filepath.Join(utils.TempPath(), "/", fileName)
    err2 := excel.SaveAs(filePath)
    // 获取文件URL地址
    fileURL := strings.ReplaceAll(filePath, utils.UploadPath(), utils.ImageUrl())
    // 返回结果
    return fileURL, err2
}