MTP20_IF/controllers/szdz/szdz.go

package szdz

import (
	"fmt"
	"mtp2_if/db"
	"mtp2_if/global/app"
	"mtp2_if/global/e"
	"mtp2_if/logger"
	"mtp2_if/models"
	"net/http"
	"sort"

	"github.com/gin-gonic/gin"
)

// QueryRecieptOrderReq 点选挂牌委托单据查询参数
type QueryRecieptOrderReq struct {
	app.PageInfo
	GoodsID     int    `form:"goodsID" binding:"required"` // 商品ID，必填
	BuyOrSell   int    `form:"buyorsell"`                  // 方向
	AccountName string `form:"accountName"`                // 所属账户名称
	MarketID    int    `form:"marketID"`                   // 市场ID
}

// QueryRecieptOrderRsp 点选挂牌委托单据查询返回模型
type QueryRecieptOrderRsp struct {
	Goodsid     int64   `json:"goodsid"  xorm:"'GOODSID'"`       // 商品ID
	Goodscode   string  `json:"goodscode"  xorm:"'GOODSCODE'"`   // 商品代码
	Goodsname   string  `json:"goodsname"  xorm:"'GOODSNAME'"`   // 商品名称
	Buyorsell   uint32  `json:"buyorsell"  xorm:"'BUYORSELL'"`   // 方向 - 0:买 1:卖
	Orderid     string  `json:"orderid"  xorm:"'ORDERID'"`       // 委托单号
	Tradedate   string  `json:"tradedate"  xorm:"'TRADEDATE'"`   // 交易日(yyyyMMdd)
	Orderprice  float64 `json:"orderprice"  xorm:"'ORDERPRICE'"` // 委托价格
	EnableQty   int64   `json:"enableqty" xorm:"ENABLEQTY"`      // 可摘数量
	AccountName string  `json:"accountName" xorm:"ACCOUNTNAME"`  // 所属账号名称（已脱敏）
	AccountID   int64   `json:"accountid" xorm:"ACCOUNTID"`      // 资金账号
}

// QueryRecieptOrder 点选挂牌委托单据查询（摘牌大厅）
// @Summary 点选挂牌委托单据查询（摘牌大厅）
// @Description 说明：pagesize参数赋值不为0时表示需要分页；page参数从0开始计算
// @Produce json
// @Security ApiKeyAuth
// @Param page query int false "页码"
// @Param pagesize query int false "每页条数"
// @Param goodsID query int true "商品ID"
// @Param accountName query string false "所属账户名称"
// @Param marketID query int false "市场ID"
// @Param buyorsell query int true "方向 - 0:买 1:卖"
// @Success 200 {object} QueryRecieptOrderRsp
// @Failure 500 {object} app.Response
// @Router /SZDZ/QueryRecieptOrder [get]
// @Tags 定制【尚志大宗】
// 参考通用查询：Client_SZDZ3_SearchRecieptOrder
func QueryRecieptOrder(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req QueryRecieptOrderReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("QueryRecieptOrder failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	datas := make([]QueryRecieptOrderRsp, 0)
	engine := db.GetEngine()

	// 投资者挂牌委托单
	s := engine.Table("TRADE_ORDERDETAIL").
		Join("INNER", "GOODS", "TRADE_ORDERDETAIL.GOODSID = GOODS.GOODSID").
		Join("LEFT", "TAACCOUNT", "TAACCOUNT.ACCOUNTID = TRADE_ORDERDETAIL.ACCOUNTID").
		Join("LEFT", "USERACCOUNT", "USERACCOUNT.USERID = TAACCOUNT.RELATEDUSERID").
		Select(`GOODS.GOODSID, GOODS.GOODSCODE, GOODS.GOODSNAME, 
				TRADE_ORDERDETAIL.BUYORSELL, to_char(TRADE_ORDERDETAIL.ORDERID) as ORDERID, TRADE_ORDERDETAIL.TRADEDATE, TRADE_ORDERDETAIL.ORDERPRICE, 
				TRADE_ORDERDETAIL.ORDERQTY - TRADE_ORDERDETAIL.TRADEQTY - TRADE_ORDERDETAIL.CANCELQTY as ENABLEQTY, 
				substr(USERACCOUNT.ACCOUNTNAME,0,1)||'****' as ACCOUNTNAME`).
		Where("TRADE_ORDERDETAIL.ORDERSTATUS in (3,7,12) and GOODS.GOODSID = ?", req.GoodsID)
	if len(req.AccountName) > 0 {
		s = s.And("USERACCOUNT.ACCOUNTNAME = ?", req.AccountName)
	}
	if req.MarketID > 0 {
		s = s.And("TRADE_ORDERDETAIL.MARKETID = ?", req.MarketID)
	}
	if req.BuyOrSell > -1 {
		s = s.And("TRADE_ORDERDETAIL.BUYORSELL = ?", req.BuyOrSell)
	}
	// 判断是否要分页
	// 这样分页会报错
	// if req.Size > 0 {
	// 	s = s.Limit(req.Size, req.Page*req.Size)
	// }
	d1 := make([]QueryRecieptOrderRsp, 0)
	if err := s.Find(&d1); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("QueryRecieptOrder failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}
	datas = append(datas, d1...)

	// 报价商挂牌委托
	s = engine.Table("TRADE_QUOTEDETAILNEW").
		Join("INNER", "GOODS", "TRADE_QUOTEDETAILNEW.GOODSID = GOODS.GOODSID").
		Join("INNER", "QUOTER", "QUOTER.QUOTERID = TRADE_QUOTEDETAILNEW.QUOTERID").
		Join("INNER", "AREAROLE", "AREAROLE.USERID = QUOTER.DEFAULTMAKERID and AREAROLE.ROLETYPE = 8").
		Select(`GOODS.GOODSID, GOODS.GOODSCODE, GOODS.GOODSNAME, 
				TRADE_QUOTEDETAILNEW.BUYORSELL, to_char(TRADE_QUOTEDETAILNEW.ORDERID) as ORDERID, TRADE_QUOTEDETAILNEW.TRADEDATE, TRADE_QUOTEDETAILNEW.PRICE as ORDERPRICE, 
				TRADE_QUOTEDETAILNEW.CURQTY as ENABLEQTY, 
				substr(QUOTER.QUOTERNAME,0,1)||'****' as ACCOUNTNAME`).
		Where("(TRADE_QUOTEDETAILNEW.CURQTY > 0 or TRADE_QUOTEDETAILNEW.PRICE > 0) and TRADE_QUOTEDETAILNEW.ISVALID != 1 and TRADE_QUOTEDETAILNEW.FREEZESTATUS != 3")
	d2 := make([]QueryRecieptOrderRsp, 0)
	if err := s.Find(&d2); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("QueryRecieptOrder failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}
	datas = append(datas, d2...)

	// 过滤相关账号下非买一卖一的单据（如买一卖一有多张单则都要显示）
	if req.BuyOrSell == 0 {
		// 买，先按价格倒序排列
		sort.Slice(datas, func(i int, j int) bool {
			return datas[i].Orderprice > datas[j].Orderprice
		})
	} else {
		// 卖，先按价格顺序排列
		sort.Slice(datas, func(i int, j int) bool {
			return datas[i].Orderprice < datas[j].Orderprice
		})
	}

	tmpDatas := make([]QueryRecieptOrderRsp, 0)
	for _, v := range datas {
		needAdd := true
		for _, t := range tmpDatas {
			if req.BuyOrSell == 0 {
				// 买
				if t.AccountID == v.AccountID && t.Buyorsell == v.Buyorsell && t.Orderprice > v.Orderprice {
					needAdd = false
				}
			} else {
				// 卖
				if t.AccountID == v.AccountID && t.Buyorsell == v.Buyorsell && t.Orderprice < v.Orderprice {
					needAdd = false
				}
			}
		}
		if needAdd {
			tmpDatas = append(tmpDatas, v)
		}
	}
	datas = tmpDatas

	total := len(datas)
	// FIXME: - 排序 & 分页
	// 排序
	sort.Slice(datas, func(i int, j int) bool {
		return datas[i].Tradedate > datas[j].Tradedate
	})
	// 分页
	if req.PageSize > 0 {
		// 开始上标
		start := req.Page * req.PageSize
		// 结束下标
		// a := []int{1,2,3,4,5}
		// a[2:4] -> [3 4]
		end := start + req.PageSize

		if start <= len(datas) {
			// 判断结束下标是否越界
			if end > len(datas) {
				end = len(datas)
			}
			datas = datas[start:end]
		} else {
			datas = make([]QueryRecieptOrderRsp, 0)
		}
	}

	// 查询成功返回
	logger.GetLogger().Infof("QueryRecieptOrder successed: %v", datas)
	if req.PageSize > 0 {
		// 分页
		appG.ResponseByPage(http.StatusOK, e.SUCCESS, datas, app.PageInfo{Page: req.Page, PageSize: req.PageSize, Total: total})
	} else {
		// 不分页
		appG.Response(http.StatusOK, e.SUCCESS, datas)
	}
}

// QueryGoodsPickupReq 商品提货单查询请求参数
type QueryGoodsPickupReq struct {
	AccountID       string `form:"accountID" binding:"required"`
	TakeOrderStatus int    `form:"takeOrderStatus"`
}

// QueryGoodsPickupRsp  商品提货单查询返回模型
type QueryGoodsPickupRsp struct {
	models.Szdz3goodspickup `xorm:"extends"`
	Goodscode               string `json:"goodscode"  xorm:"'GOODSCODE'"` // 商品代码
	Goodsname               string `json:"goodsname"  xorm:"'GOODSNAME'"` // 商品名称
}

// QueryGoodsPickup 商品提货单查询
// @Summary 商品提货单查询
// @Produce json
// @Security ApiKeyAuth
// @Param accountID query string true "资金账户 - 格式：1,2,3"
// @Param takeOrderStatus query int false "提货状态 - 1:待发货 2:已发货 3:已收货"
// @Success 200 {object} QueryGoodsPickupRsp
// @Failure 500 {object} app.Response
// @Router /SZDZ/QueryGoodsPickup [get]
// @Tags 定制【尚志大宗】
func QueryGoodsPickup(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req QueryGoodsPickupReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("QueryGoodsPickup failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	datas := make([]QueryGoodsPickupRsp, 0)
	engine := db.GetEngine()
	s := engine.Join("INNER", "GOODS", "GOODS.GOODSID = SZDZ3_GOODSPICKUP.GOODSID").
		Select("to_char(SZDZ3_GOODSPICKUP.TAKEORDERID) as TAKEORDERID, SZDZ3_GOODSPICKUP.*, GOODS.GOODSCODE, GOODS.GOODSNAME").
		Where(fmt.Sprintf(`SZDZ3_GOODSPICKUP.ACCOUNTID in (%s)`, req.AccountID)).
		Desc("SZDZ3_GOODSPICKUP.TAKEORDERID")
	if req.TakeOrderStatus > 0 {
		s = s.And("SZDZ3_GOODSPICKUP.TAKEORDERSTATUS = ?", req.TakeOrderStatus)
	}
	if err := s.Find(&datas); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("QueryGoodsPickup failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功返回
	logger.GetLogger().Infof("QueryGoodsPickup successed: %v", datas)
	appG.Response(http.StatusOK, e.SUCCESS, datas)
}

// QueryConvertLogReq 交易系统转换流水查询请求参数
type QueryConvertLogReq struct {
	AccountID string `form:"accountID" binding:"required"`
	StartDate string `form:"startDate"`
	EndDate   string `form:"endDate"`
}

// QueryConvertLogRsp 交易系统转换流水查询返回模型
type QueryConvertLogRsp struct {
	models.Szdz3convertlog `xorm:"extends"`
	Goodscode              string `json:"goodscode"  xorm:"'GOODSCODE'"` // 商品代码
	Goodsname              string `json:"goodsname"  xorm:"'GOODSNAME'"` // 商品名称
	QTY                    string `json:"qty"`                           // 数量
}

// QueryConvertLog 交易系统转换流水查询
// @Summary 交易系统转换流水查询
// @Produce json
// @Security ApiKeyAuth
// @Param accountID query string true "资金账户 - 格式：1,2,3"
// @Param startDate query string false "开始时间 - 闭区间，格式：yyyy-MM-dd HH:mm:ss"
// @Param endDate query string false "结束时间 - 闭区间，格式：yyyy-MM-dd HH:mm:ss"
// @Success 200 {object} QueryConvertLogRsp
// @Failure 500 {object} app.Response
// @Router /SZDZ/QueryConvertLog [get]
// @Tags 定制【尚志大宗】
func QueryConvertLog(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req QueryConvertLogReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("QueryConvertLog failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	datas := make([]QueryConvertLogRsp, 0)
	engine := db.GetEngine()
	s := engine.Join("INNER", "GOODS", "GOODS.GOODSID = SZDZ3_CONVERTLOG.INNERGOODSID").
		Select("SZDZ3_CONVERTLOG.*, GOODS.GOODSCODE, GOODS.GOODSNAME").
		Where(fmt.Sprintf(`SZDZ3_CONVERTLOG.HandleStatus = 1 and SZDZ3_CONVERTLOG.ACCOUNTID in (%s)`, req.AccountID)).
		Desc("SZDZ3_CONVERTLOG.LOGID")
	if len(req.StartDate) > 0 {
		s = s.And(fmt.Sprintf(`SZDZ3_CONVERTLOG.CREATETIME >= to_date('%s','yyyy-MM-dd hh24:mi:ss')`, req.StartDate))
	}
	if len(req.EndDate) > 0 {
		s = s.And(fmt.Sprintf(`SZDZ3_CONVERTLOG.CREATETIME <= to_date('%s','yyyy-MM-dd hh24:mi:ss')`, req.EndDate))
	}
	if err := s.Find(&datas); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("QueryConvertLog failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 计算数量
	for i, v := range datas {
		queryConvertLog := &datas[i]
		// 方向
		direction := "-"
		// 数量
		qty := v.Outvalue
		if v.Converttype == 1 || v.Converttype == 2 || v.Converttype == 5 {
			direction = "+"
			qty = v.Invalue
		}
		queryConvertLog.QTY = fmt.Sprintf("%s%v", direction, qty)
	}

	// 查询成功返回
	logger.GetLogger().Infof("QueryConvertLog successed: %v", datas)
	appG.Response(http.StatusOK, e.SUCCESS, datas)
}

// SearchWhiteReq 搜索白名单请求参数
type SearchWhiteReq struct {
	UserID int `form:"userID" binding:"required"`
}

// SearchWhite 搜索白名单
// @Summary 搜索白名单
// @Produce json
// @Security ApiKeyAuth
// @Param userID query int true "用户ID"
// @Success 200 {object} models.Szdz3searchwhitelist
// @Failure 500 {object} app.Response
// @Router /SZDZ/SearchWhite [get]
// @Tags 定制【尚志大宗】
func SearchWhite(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req SearchWhiteReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("SearchWhite failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	datas := make([]models.Szdz3searchwhitelist, 0)
	engine := db.GetEngine()
	if err := engine.Where("USERID = ?", req.UserID).Find(&datas); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("SearchWhite failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功返回
	logger.GetLogger().Infof("SearchWhite successed: %v", datas)
	appG.Response(http.StatusOK, e.SUCCESS, datas)
}

// QueryConvertConfigReq 查询交易系统转换设置请求参数
type QueryConvertConfigReq struct {
	ConvertType    int    `form:"convertType"`    // 转换类型 - 1:金点赞转交易 2:金点拍转交易 3:交易转金点赞(不设置) 4:交易转金点拍(不设置) 5:花生米转交易 6:交易转花生米(不设置)
	OuterGoodsCode string `form:"outerGoodsCode"` // 外部商品代码[JD\PD]
	InnerGoodsIDs  string `form:"innerGoodsIDs"`  // 内部商品ID列表[交易]
}

// QueryConvertConfig 查询交易系统转换设置
// @Summary 查询交易系统转换设置
// @Produce json
// @Security ApiKeyAuth
// @Param convertType query int false "转换类型 - 1:金点赞转交易 2:金点拍转交易 3:交易转金点赞(不设置) 4:交易转金点拍(不设置) 5:花生米转交易 6:交易转花生米(不设置)"
// @Param outerGoodsCode query string false "外部商品代码[JD\PD]"
// @Param innerGoodsIDs query string false "内部商品ID列表[交易]，格式：1,2,3"
// @Success 200 {object} models.Szdz3convertconfig
// @Failure 500 {object} app.Response
// @Router /SZDZ/QueryConvertConfig [get]
// @Tags 定制【尚志大宗】
func QueryConvertConfig(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req QueryConvertConfigReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("QueryConvertConfigReq failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	datas := make([]models.Szdz3convertconfig, 0)
	engine := db.GetEngine()
	s := engine.Table("SZDZ3_CONVERTCONFIG")
	if req.ConvertType > 0 {
		s = s.And("CONVERTTYPE = ?", req.ConvertType)
	}
	if len(req.OuterGoodsCode) > 0 {
		s = s.And("OUTERGOODSCODE = ?", req.OuterGoodsCode)
	}
	if len(req.InnerGoodsIDs) > 0 {
		s = s.And(fmt.Sprintf("INNERGOODSID in (%s)", req.InnerGoodsIDs))
	}
	if err := s.Find(&datas); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("QueryConvertConfigReq failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功返回
	logger.GetLogger().Infof("QueryConvertConfigReq successed: %v", datas)
	appG.Response(http.StatusOK, e.SUCCESS, datas)
}