adm-gateway/controller/v1.0/data_management.go

package v1_0

import (
	"adm-gateway/errors"
	param_v1 "adm-gateway/param/v1"
	"adm-gateway/parser"
	"adm-gateway/pb"
	v1 "adm-gateway/pb/v1"
	"fmt"
	"net/http"
	"strings"

	"git.getensh.com/common/gopkgsv2/id"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
	"github.com/gin-gonic/gin"
	"git.getensh.com/common/gopkgsv2/logger"
	"git.getensh.com/common/gopkgsv2/tasker/httptasker"
	"git.getensh.com/common/gopkgsv2/util"
	"go.uber.org/zap"
)

// 1. 数据管理表 t_adm_data_management

// DataList godoc
// @Summary 数据管理
// @Description 数据管理
// @Tags data_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param table_name query string false "表名"
// @Param desc query string false "描述"
// @Param level query string false "所属层"
// @Param page query int32 false "页码"
// @Param page_size query int32 false "每页数量，默认10"
// @Success 200 {object} param_v1.GetDataListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/data_management [get]
func (c *Controller) DataList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GetDataListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.GetDataListQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.GetDataListResponse{}

		r := v1.DataListRequest{
			TableName: req.TableName,
			Desc:      req.Desc,
			Level:     req.Level,
			Page:      req.Page,
			PageSize:  req.PageSize,
		}

		reply, err := pb.Management.DataList(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.DataList"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.DataList, 0)
		}
		resp.Data = reply
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// SearchData godoc
// @Summary 模糊搜索
// @Description 模糊搜索
// @Tags data_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param table_name query string false "表名"
// @Success 200 {object} param_v1.SearchDataResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/data_management/search [get]
func (c *Controller) SearchData(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.SearchDataRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.SearchDataQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.SearchDataResponse{}

		r := v1.SearchDataRequest{
			TableName: req.TableName,
		}

		reply, err := pb.Management.SearchData(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.SearchData"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.SearchData, 0)
		}
		resp.Data = reply

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// SearchLevel godoc
// @Summary 所属层搜索
// @Description 所属层搜索
// @Tags data_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param level query string false "所属层"
// @Success 200 {object} param_v1.SearchLevelResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/data_management/search_level [get]
func (c *Controller) SearchLevel(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.SearchLevelRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.SearchLevelQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.SearchLevelResponse{}

		r := v1.SearchLevelRequest{
			Level: req.Level,
		}

		reply, err := pb.Management.SearchLevel(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.SearchLevel"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		resp.Data = reply.List

		if resp.Data == nil {
			resp.Data = make([]string, 0)
		}
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 2.数据关系表 t_adm_task_data_relation

// Relation godoc
// @Summary 任务关系
// @Description 任务关系
// @Tags data_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param source_code query string false "数据源"
// @Success 200 {object} param_v1.GetRelationResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/data_management/relation [get]
func (c *Controller) Relation(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GetRelationRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.GetRelationQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.GetRelationResponse{}

		r := v1.RelationRequest{
			SourceCode: req.SourceCode,
		}

		reply, err := pb.Management.Relation(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.Relation"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.Relation, 0)
		}
		resp.Data = reply
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// Switch godoc
// @Summary 任务开关
// @Description 任务开关
// @Tags data_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param body body param_v1.GetSwitchBody true "body"
// @Success 200 {object} param_v1.GetSwitchResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/data_management/relation/ [put]
func (c *Controller) Switch(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GetSwitchRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.GetSwitchBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.GetSwitchResponse{}
		//resp.Code = 0
		//resp.Message = "成功"

		r := v1.SwitchRequest{
			TaskId: req.TaskId,
			IsOn:   req.IsOn,
		}

		_, err := pb.Management.Switch(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.Switch"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 3.任务管理表 t_adm_tasks_management

// TaskList godoc
// @Summary 任务管理
// @Description 任务管理
// @Tags task_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param task_name query string false "任务名"
// @Param desc query string false "描述"
// @Param page query int32 false "页码"
// @Param page_size query int32 false "每页数量，默认10"
// @Success 200 {object} param_v1.GetTaskListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/task_management [get]
func (c *Controller) TaskList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GetTaskListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.GetTaskListQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.GetTaskListResponse{}

		r := v1.TaskListRequest{
			TaskName: req.TaskName,
			Desc:     req.Desc,
			Page:     req.Page,
			PageSize: req.PageSize,
		}

		reply, err := pb.Management.TaskList(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.TaskList"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.TaskList, 0)
		}
		resp.Data = reply
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// SearchTask godoc
// @Summary 模糊搜索
// @Description 模糊搜索
// @Tags task_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param task_name query string false "任务名"
// @Success 200 {object} param_v1.SearchTaskResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/task_management/search [get]
func (c *Controller) SearchTask(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.SearchTaskRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.SearchTaskQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.SearchTaskResponse{}

		r := v1.SearchTaskRequest{
			TaskName: req.TaskName,
		}

		reply, err := pb.Management.SearchTask(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.SearchData"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.SearchTask, 0)
		}
		resp.Data = reply

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 4.依赖表 t_adm_task_dependency

// Dependency godoc
// @Summary 依赖表
// @Description 依赖表
// @Tags task_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param task_id query int64 false "任务id"
// @Param type query int32 true "源表或依赖表"
// @Success 200 {object} param_v1.GetDependencyResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/task_management/dependency [get]
func (c *Controller) Dependency(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GetDependencyRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.GetDependencyQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.GetDependencyResponse{}

		r := v1.DependencyRequest{
			TaskId: req.TaskId,
			Type:   req.Type,
		}

		reply, err := pb.Management.Dependency(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.Dependency"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.Dependency, 0)
		}
		resp.Data = reply
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// DataSourceRelation godoc
// @Summary 血缘关系
// @Description 血缘关系
// @Tags task_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param task_id query int64 false "任务id"
// @Param source_code query string false "source code"
// @Success 200 {object} param_v1.GetDataSourceRelationResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/task_management/relation [get]
func (c *Controller) DataSourceRelation(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GetDataSourceRelationRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.GetDataSourceRelationQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.GetDataSourceRelationResponse{}

		r := v1.DataSourceRelationRequest{
			TaskId:     req.TaskId,
			SourceCode: req.SourceCode,
		}

		reply, err := pb.Management.DataSourceRelation(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.DataSourceRelation"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		resp.Data = reply
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 手动任务列表 t_adm_offline_task

// ManualTask godoc
// @Summary 手动任务
// @Description 手动任务
// @Tags manualTask,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param source query string false "源表"
// @Param task_name query string false "任务"
// @Param manual_task_name query string false "手动任务名"
// @Param time1 query int64 false "时间1"
// @Param time2 query int64 false "时间2"
// @Param page query int32 false "页码"
// @Param page_size query int32 false "每页数量，默认10"
// @Success 200 {object} param_v1.GetManualTaskResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/manual_task [get]
func (c *Controller) ManualTask(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GetManualTaskRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.GetManualTaskQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.GetManualTaskResponse{}

		r := v1.ManualTaskRequest{
			Source:         req.Source,
			TaskName:       req.TaskName,
			ManualTaskName: req.ManualTaskName,
			Time1:          req.Time1,
			Time2:          req.Time2,
			Page:           req.Page,
			PageSize:       req.PageSize,
		}

		reply, err := pb.Management.ManualTask(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.ManualTask"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.ManualTask, 0)
		}
		resp.Data = reply
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// Source godoc
// @Summary 源表搜索
// @Description 源表搜索
// @Tags manualTask,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param source_name query string false "源表"
// @Success 200 {object} param_v1.SourceResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/manual_task/source [get]
func (c *Controller) Source(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.SourceRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.SourceQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.SourceResponse{}

		r := v1.SourceRequest{
			SourceName: req.SourceName,
		}

		reply, err := pb.Management.Source(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.Source"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.Source, 0)
		}
		resp.Data = reply

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// Task godoc
// @Summary 任务列表
// @Description 任务列表
// @Tags manualTask,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param source_request query string false "源表名"
// @Success 200 {object} param_v1.TaskResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/manual_task/task [get]
func (c *Controller) Task(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.TaskRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.TaskQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.TaskResponse{}

		r := v1.TaskRequest{
			SourceRequest: req.SourceRequest,
		}

		reply, err := pb.Management.Task(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.Task"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.Task, 0)
		}
		resp.Data = reply

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// Create godoc
// @Summary 创建手动任务
// @Description 创建手动任务
// @Tags manualTask,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param body body param_v1.CreateBody true "body"
// @Success 200 {object} param_v1.CreateResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/manual_task/create [post]
func (c *Controller) Create(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.CreateRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.CreateBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.CreateResponse{}

		r := v1.CreateRequest{
			TaskName: req.TaskName,
			Type:     req.Type,
			Source:   req.Source,
			Sql:      req.Sql,
			TaskIds:  req.TaskIds,
		}

		_, err := pb.Management.Create(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.Create"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// UploadFile godoc
// @Summary 上传文件创建
// @Description 上传文件创建
// @Tags manualTask,v1.0
// @Accept json
// @Produce json
// @Param token header string true "jwt token"
// @Param file formData file true "上传文件"
// @Param task_name formData string true "手动任务"
// @Success 200 {string} param_v1.UploadFileResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/manual_task/create/upload [post]
func (c *Controller) UploadFile(ctx *gin.Context) {
	// 业务处理
	uploadFileTask := func() error {
		// 上传文件 得到url
		file, err := ctx.FormFile("file")
		if err != nil {
			return errors.SystemError
		}

		if strings.Index(file.Filename, "xlsx") == -1 && strings.Index(file.Filename, "xlx") == -1 {
			return errors.FileTypeError
		}

		id, _ := id.GetUniqueID()
		fileName := fmt.Sprintf("file-upload-%s-%d.xlsx", ctx.PostForm("task_name"), id)

		resp := &param_v1.UploadFileResponse{}

		r := v1.UploadFileRequest{
			TaskName: ctx.PostForm("task_name"),
		}

		reply, err := pb.Management.UploadFile(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.UploadFile"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		client, err := oss.New(
			parser.Conf.Oss.EndPoint,
			parser.Conf.Oss.AccessKey,
			parser.Conf.Oss.AccessSecret,
		)
		if err != nil {
			return err
		}

		bucket, err := client.Bucket(parser.Conf.Oss.Bucket)
		if err != nil {
			return err
		}

		reader, _ := file.Open()

		err = bucket.PutObject(fileName, reader)
		if err != nil {
			return err
		}

		reply.Url = "https://" + parser.Conf.Oss.Bucket + "." + parser.Conf.Oss.EndPoint + "/" + fileName

		resp.Data = reply

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, uploadFileTask)
}

// TableStruct godoc
// @Summary 查看表结构
// @Description 查看表结构
// @Tags data_management,v1.0
// @Accept  json
// @Produce  json
// @Param token header string true "jwt token"
// @Param table_name query string false "表名"
// @Success 200 {object} param_v1.TableStructResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1.0/data_management/table_struct [get]
func (c *Controller) TableStruct(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.TableStructRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.TableStructQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := &param_v1.TableStructResponse{}

		r := v1.TableStructRequest{
			TableName: req.TableName,
		}

		reply, err := pb.Management.TableStruct(ctx.Request.Context(), &r)
		if err != nil {
			s, _ := json.MarshalToString(r)
			logger.Error("func",
				zap.String("call", "pb.management.TableStruct"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		if reply.List == nil {
			reply.List = make([]*v1.TableStruct, 0)
		}
		resp.Data = reply
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}