package ctrl_v1

import (
	"gd_management_gateway/errors"
	"gd_management_gateway/params/param_base"
	"gd_management_gateway/params/param_v1_0"
	"gd_management_gateway/rpc_apis"
	"gd_management_gateway/rpc_apis/gd_admin"
	"gd_management_gateway/rpc_apis/gd_management"
	"encoding/json"
	"fmt"
	"time"

	"gd_management_gateway/common.in/httper"
	"gd_management_gateway/common.in/task"
	"gd_management_gateway/common.in/utils"
	"github.com/astaxie/beego"
	"github.com/tidwall/sjson"
	"go.uber.org/zap"
)

// Operations about data api
type BaseDataApiController struct {
	metadata interface{} // 中继元数据
	beego.Controller
	LogID string
}

// @Title 添加数据api
// @Description 添加数据api
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body    body   rpc_apis.gd_management.ManagementDataApiAddApiReq true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiAddApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /data_api [post]
func (u *BaseDataApiController) ManagementDataApiAddApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiAddApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiAddApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	// 加入行为日志
	AddActionLogTask := func() error {
		go func() {
			// 构建json
			contentBytes, _ := json.Marshal(req.Body)

			areq := gd_admin.AddActionLogReq{
				Uid:        req.Uid,
				Name:       req.Body.DataApiName,
				Modules:    "数据API",
				Func:       "添加数据api",
				Content:    string(contentBytes),
				ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
			}
			AddActionLog(areq)
		}()
		return nil
	}

	handleDataTask := func() error {
		reply, err := rpc_apis.Management.DataApiAddApi(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiAddApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiAddApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, AddActionLogTask, handleDataTask,
	)
}

// @Title 删除数据api
// @Description 删除数据api
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   data_api_id    query   int64 true "数据api id"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiDeleteApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /data_api [delete]
func (u *BaseDataApiController) ManagementDataApiDeleteApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiDeleteApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiDeleteApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	// 加入行为日志
	AddActionLogTask := func() error {
		// 获取数据api内容
		mreq := gd_management.GetApiInfoReq{
			Id: req.DataApiId,
		}

		reply, err := rpc_apis.Management.GetDataApiInfo(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "GetDataApiInfo"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}

		// 构建json
		contentBytes, _ := json.Marshal(reply)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       reply.DataApiName,
			Modules:    "数据API",
			Func:       "删除数据api",
			Content:    string(contentBytes),
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiDeleteApiReq{}
		mreq.DataApiId = req.DataApiId
		reply, err := rpc_apis.Management.DataApiDeleteApi(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiDeleteApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiDeleteApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, AddActionLogTask, handleDataTask,
	)
}

// @Title 修改数据api
// @Description 修改数据api
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body    body   rpc_apis.gd_management.ManagementDataApiModifyApiReq true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiModifyApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /data_api [put]
func (u *BaseDataApiController) ManagementDataApiModifyApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiModifyApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiModifyApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	// 加入行为日志
	AddActionLogTask := func() error {
		// 获取数据api内容
		mreq := gd_management.GetApiInfoReq{
			Id: req.Body.DataApiId,
		}

		reply, err := rpc_apis.Management.GetDataApiInfo(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "GetDataApiInfo"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}

		// 构建json
		beforeBytes, _ := json.Marshal(reply)
		contentBytes, _ := json.Marshal(req.Body)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       reply.DataApiName,
			Modules:    "数据API",
			Func:       "修改数据api",
			Before:     string(beforeBytes),
			Content:    string(contentBytes),
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		reply, err := rpc_apis.Management.DataApiModifyApi(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiModifyApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiModifyApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, AddActionLogTask, handleDataTask,
	)
}

// @Title 获取数据api列表
// @Description 获取数据api列表
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   page_size  query  int64   false "页大小"
// @Param   page_number  query  int64   false "页号"
// @Param   is_all  query  bool   false "是否获取全部数据"
// @Param   search  query  string   false "搜索字符串"
// @Param   data_api_type query string false ""
// @Param   merchant_id query int64 false ""
// @Success 200 	{object} params.param_v1_0.ManagementDataApiGetAllResp "响应信息"
// @Failure 500 	服务器错误
// @router /data_api [get]
func (u *BaseDataApiController) ManagementDataApiGetAll() {
	u.LogID = fmt.Sprintf("ManagementDataApiGetAll[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiGetAllReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiGetAllReq{}
		mreq.PageSize = req.PageSize
		mreq.PageNumber = req.PageNumber
		mreq.IsAll = req.IsAll
		mreq.Search = req.Search
		mreq.DataApiType = req.DataApiType
		mreq.MerchantId = req.MerchantId
		reply, err := rpc_apis.Management.DataApiGetAll(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetAll"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiGetAllResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleDataTask,
	)
}

// @Title 获取数据api详情
// @Description 获取数据api详情
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   data_api_id   query int64   true "数据api id"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiGetApiInfoResp "响应信息"
// @Failure 500 	服务器错误
// @router /data_api_info [get]
func (u *BaseDataApiController) ManagementDataApiGetApiInfo() {
	u.LogID = fmt.Sprintf("ManagementDataApiGetApiInfo[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiGetApiInfoReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiGetApiInfoReq{}
		mreq.DataApiId = req.DataApiId
		reply, err := rpc_apis.Management.DataApiGetApiInfo(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetApiInfo"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiGetApiInfoResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleDataTask,
	)
}

// @Title 发布数据api
// @Description 发布数据api
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   data_api_id   path int64   true "数据api id"
// @Param   data 	body params.param_v1_0.DataApiReleaseBody true ""
// @Success 200 	{object} params.param_v1_0.ManagementDataApiReleaseApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /data_api_release/:data_api_id [put]
func (u *BaseDataApiController) ManagementDataApiReleaseApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiReleaseApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiReleaseApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}
	// 加入行为日志
	AddActionLogTask := func() error {
		// 获取数据api内容
		mreq := gd_management.GetApiInfoReq{
			Id: req.DataApiId,
		}

		reply, err := rpc_apis.Management.GetDataApiInfo(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "GetDataApiInfo"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}

		// 构建json
		c := map[string]interface{}{
			"data_api_id": req.DataApiId,
		}
		contentBytes, _ := json.Marshal(c)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       reply.DataApiName,
			Modules:    "数据API",
			Func:       "发布数据api",
			Content:    string(contentBytes),
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiReleaseApiReq{}
		mreq.DataApiId = req.DataApiId
		mreq.Status = req.Data.Status
		reply, err := rpc_apis.Management.DataApiReleaseApi(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiReleaseApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiReleaseApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, AddActionLogTask, handleDataTask,
	)
}

// @Title 填加数据api查询方式
// @Description 填加数据api查询方式
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body   body  rpc_apis.gd_management.ManagementDataApiAddQueryTypeReq  true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiAddQueryTypeResp "响应信息"
// @Failure 500 	服务器错误
// @router /query_type [post]
func (u *BaseDataApiController) ManagementDataApiAddQueryType() {
	u.LogID = fmt.Sprintf("ManagementDataApiAddQueryType[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiAddQueryTypeReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	addActionLogTask := func() error {
		go func() {
			// 构建json
			contentBytes, _ := json.Marshal(req.Body)
			queryTypeNames := ""
			for _, v := range req.Body.QueryTypes {
				if queryTypeNames == "" {
					queryTypeNames = v.QueryTypeName
					continue
				}
				queryTypeNames = fmt.Sprintf("%s,%s", queryTypeNames)
			}
			areq := gd_admin.AddActionLogReq{
				Uid:        req.Uid,
				Name:       queryTypeNames,
				Modules:    "数据API",
				Func:       "数据api查询方式",
				Content:    string(contentBytes),
				ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
			}
			AddActionLog(areq)
		}()
		return nil
	}

	handleDataTask := func() error {
		reply, err := rpc_apis.Management.DataApiAddQueryType(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiAddQueryType"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiAddQueryTypeResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, addActionLogTask, handleDataTask,
	)
}

// @Title 修改数据api查询方式
// @Description 修改数据api查询方式
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body   body rpc_apis.gd_management.ManagementDataApiModifyQueryTypeReq   true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiModifyQueryTypeResp "响应信息"
// @Failure 500 	服务器错误
// @router /query_type [put]
func (u *BaseDataApiController) ManagementDataApiModifyQueryType() {
	u.LogID = fmt.Sprintf("ManagementDataApiModifyQueryType[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiModifyQueryTypeReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	addActionLogTask := func() error {
		mreq := gd_management.ManagementDataApiGetQueryTypeReq{}
		mreq.QueryTypeId = req.Body.QueryTypeId
		reply, err := rpc_apis.Management.DataApiGetQueryType(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetQueryType"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}

		beforeBytes, _ := json.Marshal(reply.QueryTypeInfo)
		contentBytes, _ := json.Marshal(req.Body)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       req.Body.QueryTypeName,
			Modules:    "数据API",
			Func:       "修改数据api查询方式",
			Before:     string(beforeBytes),
			Content:    string(contentBytes),
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		reply, err := rpc_apis.Management.DataApiModifyQueryType(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiModifyQueryType"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiModifyQueryTypeResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, addActionLogTask, handleDataTask,
	)
}

// @Title 删除数据api查询方式
// @Description 删除数据api查询方式
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   query_type_id   query int64   true "数据api查询方式id"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiRemoveQueryTypeResp "响应信息"
// @Failure 500 	服务器错误
// @router /query_type [delete]
func (u *BaseDataApiController) ManagementDataApiRemoveQueryType() {
	u.LogID = fmt.Sprintf("ManagementDataApiRemoveQueryType[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiRemoveQueryTypeReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	addActionLogTask := func() error {
		mreq := gd_management.ManagementDataApiGetQueryTypeReq{}
		mreq.QueryTypeId = req.QueryTypeId
		reply, err := rpc_apis.Management.DataApiGetQueryType(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetQueryType"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}

		beforeBytes, _ := json.Marshal(reply.QueryTypeInfo)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       reply.QueryTypeInfo.QueryTypeName,
			Modules:    "数据API",
			Func:       "删除数据api查询方式",
			Before:     string(beforeBytes),
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiRemoveQueryTypeReq{}
		mreq.QueryTypeId = req.QueryTypeId
		reply, err := rpc_apis.Management.DataApiRemoveQueryType(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiRemoveQueryType"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiRemoveQueryTypeResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, addActionLogTask, handleDataTask,
	)
}

// @Title 获取数据api查询方式信息
// @Description 获取数据api查询方式信息
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   query_type_id   query int64   true "数据api查询方式id"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiGetQueryTypeResp "响应信息"
// @Failure 500 	服务器错误
// @router /query_type [get]
func (u *BaseDataApiController) ManagementDataApiGetQueryType() {
	u.LogID = fmt.Sprintf("ManagementDataApiGetQueryType[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiGetQueryTypeReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiGetQueryTypeReq{}
		mreq.QueryTypeId = req.QueryTypeId
		reply, err := rpc_apis.Management.DataApiGetQueryType(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetQueryType"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiGetQueryTypeResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply.QueryTypeInfo
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleDataTask,
	)
}

// @Title 数据api添加基础api
// @Description 数据api添加基础api
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body   body rpc_apis.gd_management.ManagementDataApiAddBaseApiReq   true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiAddBaseApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /base_api [post]
func (u *BaseDataApiController) ManagementDataApiAddBaseApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiAddBaseApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiAddBaseApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	// 加入行为日志
	AddActionLogTask := func() error {
		go func() {
			mreq := gd_management.ManagementDataApiGetQueryTypeReq{}
			mreq.QueryTypeId = req.Body.QueryTypeId
			reply, err := rpc_apis.Management.DataApiGetQueryType(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
			if err != nil {
				l.Error("rpc",
					zap.String("call", "DataApiGetQueryType"),
					zap.String("args", utils.MarshalJsonString(req)),
					zap.String("error", err.Error()))
				return
			}

			// 构建json
			contentBytes, _ := json.Marshal(req.Body)

			areq := gd_admin.AddActionLogReq{
				Uid:        req.Uid,
				Name:       reply.QueryTypeInfo.QueryTypeName,
				Modules:    "数据API",
				Func:       "数据api添加基础api",
				Content:    string(contentBytes),
				ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
			}
			AddActionLog(areq)
		}()

		return nil
	}

	handleDataTask := func() error {
		_, err := rpc_apis.Management.DataApiAddBaseApi(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiAddBaseApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiAddBaseApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, AddActionLogTask, handleDataTask,
	)
}

// @Title 数据api删除基础api
// @Description 数据api删除基础api
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   data_api_base_api_id   query int64   true "数据api中基础api id"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiRemoveBaseApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /base_api [delete]
func (u *BaseDataApiController) ManagementDataApiRemoveBaseApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiRemoveBaseApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiRemoveBaseApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	addActionLogTask := func() error {
		mreq := gd_management.ManagementDataApiGetBaseApiReq{}
		mreq.DataApiBaseApiId = req.DataApiBaseApiId
		reply, err := rpc_apis.Management.DataApiGetBaseApi(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetBaseApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}

		beforeBytes, _ := json.Marshal(reply.DataApiBaseApis)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       reply.DataApiBaseApis.SaleName,
			Modules:    "数据API",
			Func:       "数据api删除基础api",
			Before:     string(beforeBytes),
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiRemoveBaseApiReq{}
		mreq.DataApiBaseApiId = req.DataApiBaseApiId
		reply, err := rpc_apis.Management.DataApiRemoveBaseApi(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiRemoveBaseApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiRemoveBaseApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, addActionLogTask, handleDataTask,
	)
}

// @Title 数据api修改基础api信息
// @Description 数据api修改基础api信息
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body   body rpc_apis.gd_management.ManagementDataApiModifyBaseApiReq   true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiModifyBaseApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /base_api [put]
func (u *BaseDataApiController) ManagementDataApiModifyBaseApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiModifyBaseApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiModifyBaseApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	addActionLogTask := func() error {
		mreq := gd_management.ManagementDataApiGetBaseApiReq{}
		mreq.DataApiBaseApiId = req.Body.DataApiBaseApiId
		reply, err := rpc_apis.Management.DataApiGetBaseApi(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetBaseApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}

		beforeBytes, _ := json.Marshal(reply.DataApiBaseApis)
		contentBytes, _ := json.Marshal(req.Body)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       reply.DataApiBaseApis.SaleName,
			Modules:    "数据API",
			Func:       "数据api修改基础api信息",
			Before:     string(beforeBytes),
			Content:    string(contentBytes),
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		reply, err := rpc_apis.Management.DataApiModifyBaseApi(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiModifyBaseApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiModifyBaseApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, addActionLogTask, handleDataTask,
	)
}

// @Title 数据api获取基础api
// @Description 数据api获取基础api
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   data_api_base_api_id   query int64   false "数据api中基础api id"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiGetBaseApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /base_api [get]
func (u *BaseDataApiController) ManagementDataApiGetBaseApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiGetBaseApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiGetBaseApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiGetBaseApiReq{}
		mreq.DataApiBaseApiId = req.DataApiBaseApiId
		reply, err := rpc_apis.Management.DataApiGetBaseApi(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetBaseApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiGetBaseApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply.DataApiBaseApis
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleDataTask,
	)
}

/*
// @Title 数据api基础api序号调整
// @Description 数据api基础api序号调整
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body   body rpc_apis.gd_management.ManagementDataApiChangeBaseApiIndexReq   true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiChangeBaseApiIndexResp "响应信息"
// @Failure 500 	服务器错误
// @router /base_api_change_index [put]
func (u *BaseDataApiController) ManagementDataApiChangeBaseApiIndex() {
	u.LogID = fmt.Sprintf("ManagementDataApiChangeBaseApiIndex[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiChangeBaseApiIndexReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleTokenCheck := func() error {
		uid, level, err := utils.ParseToken(req.Token)
		if err != nil {
			return err
		}

		if uid != req.Uid {
			return errors.UserTokenillegality
		}

		if level == 0 {
			return errors.AuthNotAllow
		}
		return nil
	}

	handleDataTask := func() error {
		reply, err := rpc_apis.Management.DataApiChangeBaseApiIndex(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiChangeBaseApiIndex"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiChangeBaseApiIndexResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleTokenCheck, handleDataTask,
	)
}
*/

// @Title 数据api添加数据套餐
// @Description 数据api添加数据套餐
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body  body rpc_apis.gd_management.ManagementDataApiAddDataComboReq   true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiAddDataComboResp "响应信息"
// @Failure 500 	服务器错误
// @router /data_combo [post]
func (u *BaseDataApiController) ManagementDataApiAddDataCombo() {
	u.LogID = fmt.Sprintf("ManagementDataApiAddDataCombo[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiAddDataComboReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	addActionLogTask := func() error {
		var queryTypeId int64

		for _, v := range req.Body.ManagementAddDataComboList {
			queryTypeId = v.QueryTypeId
			break
		}

		if queryTypeId == 0 {
			return nil
		}
		mreq := gd_management.ManagementDataApiGetQueryTypeReq{}
		mreq.QueryTypeId = queryTypeId
		reply, err := rpc_apis.Management.DataApiGetQueryType(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetQueryType"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return err
		}

		// 构建json
		contentBytes, _ := json.Marshal(req.Body)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       reply.QueryTypeInfo.QueryTypeName,
			Modules:    "数据API",
			Func:       "数据api添加数据套餐",
			Content:    string(contentBytes),
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		_, err := rpc_apis.Management.DataApiAddDataCombo(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiAddDataCombo"),
				zap.String("args", utils.MarshalJsonString(req.Body)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiAddDataComboResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		//resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, addActionLogTask, handleDataTask,
	)
}

// @Title 数据api删除数据套餐
// @Description 数据api删除数据套餐
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   combo_id   query int64   true "数据api套餐id"
// @Param   query_type_id   query int64   true "数据apiid"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiRemoveDataComboResp "响应信息"
// @Failure 500 	服务器错误
// @router /data_combo [delete]
func (u *BaseDataApiController) ManagementDataApiRemoveDataCombo() {
	u.LogID = fmt.Sprintf("ManagementDataApiRemoveDataCombo[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiRemoveDataComboReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	addActionLogTask := func() error {
		mreq := gd_management.ManagementDataApiGetDataComboReq{
			ComboId: req.ComboId,
		}

		reply, err := rpc_apis.Management.DataApiGetDataCombo(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiGetDataCombo"),
				zap.String("args", utils.MarshalJsonString(mreq)),
				zap.String("error", err.Error()))
			return err
		}

		json := `{"count":,"price":,"type":,"total_day":}`
		json, _ = sjson.Set(json, "count", reply.Count)
		json, _ = sjson.Set(json, "price", reply.Price)
		json, _ = sjson.Set(json, "type", reply.Type)
		json, _ = sjson.Set(json, "total_day", reply.TotalDay)

		areq := gd_admin.AddActionLogReq{
			Uid:        req.Uid,
			Name:       reply.QueryTypeName,
			Modules:    "数据API",
			Func:       "数据api删除数据套餐",
			Content:    json,
			ModifyTime: time.Now().Format("2006-01-02 15:04:05"),
		}
		err = AddActionLog(areq)
		if err != nil {
			return err
		}

		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiRemoveDataComboReq{}
		mreq.ComboId = req.ComboId
		reply, err := rpc_apis.Management.DataApiRemoveDataCombo(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiRemoveDataCombo"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiRemoveDataComboResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, addActionLogTask, handleDataTask,
	)
}

/*
// @Title 数据api选择三方数据源接口
// @Description 数据api选择三方数据源接口
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body   body rpc_apis.gd_management.ManagementDataApiChooseProviderApiReq   true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiChooseProviderApiResp "响应信息"
// @Failure 500 	服务器错误
// @router /choose_provider_api [put]
func (u *BaseDataApiController) ManagementDataApiChooseProviderApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiChooseProviderApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiChooseProviderApiReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleTokenCheck := func() error {
		uid, level, err := utils.ParseToken(req.Token)
		if err != nil {
			return err
		}

		if uid != req.Uid {
			return errors.UserTokenillegality
		}

		if level == 0 {
			return errors.AuthNotAllow
		}
		return nil
	}

	handleDataTask := func() error {
		reply, err := rpc_apis.Management.DataApiChooseProviderApi(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "DataApiChooseProviderApi"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiChooseProviderApiResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleTokenCheck, handleDataTask,
	)
}
*/

// @Title 数据api设置查询方式是否免费
// @Description 数据api设置查询方式是否免费
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   body   body rpc_apis.gd_management.ManagementDataApiSetFreeDataComboReq   true "参数"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiSetFreeDataComboResp "响应信息"
// @Failure 500 	服务器错误
// @router /set_free_combo [put]
func (u *BaseDataApiController) ManagementDataApiSetFreeDataCombo() {
	u.LogID = fmt.Sprintf("ManagementDataApiSetFreeDataCombo[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiSetFreeDataComboReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleDataTask := func() error {
		reply, err := rpc_apis.Management.ManagementDataApiSetFreeDataCombo(utils.NewContextFromBeegoCtx(u.Ctx), &req.Body)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "ManagementDataApiSetFreeDataCombo"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiSetFreeDataComboResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleDataTask,
	)
}

// @Title 数据api获取查询方式列表
// @Description 数据api获取插叙方式列表
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   data_api_id   query int64   true "数据api id"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiGetQueryTypeListResp "响应信息"
// @Failure 500 	服务器错误
// @router /query_type_list [get]
func (u *BaseDataApiController) ManagementDataApiGetQueryTypeListApi() {
	u.LogID = fmt.Sprintf("ManagementDataApiGetQueryTypeListApi[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiGetQueryTypeListReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiGetQueryTypeListReq{}
		mreq.DataApiId = req.DataApiId
		reply, err := rpc_apis.Management.ManagementDataApiGetQueryTypeList(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "MangementDataApiGetQueryTypeList"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiGetQueryTypeListResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleDataTask,
	)
}

// @Title 数据api套餐列表
// @Description 数据api套餐列表
// @Param   token    header   string true "token"
// @Param   uid    header   int64 true "admin id"
// @Param   query_type_id   query int64   true "数据api id"
// @Success 200 	{object} params.param_v1_0.ManagementDataApiComboListResp "响应信息"
// @Failure 500 	服务器错误
// @router /combo_list [get]
func (u *BaseDataApiController) ManagementDataApiComboList() {
	u.LogID = fmt.Sprintf("ManagementDataApiComboList[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementDataApiComboListReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementDataApiComboListReq{}
		mreq.QueryTypeId = req.QueryTypeId
		reply, err := rpc_apis.Management.ManagementDataApiComboList(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "ManagementDataApiComboList"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementDataApiComboListResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Data = reply
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleDataTask,
	)
}

// @Title get filter rules
// @Description 获取参数过滤规则列表
// @Param   token    header   string true "token"
// @Param   uid    header   string true "uid"
// @Success 200 	{object} params.param_v1_0.ManagementGetFilterRuleResp "响应信息"
// @Failure 500 	服务器错误
// @router /param_filter_rules [get]
func (u *BaseDataApiController) ManagementGetFilterRule() {
	u.LogID = fmt.Sprintf("ManagementGetFilterRule[%d]", time.Now().UnixNano())

	req := &param_v1_0.ManagementGetFilterRuleReq{}
	getParamsTask := func() error {
		httper.FillRequireParams(u.Ctx, req, u.LogID)
		return nil
	}

	handleDataTask := func() error {
		mreq := gd_management.ManagementGetFilterRuleReq{}
		reply, err := rpc_apis.Management.ManagementGetFilterRule(utils.NewContextFromBeegoCtx(u.Ctx), &mreq)
		if err != nil {
			l.Error("rpc",
				zap.String("call", "ManagementSetBaseApiShowInfo"),
				zap.String("args", utils.MarshalJsonString(req)),
				zap.String("error", err.Error()))
			return errors.ErrorTransform(err)
		}
		resp := param_v1_0.ManagementGetFilterRuleResp{
			SimpleResp: param_base.SimpleResp{
				Code: 0,
				Msg:  "SUCCESS",
			},
		}
		resp.Rules = reply.Rules
		httper.JSON(u.Ctx, resp, u.LogID)
		return nil
	}

	// 执行以上定义的任务
	task.Do(&task.PanicRecover{
		Ctx:   u.Ctx,
		LogID: u.LogID}, u.Ctx,
		getParamsTask, handleDataTask,
	)
}
