MTP20_IF/controllers/ermcp3/qryErmcp3.go

/**
* @Author: zou.yingbin
* @Create  : 2021/4/15 10:35
* @Modify  : 2021/4/15 10:35
 */

package ermcp3

import (
	"github.com/gin-gonic/gin"
	"mtp2_if/global/app"
	"mtp2_if/global/e"
	"mtp2_if/logger"
	"mtp2_if/models"
	"mtp2_if/mtpcache"
	"net/http"
)

// QueryDeliveryGoods
// @Summary  查询现货商品
// @Produce  json
// @Security    ApiKeyAuth
// @Param    userid     query    int true  "用户id"
// @Param    usertype   query    int false "用户类型 2-机构 7-企业成员"
// @Param    excludecfg query    int false "排除已配置的业务类型商品 1-套保 2-套利"
// @Success  200        {array}  models.ErmcpDeliveryGoods
// @Failure  500        {object} app.Response
// @Router   /Ermcp3/QueryDeliveryGoods [get]
// @Tags     企业风险管理v3(app)
func QueryDeliveryGoods(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		UserId     int64 `form:"userid" binding:"required"` // 用户id
		USERTYPE   int32 `form:"usertype"`                  // 用户类型
		ExcludeCfg int32 `form:"excludecfg"`                // 排除已配置的业务类型商品 1-套保 2-套利
	}{}

	a.DoBindReq(&req)
	m := models.ErmcpDeliveryGoods{AREAUSERID: mtpcache.GetAreaUserId(req.UserId, req.USERTYPE),
		ExcludeCfg: req.ExcludeCfg}
	a.DoGetDataI(&m)
}

// QueryDeliveryGoodsDetail
// @Summary  查询现货商品详情
// @Produce  json
// @Security    ApiKeyAuth
// @Param    userid          query    int true  "用户id"
// @Param    usertype        query    int false "用户类型 2-机构 7-企业成员"
// @Param    deliverygoodsid query    int false "现货商品id"
// @Param    filtersubempty  query    int false "过滤下级为空, 1-过滤. 比如 品种大豆的下级品类列表为空, 则大豆不显示; 比如品类的下级套保品列表为空, 则该品类不显示"
// @Success  200             {array}  models.XHDeliveryGoods
// @Failure  500             {object} app.Response
// @Router   /Ermcp3/QueryDeliveryGoodsDetail [get]
// @Tags     企业风险管理v3(app)
func QueryDeliveryGoodsDetail(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		UserId          int64 `form:"userid" binding:"required"` // 用户id
		USERTYPE        int32 `form:"usertype"`                  // 用户类型
		DeliveryGoodsId int64 `form:"deliverygoodsid"`           // 现货商品id
	}{}
	a.DoBindReq(&req)
	m := models.XHDeliveryGoods{AREAUSERID: mtpcache.GetAreaUserId(req.UserId, req.USERTYPE),
		DELIVERYGOODSID: req.DeliveryGoodsId}
	a.DoGetDataI(&m)
}

// QueryMiddleGoodsDetail
// @Summary  查询套保品种详情(套保品种/商品详情)
// @Produce  json
// @Security    ApiKeyAuth
// @Param    userid        query    int true  "用户id"
// @Param    usertype      query    int false "用户类型 2-机构 7-企业成员"
// @Param    middlegoodsid query    int false "套保品种id"
// @Success  200           {array}  models.TBMiddleGoods
// @Failure  500           {object} app.Response
// @Router   /Ermcp3/QueryMiddleGoodsDetail [get]
// @Tags     企业风险管理v3(app)
func QueryMiddleGoodsDetail(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID        int64  `form:"userid" binding:"required"` // 所属机构id
		USERTYPE      int32  `form:"usertype"`                  // 用户类型
		MIDDLEGOODSID uint32 `form:"middlegoodsid"`             // 套保品种id
	}{}
	a.DoBindReq(&req)
	m := models.TBMiddleGoods{AREAUSERID: mtpcache.GetAreaUserId(req.USERID, req.USERTYPE),
		MIDDLEGOODSID: int64(req.MIDDLEGOODSID)}
	a.DoGetDataI(&m)
}

// QryContractReq 查询合同请求
type QryContractReq struct {
	AreadUserId    int64  `form:"userid"`         // 所属机构Id
	CONTRACTTYPE   int32  `form:"contracttype"`   // 合同类型 1-采购, -1-销售
	QUERYTYPE      int32  `form:"querytype"`      // 查询类型
	USERID         int64  `form:"userid"`         // 用户Id
	USERTYPE       int32  `form:"usertype"`       // 用户类型
	CONTRACTID     string `form:"contractid"`     // 合同ID(SpotContractId)
	CONTRACTNO     string `form:"contractno"`     // 现货合同编号
	WRSTANDARDNAME string `form:"wrstandardname"` // 品类名称
	STATUS         string `form:"status"`         // 状态
	ISTODAY        int32  `form:"istoday"`        // 今日
}

// QuerySpotContract
// @Summary  查询现货合同
// @Produce  json
// @Security    ApiKeyAuth
// @Param    userid         query    int    true  "用户id(当指定contractid, userid可不填)"
// @Param    usertype       query    int    false "用户类型 2-机构 7-企业成员"
// @Param    contracttype   query    int    false "合同类型 1-采购, -1-销售"
// @Param    querytype      query    string false "查询类型(逗号隔开, 如1,2,3) 1-未提交 2-待审核 3-履约中 4-已完成"
// @Param    contractid     query    string false "合同ID(SpotContractId)"
// @Param    contractno     query    string false "合同编号(模糊匹配)"
// @Param    wrstandardname query    string false "商品名称(模糊匹配)"
// @Param    status         query    string false "合同状态(当填写此项时,将忽略querytype条件;可多个,逗号隔开,如0,1,2) 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回"
// @Param    istoday        query    int    false "是否只查今日的合同  1-查今日合同"
// @Success  200            {array}  models.Ermcp3Contract
// @Failure  500            {object} app.Response
// @Router   /Ermcp3/QuerySpotContract [get]
// @Tags     企业风险管理v3(app)
func QuerySpotContract(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		AreadUserId    int64  `form:"userid"`         // 所属机构Id
		CONTRACTTYPE   int32  `form:"contracttype"`   // 合同类型 1-采购, -1-销售
		QUERYTYPE      string `form:"querytype"`      // 查询类型
		USERID         int64  `form:"userid"`         // 用户Id
		USERTYPE       int32  `form:"usertype"`       // 用户类型
		CONTRACTID     string `form:"contractid"`     // 合同ID(SpotContractId)
		CONTRACTNO     string `form:"contractno"`     // 现货合同编号
		WRSTANDARDNAME string `form:"wrstandardname"` // 品类名称
		STATUS         string `form:"status"`         // 状态
		ISTODAY        int32  `form:"istoday"`        // 今日
	}{}
	a.DoBindReq(&req)
	m := models.Ermcp3Contract{USERID: mtpcache.GetAreaUserId(req.USERID, req.USERTYPE),
		QryType: req.QUERYTYPE, CONTRACTTYPE: req.CONTRACTTYPE,
		OwnUserId: req.USERID, UserType: req.USERTYPE, SPOTCONTRACTID: req.CONTRACTID,
		CONTRACTNO: req.CONTRACTNO, WRSTANDARDNAME: req.WRSTANDARDNAME, STATUS: req.STATUS, ISTODAY: req.ISTODAY}
	a.DoGetDataI(&m)
}

// QuerySpotContractBS
// @Summary  查询合同(采购/销售)
// @Produce  json
// @Security    ApiKeyAuth
// @Param    userid       query    int    true  "用户id"
// @Param    usertype     query    int    false "用户类型 2-机构 7-企业成员"
// @Param    contracttype query    int    true  "合同类型 1-采购, -1-销售"
// @Param    querytype    query    int    false "查询类型 1-全部 2-待点价 3-履约结算 4-已完成"
// @Param    contractid   query    string false "合同ID(SpotContractId)"
// @Param    status       query    string false "合同状态(当填写此项时,将忽略querytype条件;可多个,逗号隔开,如0,1,2) 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回"
// @Param    istoday      query    int    false "是否只查今日的合同  1-查今日合同"
// @Success  200          {array}  models.Ermcp3SellBuyContract
// @Failure  500          {object} app.Response
// @Router   /Ermcp3/QuerySpotContractBS [get]
// @Tags     企业风险管理v3(app)
func QuerySpotContractBS(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := QryContractReq{}
	a.DoBindReq(&req)
	m := models.Ermcp3SellBuyContract{UserID: mtpcache.GetAreaUserId(req.USERID, req.USERTYPE),
		Contracttype: req.CONTRACTTYPE,
		OwnUserId:    req.USERID, UserType: req.USERTYPE,
		SpotContractId: req.CONTRACTID, QryType: req.QUERYTYPE,
		STATUS: req.STATUS, ISTODAY: req.ISTODAY}
	a.DoGetDataI(&m)
}

// QueryExposureDetail
// @Summary  查询敞口现货明细
// @Produce  json
// @Security    ApiKeyAuth
// @Param    userid        query    int true  "用户id"
// @Param    usertype      query    int false "用户类型 2-机构 7-企业成员"
// @Param    middlegoodsid query    int true  "套保商品"
// @Success  200           {array}  models.Ermcp3ExposureDetail
// @Failure  500           {object} app.Response
// @Router   /Ermcp3/QueryExposureDetail [get]
// @Tags     企业风险管理v3(app)
func QueryExposureDetail(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID        int64 `form:"userid" binding:"required"`        // 用户id
		USERTYPE      int32 `form:"usertype"`                         // 用户类型
		MIDDLEGOODSID int32 `form:"middlegoodsid" binding:"required"` // 套保商品id
	}{}
	a.DoBindReq(&req)
	m := models.Ermcp3ExposureDetail{Areauserid: req.USERID,
		MiddlegoodsId: req.MIDDLEGOODSID}
	a.DoGetDataI(&m)
}

// QueryExposureSpot
// @Summary  查询敞口现货头寸(敞口/现货头寸)
// @Produce  json
// @Security    ApiKeyAuth
// @Param    userid   query    int true  "用户id"
// @Param    usertype query    int false "用户类型 2-机构 7-企业成员"
// @Success  200      {array}  models.Ermcp3AreaSpot
// @Failure  500      {object} app.Response
// @Router   /Ermcp3/QueryExposureSpot [get]
// @Tags     企业风险管理v3(app)
func QueryExposureSpot(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID int64 `form:"userid" binding:"required"` // 用户id
	}{}
	a.DoBindReq(&req)
	// 交易员有敞口, 也是按交易员userid生成的, 不用转换为areauserid
	m := models.Ermcp3AreaSpot{AREAUSERID: req.USERID}
	a.DoGetDataI(&m)
}

// QueryExposureSpotDetail
// @Summary  查询敞口现货头寸明细(敞口/现货头寸/现货明细)
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid       query    int true  "用户id"
// @Param    usertype     query    int false "用户类型 2-机构 7-企业成员"
// @Param    wrstandardid query    int true  "现货商品ID"
// @Success  200          {array}  models.Ermcp3AreaSpotDetail
// @Failure  500          {object} app.Response
// @Router   /Ermcp3/QueryExposureSpotDetail [get]
// @Tags     企业风险管理v3(app)
func QueryExposureSpotDetail(c *gin.Context) {
	appG := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID       int64 `form:"userid" binding:"required"`       // 用户id
		USERTYPE     int32 `form:"usertype"`                        // 用户类型
		WRSTANDARDID int32 `form:"wrstandardid" binding:"required"` // 现货商品id
	}{}
	appG.DoBindReq(&req)
	m := models.Ermcp3AreaSpotDetail{UserId: req.USERID,
		WRSTANDARDID: req.WRSTANDARDID}
	appG.DoGetDataI(&m)
}

// QueryDGFactoryItem
// @Summary  查询品种要素定义项
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid              query    int false "用户id"
// @Param    usertype            query    int false "用户类型 2-机构 7-企业成员"
// @Param    dgfactoryitemid     query    int false "选择项ID(SEQ_DGFACTORYITEM)"
// @Param    deliverygoodsid     query    int false "现货品种ID"
// @Param    dgfactoryitemtypeid query    int false "要素项类型"
// @Param    orderindex          query    int false "顺序"
// @Success  200                 {array}  models.ErmcpDGFactoryItem
// @Failure  500                 {object} app.Response
// @Router   /Ermcp3/QueryDGFactoryItem [get]
// @Tags     企业风险管理v3(app)
func QueryDGFactoryItem(c *gin.Context) {
	appG := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID              int64 `form:"userid"`              // 用户id
		USERTYPE            int32 `form:"usertype"`            // 用户类型
		DGFACTORYITEMID     int64 `form:"dgfactoryitemid"`     // 选择项ID(SEQ_DGFACTORYITEM)
		DELIVERYGOODSID     int32 `form:"deliverygoodsid"`     // 现货品种ID
		DGFACTORYITEMTYPEID int64 `form:"dgfactoryitemtypeid"` // 要素项类型
		ORDERINDEX          int32 `form:"orderindex"`          // 顺序
	}{}
	appG.DoBindReq(&req)
	m := models.ErmcpDGFactoryItem{
		AREAUSERID:          mtpcache.GetAreaUserId(req.USERID, req.USERTYPE),
		DGFACTORYITEMID:     req.DGFACTORYITEMID,
		DELIVERYGOODSID:     req.DELIVERYGOODSID,
		DGFACTORYITEMTYPEID: req.DGFACTORYITEMTYPEID,
		ORDERINDEX:          req.ORDERINDEX,
	}
	appG.DoGetDataI(&m)
}

// QueryGoodsbrand
// @Summary  查询商品品牌
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid   query    int true  "用户id"
// @Param    usertype query    int false "用户类型 2-机构 7-企业成员"
// @Success  200      {array}  models.Ermcp3Brand
// @Failure  500      {object} app.Response
// @Router   /Ermcp3/QueryGoodsbrand [get]
// @Tags     企业风险管理v3(app)
func QueryGoodsbrand(c *gin.Context) {
	appG := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID          int64 `form:"userid"`          // 用户id
		USERTYPE        int32 `form:"usertype"`        // 用户类型
		DELIVERYGOODSID int64 `form:"deliverygoodsid"` // 现货品种ID
	}{}
	appG.DoBindReq(&req)
	m := models.Ermcp3Brand{
		AREAUSERID:      mtpcache.GetAreaUserId(req.USERID, req.USERTYPE),
		DELIVERYGOODSID: req.DELIVERYGOODSID,
	}
	appG.DoGetDataI(&m)
}

// QueryGoodsWrstandard
// @Summary  查询商品品类
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid          query    int true  "用户id"
// @Param    usertype        query    int false "用户类型 2-机构 7-企业成员"
// @Param    deliverygoodsid query    int false "现货商品id"
// @Success  200             {array}  models.Ermcp3Wrstandard
// @Failure  500             {object} app.Response
// @Router   /Ermcp3/QueryGoodsWrstandard [get]
// @Tags     企业风险管理v3(app)
func QueryGoodsWrstandard(c *gin.Context) {
	appG := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID          int64 `form:"userid" binding:"required"` // 用户id
		USERTYPE        int32 `form:"usertype"`                  // 用户类型
		DELIVERYGOODSID int32 `form:"deliverygoodsid"`           // 现货商品id
	}{}
	appG.DoBindReq(&req)
	m := models.Ermcp3Wrstandard{AREAUSERID: mtpcache.GetAreaUserId(req.USERID, req.USERTYPE),
		DELIVERYGOODSID: req.DELIVERYGOODSID}
	appG.DoGetDataI(&m)
}

// QueryAreaStockApply
// @Summary  查询库存申请(出入库记录|库存审核)
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid           query    int    true  "用户ID"
// @Param    usertype         query    int    false "用户类型 2-机构 7-企业成员"
// @Param    deliverygoodsid  query    int    false "现货商品ID"
// @Param    inouttype        query    string false "出入库类型(可多项,逗号隔开) 5:采购入库 6:销售出库 7:生产入库 8:生产出库"
// @Param    spotcontractid   query    int    false "合同ID"
// @Param    wrstandardid     query    int    false "品类ID"
// @Param    spotgoodsbrandid query    int    false "品牌ID"
// @Param    warehouseinfoid  query    int    false "仓库ID"
// @Param    applystatus      query    string false "申请状态(可多项,逗号隔开)1:待审核 2:审核通过 3:审核拒绝 4:处理失败 5:已撤回"
// @Success  200              {array}  models.Ermcp3AreaStockApply
// @Failure  500              {object} app.Response
// @Router   /Ermcp3/QueryAreaStockApply [get]
// @Tags     企业风险管理v3(app)
func QueryAreaStockApply(c *gin.Context) {
	a := app.NewGinUtils(c)
	req := struct {
		USERID           int64  `form:"userid" binding:"required"` // 用户
		WRSTANDARDID     int32  `form:"wrstandardid"`              // 品类
		SPOTGOODSBRANDID int32  `form:"spotgoodsbrandid"`          // 品牌
		SPOTCONTRACTID   string `form:"spotcontractid"`            // 合同id
		WAREHOUSEINFOID  string `form:"warehouseinfoid"`           // 仓库id
		DELIVERYGOODSID  int32  `form:"deliverygoodsid"`           // 现货商品id
		FilterStatus     string `form:"applystatus"`               // 申请状态
		FilterType       string `form:"inouttype"`                 // 出入库类型
		USERTYPE         int32  `form:"usertype"`                  // 用户类型
	}{}
	a.DoBindReq(&req)
	m := models.Ermcp3AreaStockApply{
		USERID:           req.USERID,
		FilterType:       req.FilterType,
		SPOTCONTRACTID:   req.SPOTCONTRACTID,
		WRSTANDARDID:     req.WRSTANDARDID,
		SPOTGOODSBRANDID: req.SPOTGOODSBRANDID,
		DELIVERYGOODSID:  req.DELIVERYGOODSID,
		WAREHOUSEINFOID:  req.WAREHOUSEINFOID,
		FilterStatus:     req.FilterStatus,
	}
	a.DoGetDataI(&m)
}

// QueryAreaStock
// @Summary  查询机构库存(库存管理/当前库存)
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid query    int true "用户ID"
// @Success  200    {array}  models.Ermcp3AreaStock
// @Failure  500    {object} app.Response
// @Router   /Ermcp3/QueryAreaStock [get]
// @Tags     企业风险管理v3(app)
func QueryAreaStock(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3AreaStock{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryAreaStockApplySum
// @Summary  查询已登记出入库信息(入库登记/已入库信息 | 出库登记/已出库信息)
// @Produce  json
// @Security ApiKeyAuth
// @Param    spotcontractid query    int true "合同ID"
// @Success  200            {array}  models.Ermcp3AreaStockApplySum
// @Failure  500            {object} app.Response
// @Router   /Ermcp3/QueryAreaStockApplySum [get]
// @Tags     企业风险管理v3(app)
func QueryAreaStockApplySum(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		SPOTCONTRACTID string `form:"spotcontractid" binding:"required"` // 合同id
	}{}
	a.DoBindReq(&req)
	m := models.Ermcp3AreaStockApplySum{SPOTCONTRACTID: req.SPOTCONTRACTID}
	a.DoGetDataI(&m)
}

// QuerySpotGoodsPrice
// @Summary  查询现货市价(现货市价)
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid query    int true "用户ID"
// @Success  200    {array}  models.Ermcp3SpotGoodsPrice
// @Failure  500    {object} app.Response
// @Router   /Ermcp3/QuerySpotGoodsPrice [get]
// @Tags     企业风险管理v3(app)
func QuerySpotGoodsPrice(c *gin.Context) {
	req := struct {
		UserId int64 `form:"userid" binding:"required"` // 用户id
	}{}
	a := app.GinUtils{Gin: app.Gin{C: c}}
	a.DoBindReq(&req)
	m := models.Ermcp3SpotGoodsPrice{AREAUSERID: req.UserId}
	a.DoGetDataI(&m)
}

// QuerySpotGoodsPriceLog
// @Summary  查询现货市价详情(现货市价/详情)
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid          query    int true  "用户ID"
// @Param    deliverygoodsid query    int true  "现货商品ID"
// @Param    brandid         query    int false "品牌ID"
// @Param    wrstandardid    query    int false "品类ID"
// @Success  200             {array}  models.Ermcp3SpotGoodsPriceLog
// @Failure  500             {object} app.Response
// @Router   /Ermcp3/QuerySpotGoodsPriceLog [get]
// @Tags     企业风险管理v3(app)
func QuerySpotGoodsPriceLog(c *gin.Context) {
	req := struct {
		UserId          int64 `form:"userid" binding:"required"`          // 用户id
		DELIVERYGOODSID int32 `form:"deliverygoodsid" binding:"required"` // 现货商品id
		WRSTANDARDID    int64 `form:"wrstandardid"`                       // 品类id
		BRANDID         int32 `form:"brandid"`                            // 品牌id
	}{}
	a := app.GinUtils{Gin: app.Gin{C: c}}
	a.DoBindReq(&req)
	m := models.Ermcp3SpotGoodsPriceLog{AREAUSERID: req.UserId,
		DELIVERYGOODSID: req.DELIVERYGOODSID, WRSTANDARDID: req.WRSTANDARDID, SPOTGOODSBRANDID: req.BRANDID}
	a.DoGetDataI(&m)
}

// QueryHedgePlan 查询套保计划
// @Summary  查询套保计划
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid          query    int    true  "用户ID"
// @Param    usertype        query    int    false "用户类型 2-机构 7-企业成员"
// @Param    hedgeplanstatus query    string true  "套保计划状态(允许多个，逗号隔开) - 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回"
// @Success  200             {array}  models.Ermcp3HedgePlan
// @Failure  500             {object} app.Response
// @Router   /Ermcp3/QueryHedgePlan [get]
// @Tags     企业风险管理v3(app)
func QueryHedgePlan(c *gin.Context) {
	appG := app.Gin{C: c}
	req := struct {
		UserId          int64  `form:"userid" binding:"required"`          // 用户id
		USERTYPE        int32  `form:"usertype"`                           // 用户类型
		HedgePlanStatus string `form:"hedgeplanstatus" binding:"required"` // 状态
	}{}
	if err := c.ShouldBind(&req); err != nil {
		logger.GetLogger().Errorf("query hedgeplanReq,%v", err)
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	var m = models.Ermcp3HedgePlan{Areauserid: req.UserId, UserType: req.USERTYPE}
	if d, err := m.GetData(req.HedgePlanStatus); err == nil {
		appG.Response(http.StatusOK, e.SUCCESS, d)
	} else {
		logger.GetLogger().Errorf("query fail, %v", err)
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
	}
}

// QueryGoodsGroup
// @Summary  查询期货商品组
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid     query    int true  "用户id"
// @Param    usertype   query    int false "用户类型 2-机构 7-企业成员"
// @Param    excludecfg query    int false "排除套保品中已关联的商品组 1-排除"
// @Success  200        {array}  models.Ermcp3GoodsGroup
// @Failure  500        {object} app.Response
// @Router   /Ermcp3/QueryGoodsGroup [get]
// @Tags     企业风险管理v3(app)
func QueryGoodsGroup(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID     int64 `form:"userid" binding:"required"` // 所属机构id
		USERTYPE   int32 `form:"usertype"`                  // 用户类型
		EXCLUDECFG int32 `form:"excludecfg"`                // 是否排除已配置
	}{}
	a.DoBindReq(&req)
	m := models.Ermcp3GoodsGroup{AreaUserId: mtpcache.GetAreaUserId(req.USERID, req.USERTYPE),
		ExcludeCfg: req.EXCLUDECFG}
	a.DoGetDataI(&m)
}

// QueryRootUserAccount
// @Summary  查询顶级用户信息
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid query    int true "用户ID"
// @Success  200    {array}  models.Ermcp3RootUserAccount
// @Failure  500    {object} app.Response
// @Router   /Ermcp3/QueryRootUserAccount [get]
// @Tags     企业风险管理v3(app)
func QueryRootUserAccount(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	req := struct {
		USERID int64 `form:"userid" binding:"required"` // 用户id
	}{}
	a.DoBindReq(&req)
	m := models.Ermcp3RootUserAccount{USERID: req.USERID}
	a.DoGetDataI(&m)
}

// QueryPaAreaSubject
// @Summary  查询交易主体
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid        query    int true  "用户id"
// @Param    subjectid     query    int false "主体ID(SEQ_ERMCP_PA_AREASUBJECT)"
// @Param    subjecttype   query    int false "主体类型 - 1:交易主体 2:业务部门"
// @Param    subjectstatus query    int false "主体状态 - 1:正常 2: 停用"
// @Success  200           {array}  models.Ermcp3PaAreaSubject
// @Failure  500           {object} app.Response
// @Router   /Ermcp3/QueryPaAreaSubject [get]
// @Tags     企业风险管理v3(app)
func QueryPaAreaSubject(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3PaAreaSubject{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryPaAreaAuditCfg
// @Summary  查询审核设置
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid query    int true "用户id"
// @Success  200    {array}  models.Ermcp3PaAreaAuditCfg
// @Failure  500    {object} app.Response
// @Router   /Ermcp3/QueryPaAreaAuditCfg [get]
// @Tags     企业风险管理v3(app)
func QueryPaAreaAuditCfg(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3PaAreaAuditCfg{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryPaTradeLink
// @Summary     查询期现单据关联
// @Description 页面 app 现货->期现关联->期现单据关联
// @Produce     json
// @Security ApiKeyAuth
// @Param       userid query    int true "用户ID"
// @Success     200    {array}  models.Ermcp3PaTradeLink
// @Failure     500    {object} app.Response
// @Router      /Ermcp3/QueryPaTradeLink [get]
// @Tags        企业风险管理v3(app)
func QueryPaTradeLink(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3PaTradeLink{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QuerySCMiddleGoods
// @Summary     查询现货订单
// @Description 页面 app 现货->期现关联->期现单据关联->点"关联"按钮->弹出界面 : 现货订单
// @Description 现货编号 即 合同编号
// @Produce     json
// @Security ApiKeyAuth
// @Param       userid         query    int    true  "用户ID(填登录用户的userid)"
// @Param       buyorsell      query    int    true  "买卖方向 0-买 1-卖"
// @Param       goodsgroupid   query    int    true  "商品组id"
// @Param       biztype        query    int    false "业务类型  1:套保 2:套利"
// @Param       contractno     query    string false "现货编号(模糊匹配)"
// @Param       customername   query    string false "对手方(模糊匹配)"
// @Param       wrstandardname query    string false "现货商品名称(模糊匹配)"
// @Success     200            {array}  models.Ermcp3SCMiddleGoods
// @Failure     500            {object} app.Response
// @Router      /Ermcp3/QuerySCMiddleGoods [get]
// @Tags        企业风险管理v3(app)
func QuerySCMiddleGoods(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3SCMiddleGoods{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryHPMiddleGoods
// @Summary  查询可关联套保计划
// @Produce  json
// @Security ApiKeyAuth
// @Param    userid         query    int    true  "用户ID(填登录用户的userid)"
// @Param    buyorsell      query    int    true  "买卖方向 0-买 1-卖"
// @Param    goodsgroupid   query    int    true  "商品组id"
// @Param    hedgeplanno    query    string false "套保计划编号(模糊匹配)"
// @Param    wrstandardname query    string false "现货商品名称(模糊匹配)"
// @Success  200            {array}  models.Ermcp3HPMiddleGoods
// @Failure  500            {object} app.Response
// @Router   /Ermcp3/QueryHPMiddleGoods [get]
// @Tags     企业风险管理v3(app)
func QueryHPMiddleGoods(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3HPMiddleGoods{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryPaTradeLinkDetail
// @Summary     查询期现关联记录
// @Description 页面 app 现货->期现关联->关联记录
// @Produce     json
// @Security ApiKeyAuth
// @Param       userid     query    int    true  "用户ID(填登录用户的userid)"
// @Param       linkstatus query    int    false "关联状态 1:成功 2:失败 3:解绑"
// @Param       tradeid    query    string false "期货订单号(模糊匹配)"
// @Param       contractno query    string false "现货编号(模糊匹配)"
// @Param       taname     query    string false "期货账户(模糊匹配)"
// @Success     200        {array}  models.Ermcp3TradeLinkDetail
// @Failure     500        {object} app.Response
// @Router      /Ermcp3/QueryPaTradeLinkDetail [get]
// @Tags        企业风险管理v3(app)
func QueryPaTradeLinkDetail(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3TradeLinkDetail{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryOutTradeLink
// @Summary     查询外部成交单关联
// @Description 页面 app 现货->期现关联->外部成交单关联
// @Produce     json
// @Security ApiKeyAuth
// @Param       userid        query    int    true  "用户ID(填登录用户的userid)"
// @Param       outtradeid    query    string false "外部订单号(模糊匹配)"
// @Param       goodsname     query    string false "合约名称/代码(模糊匹配)"
// @Param       hasinnerorder query    int    false "关联状态 0-未关联 1-已关联"
// @Success     200           {array}  models.Ermcp3OutTradeLink
// @Failure     500           {object} app.Response
// @Router      /Ermcp3/QueryOutTradeLink [get]
// @Tags        企业风险管理v3(app)
func QueryOutTradeLink(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3OutTradeLink{HASINNERORDER: -1}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QuerySubTaaccount
// @Summary     查询期货子账户
// @Description 页面 app 现货->期现关联->外部成交单关联->点"关联"按钮->选择期货子账户
// @Produce     json
// @Security ApiKeyAuth
// @Param       parentaccountid   query    int    false "母账号id"
// @Param       parentaccountcode query    string false "母账号代码"
// @Success     200               {array}  models.Ermcp3SubTaaccount
// @Failure     500               {object} app.Response
// @Router      /Ermcp3/QuerySubTaaccount [get]
// @Tags        企业风险管理v3(app)
func QuerySubTaaccount(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3SubTaaccount{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryInnerTradeLink
// @Summary     查询外部成交单关联的内部单信息(在解除外部关联页面使用)
// @Description 页面 app 现货->期现关联->外部成交单关联->点"解除关联"按钮->解除外部关联的页面信息
// @Produce     json
// @Security ApiKeyAuth
// @Param       outtradeid query    int true "外部成交单号"
// @Success     200        {array}  models.Ermcp3InnerTradeLink
// @Failure     500        {object} app.Response
// @Router      /Ermcp3/QueryInnerTradeLink [get]
// @Tags        企业风险管理v3(app)
func QueryInnerTradeLink(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3InnerTradeLink{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryParamChangeApp
// @Summary     查询现货商品参数变更申请(流水)
// @Description 原型页面:
// @Description 1.商品信息->商品参数修改流水-> 增值税税率 | 折算系数 | 成本权重; 流水页面查申请状态为“审核通过”的记录
// @Description 2.风管审核->套保比例审核 | 折算系数审核 | 增值税税率审核 | 成本权重审核
// @Produce     json
// @Security ApiKeyAuth
// @Param       userid          query    int    true  "用户ID"
// @Param       deliverygoodsid query    int    false "现货品种id"
// @Param       wrstandardid    query    int    false "现货商品id"
// @Param       middlegoodsid   query    int    false "套保商品id"
// @Param       operatetype     query    int    false "操作类型  1:新增 2:修改"
// @Param       paramchangetype query    int    false "参数变更类型 - 1:增值税率变更(现货商品) 2:折算系数变更(现货商品) 3:成本权重(现货商品) 4:套保比率变更(套保品种)"
// @Param       ftstatus        query    string false "申请状态(逗号隔开,如1,2,3) 1:待审核 2:审核通过 3:审核拒绝 4:处理失败 5:已撤回"
// @Success     200             {array}  models.Ermcp3ParamChangeApp
// @Failure     500             {object} app.Response
// @Router      /Ermcp3/QueryParamChangeApp [get]
// @Tags        企业风险管理v3(app)
func QueryParamChangeApp(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3ParamChangeApp{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}

// QueryErmcp3ContractMiddleGoodsCfg
// @Summary  查询现货合同期现配置信息
// @Produce  json
// @Security ApiKeyAuth
// @Param    spotcontractid query    string true "合同id"
// @Success  200            {array}  models.Ermcp3ContractMiddleGoodsCfg
// @Failure  500            {object} app.Response
// @Router   /Ermcp3/QueryErmcp3ContractMiddleGoodsCfg [get]
// @Tags     企业风险管理v3(app)
func QueryErmcp3ContractMiddleGoodsCfg(c *gin.Context) {
	a := app.GinUtils{Gin: app.Gin{C: c}}
	m := models.Ermcp3ContractMiddleGoodsCfg{}
	a.DoBindReq(&m)
	a.DoGetDataI(&m)
}