MTP20_IF/models/ermcp8.go

package models

import (
	"fmt"
	"mtp2_if/db"
	"mtp2_if/logger"
	"mtp2_if/mtpcache"
	"mtp2_if/pb"
	"mtp2_if/rediscli"
	"mtp2_if/utils"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/golang/protobuf/proto"
)

// Ermcp2himiddlegoodsOrc 项目套保品种明细
type Ermcp2himiddlegoodsOrc struct {
	HEDGEDITEMID     int64     `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`         // 被套期项目ID(624+Unix秒时间戳(10位)+xxxxxx)
	MIDDLEGOODSID    int64     `json:"middlegoodsid"  xorm:"MIDDLEGOODSID"`       // 套保品种ID
	DELIVERYGOODSID  int64     `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`   // 现货品种ID
	WRSTANDARDID     int64     `json:"wrstandardid"  xorm:"WRSTANDARDID"`         // 现货商品ID
	VATRATE          float64   `json:"vatrate"  xorm:"VATRATE"`                   // 增值税
	SPOTCONVERTRATIO float64   `json:"spotconvertratio"  xorm:"SPOTCONVERTRATIO"` // 折算系数 [现货]
	UNEXESPOTQTY     float64   `json:"unexespotqty"  xorm:"UNEXESPOTQTY"`         // 未执行现货量
	UNEXEHEDGEQTY    float64   `json:"unexehedgeqty"  xorm:"UNEXEHEDGEQTY"`       // 未执行套期量 = 未执行现货量*折算系数* (1/(1+增值税)) * 套期比例(项目上)
	FUTUREHEDGEQTY   float64   `json:"futurehedgeqty"  xorm:"FUTUREHEDGEQTY"`     // 期货持仓套期量
	HIEXPSOURE       float64   `json:"hiexpsoure"  xorm:"HIEXPSOURE"`             // 期现敞口量 = 未执行套期量 + 期货持仓套期量
	TRADEUSERID      int64     `json:"tradeuserid"  xorm:"TRADEUSERID"`           // 交易用户ID
	AREAUSERID       int64     `json:"areauserid"  xorm:"AREAUSERID"`             // 企业ID
	CREATETIME       time.Time `json:"createtime"  xorm:"CREATETIME"`             // 创建时间
	UPDATETIME       time.Time `json:"updatetime"  xorm:"UPDATETIME"`             // 更新时间
}

// TableName is ERMCP2_HIMIDDLEGOODS
func (r *Ermcp2himiddlegoodsOrc) TableName() string {
	return "ERMCP2_HIMIDDLEGOODS"
}

// Ermcp2hedgeditem 被套期项目表
type Ermcp2hedgeditemOrc struct {
	HEDGEDITEMID        int64     `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`               // 被套期项目ID(624+Unix秒时间戳(10位)+xxxxxx)
	HEDGEDITEMNUM       string    `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM"`             // 项目编号
	HEDGEDITEMNAME      string    `json:"hedgeditemname"  xorm:"HEDGEDITEMNAME"`           // 项目名称
	HEDGEDTYPE          int32     `json:"hedgedtype"  xorm:"HEDGEDTYPE"`                   // 套期类型 - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	PLANSTARTDATE       time.Time `json:"planstartdate"  xorm:"PLANSTARTDATE"`             // 计划开始日期
	PLANENDDATE         time.Time `json:"planenddate"  xorm:"PLANENDDATE"`                 // 计划结束日期
	HEDGERATE           float64   `json:"hedgerate"  xorm:"HEDGERATE"`                     // 套期比率
	TRADEUSERID         int64     `json:"tradeuserid"  xorm:"TRADEUSERID"`                 // 交易用户ID
	AREAUSERID          int64     `json:"areauserid"  xorm:"AREAUSERID"`                   // 企业ID
	HEDGEDITEMSTATUS    int32     `json:"hedgeditemstatus"  xorm:"HEDGEDITEMSTATUS"`       // 项目状态 - 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回
	APPLYSRC            int32     `json:"applysrc"  xorm:"APPLYSRC"`                       // 申请来源 - 1:管理端 2:终端
	APPLYID             int64     `json:"applyid"  xorm:"APPLYID"`                         // 申请人
	REMARK              string    `json:"remark"  xorm:"REMARK"`                           // 备注
	CREATETIME          time.Time `json:"createtime"  xorm:"CREATETIME"`                   // 申请时间
	AUDITTRADEDATE      string    `json:"audittradedate"  xorm:"AUDITTRADEDATE"`           // 审核交易日(yyyyMMdd)
	AUDITID             int64     `json:"auditid"  xorm:"AUDITID"`                         // 审核人
	AUDITSRC            int32     `json:"auditsrc"  xorm:"AUDITSRC"`                       // 审核来源 - 1:管理端 2:终端
	AUDITTIME           time.Time `json:"audittime"  xorm:"AUDITTIME"`                     // 审核时间
	AUDITREMARK         string    `json:"auditremark"  xorm:"AUDITREMARK"`                 // 审核备注
	DELIVERYGOODSID     int64     `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`         // 现货品种ID
	WRSTANDARDID        int64     `json:"wrstandardid"  xorm:"WRSTANDARDID"`               // 现货商品ID
	VATRATE             float64   `json:"vatrate"  xorm:"VATRATE"`                         // 增值税
	HEDGEQTY            float64   `json:"hedgeqty"  xorm:"HEDGEQTY"`                       // 套期现货量
	HEDGEAMOUNT         float64   `json:"hedgeamount"  xorm:"HEDGEAMOUNT"`                 // 套期市价总额
	HEDGERESTAMOUNT     float64   `json:"hedgerestamount"  xorm:"HEDGERESTAMOUNT"`         // 套期剩余市价总额【现货贸易】
	HEDGECONTRACTAMOUNT float64   `json:"hedgecontractamount"  xorm:"HEDGECONTRACTAMOUNT"` // 套期定价总额 【定价采购合同】【现货贸易】
	ORIAVGPRICE         float64   `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                 // 期初市场均价 = 套期市价总额 / 套期现货量
	EXEQTY              float64   `json:"exeqty"  xorm:"EXEQTY"`                           // 执行现货量
	EXEAMOUNT           float64   `json:"exeamount"  xorm:"EXEAMOUNT"`                     // 执行市价总额
	EXERESTAMOUNT       float64   `json:"exerestamount"  xorm:"EXERESTAMOUNT"`             // 执行剩余市价总额【现货贸易】
	EXEAVGPRICE         float64   `json:"exeavgprice"  xorm:"EXEAVGPRICE"`                 // 执行市场均价= 执行市价总额 / 执行现货量
	EXECONTRACTAMOUNT   float64   `json:"execontractamount"  xorm:"EXECONTRACTAMOUNT"`     // 执行定价总额
	CURPRICE            float64   `json:"curprice"  xorm:"CURPRICE"`                       // 当前市场价
	UNEXEQTY            float64   `json:"unexeqty"  xorm:"UNEXEQTY"`                       // 未执行现货量 = 套期现货量 - 执行现货量
	SPOTHEDGEPL         float64   `json:"spothedgepl"  xorm:"SPOTHEDGEPL"`                 // 现货套期损益 =(执行市场均价-期初市场均价)*执行现货量 * 方向(销售计划 为 -1, 其它为1)
	SPOTPL              float64   `json:"spotpl"  xorm:"SPOTPL"`                           // 现货套期损益 = 现货实际损益 + 现货浮动损益
	FUTUREHEDGEPL       float64   `json:"futurehedgepl"  xorm:"FUTUREHEDGEPL"`             // 期货实际损益
	FUTUREPL            float64   `json:"futurepl"  xorm:"FUTUREPL"`                       // 期货套期损益
	HEDGESUMPL          float64   `json:"hedgesumpl"  xorm:"HEDGESUMPL"`                   // 套期汇总损益 = 期货汇总损益 + 现货汇总损益
	SPOTTRADEPL         float64   `json:"spottradepl"  xorm:"SPOTTRADEPL"`                 // 现货贸易损益【现货贸易】= 执行合同定价总额 - 套期合同定价总额
	VATPL               float64   `json:"vatpl"  xorm:"VATPL"`                             // 增值税损益【现货贸易】= 现货贸易损益 * （增值税率 /（1+增值税率））
	SUMOBSPL            float64   `json:"sumobspl"  xorm:"SUMOBSPL"`                       // 汇总绝对损益【现货贸易】=现货贸易损益+增值税损益+期货套期损益
	SPOTBOOKAMOUNT      float64   `json:"spotbookamount"  xorm:"SPOTBOOKAMOUNT"`           // 现货账面总额
	CURSTOCK            float64   `json:"curstock"  xorm:"CURSTOCK"`                       // 期末库存量 = 采购总量 - 销售总量
	ENDDATE             time.Time `json:"enddate"  xorm:"ENDDATE"`                         // 完成日期
	ENDTRADEDATE        string    `json:"endtradedate"  xorm:"ENDTRADEDATE"`               // 完成交易日
	UPDATETIME          time.Time `json:"updatetime"  xorm:"UPDATETIME"`                   // 更新时间
	ORISPOTHEDGEPL      float64   `json:"orispothedgepl"  xorm:"ORISPOTHEDGEPL"`           // 期初现货实际损益
	ORIFUTUREHEDGEPL    float64   `json:"orifuturehedgepl"  xorm:"ORIFUTUREHEDGEPL"`       // 期初期货实际损益
	ORISPOTPL           float64   `json:"orispotpl"  xorm:"ORISPOTPL"`                     // 期初现货套期损益
	ORIFUTUREPL         float64   `json:"orifuturepl"  xorm:"ORIFUTUREPL"`                 // 期初期货套期损益
	SPOTFLOATPL         float64   `json:"spotfloatpl"  xorm:"SPOTFLOATPL"`                 // 现货浮动损益 =(当前市场价 - 期初市场价)*未执行现货量 * 方向(销售计划 为 -1, 其它为1)
	FUTUREFLOATPL       float64   `json:"futurefloatpl"  xorm:"FUTUREFLOATPL"`             // 期货浮动损益
}

// TableName is ERMCP2_HEDGEDITEM
func (r *Ermcp2hedgeditemOrc) TableName() string {
	return "ERMCP2_HEDGEDITEM"
}

// Reckonermcp2hedgeditem 被套期项目日照表
type Reckonermcp2hedgeditem struct {
	RECKONDATE          string    `json:"reckondate"  xorm:"RECKONDATE"`                   // 日照时期(yyyyMMdd)
	HEDGEDITEMID        int64     `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`               // 被套期项目ID(624+Unix秒时间戳(10位)+xxxxxx)
	HEDGEDITEMNUM       string    `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM"`             // 项目编号
	HEDGEDITEMNAME      string    `json:"hedgeditemname"  xorm:"HEDGEDITEMNAME"`           // 项目名称
	HEDGEDTYPE          int32     `json:"hedgedtype"  xorm:"HEDGEDTYPE"`                   // 套期类型 - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	PLANSTARTDATE       time.Time `json:"planstartdate"  xorm:"PLANSTARTDATE"`             // 计划开始日期
	PLANENDDATE         time.Time `json:"planenddate"  xorm:"PLANENDDATE"`                 // 计划结束日期
	HEDGERATE           float64   `json:"hedgerate"  xorm:"HEDGERATE"`                     // 套期比率
	TRADEUSERID         int64     `json:"tradeuserid"  xorm:"TRADEUSERID"`                 // 交易用户ID
	AREAUSERID          int64     `json:"areauserid"  xorm:"AREAUSERID"`                   // 企业ID
	HEDGEDITEMSTATUS    int32     `json:"hedgeditemstatus"  xorm:"HEDGEDITEMSTATUS"`       // 项目状态 - 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回
	APPLYSRC            int32     `json:"applysrc"  xorm:"APPLYSRC"`                       // 申请来源 - 1:管理端 2:终端
	APPLYID             int64     `json:"applyid"  xorm:"APPLYID"`                         // 申请人
	REMARK              string    `json:"remark"  xorm:"REMARK"`                           // 备注
	CREATETIME          time.Time `json:"createtime"  xorm:"CREATETIME"`                   // 申请时间
	AUDITTRADEDATE      string    `json:"audittradedate"  xorm:"AUDITTRADEDATE"`           // 审核交易日(yyyyMMdd)
	AUDITID             int64     `json:"auditid"  xorm:"AUDITID"`                         // 审核人
	AUDITSRC            int32     `json:"auditsrc"  xorm:"AUDITSRC"`                       // 审核来源 - 1:管理端 2:终端
	AUDITTIME           time.Time `json:"audittime"  xorm:"AUDITTIME"`                     // 审核时间
	AUDITREMARK         string    `json:"auditremark"  xorm:"AUDITREMARK"`                 // 审核备注
	DELIVERYGOODSID     int64     `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`         // 现货品种ID
	WRSTANDARDID        int64     `json:"wrstandardid"  xorm:"WRSTANDARDID"`               // 现货商品ID
	VATRATE             float64   `json:"vatrate"  xorm:"VATRATE"`                         // 增值税
	HEDGEQTY            float64   `json:"hedgeqty"  xorm:"HEDGEQTY"`                       // 套期现货量
	HEDGEAMOUNT         float64   `json:"hedgeamount"  xorm:"HEDGEAMOUNT"`                 // 套期市价总额
	HEDGERESTAMOUNT     float64   `json:"hedgerestamount"  xorm:"HEDGERESTAMOUNT"`         // 套期剩余市价总额【现货贸易】
	HEDGECONTRACTAMOUNT float64   `json:"hedgecontractamount"  xorm:"HEDGECONTRACTAMOUNT"` // 套期定价总额 【定价采购合同】【现货贸易】
	ORIAVGPRICE         float64   `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                 // 期初市场均价 = 套期市价总额 / 套期现货量
	EXEQTY              float64   `json:"exeqty"  xorm:"EXEQTY"`                           // 执行现货量
	EXEAMOUNT           float64   `json:"exeamount"  xorm:"EXEAMOUNT"`                     // 执行市价总额
	EXERESTAMOUNT       float64   `json:"exerestamount"  xorm:"EXERESTAMOUNT"`             // 执行剩余市价总额【现货贸易】
	EXEAVGPRICE         float64   `json:"exeavgprice"  xorm:"EXEAVGPRICE"`                 // 执行市场均价= 执行市价总额 / 执行现货量
	EXECONTRACTAMOUNT   float64   `json:"execontractamount"  xorm:"EXECONTRACTAMOUNT"`     // 执行定价总额
	CURPRICE            float64   `json:"curprice"  xorm:"CURPRICE"`                       // 当前市场价
	UNEXEQTY            float64   `json:"unexeqty"  xorm:"UNEXEQTY"`                       // 未执行现货量 = 套期现货量 - 执行现货量
	SPOTHEDGEPL         float64   `json:"spothedgepl"  xorm:"SPOTHEDGEPL"`                 // 现货套期损益 =(执行市场均价-期初市场均价)*执行现货量 * 方向(销售计划 为 -1, 其它为1)
	SPOTPL              float64   `json:"spotpl"  xorm:"SPOTPL"`                           // 现货套期损益 = 现货实际损益 + 现货浮动损益
	FUTUREHEDGEPL       float64   `json:"futurehedgepl"  xorm:"FUTUREHEDGEPL"`             // 期货实际损益
	FUTUREPL            float64   `json:"futurepl"  xorm:"FUTUREPL"`                       // 期货套期损益
	HEDGESUMPL          float64   `json:"hedgesumpl"  xorm:"HEDGESUMPL"`                   // 套期汇总损益 = 期货汇总损益 + 现货汇总损益
	SPOTTRADEPL         float64   `json:"spottradepl"  xorm:"SPOTTRADEPL"`                 // 现货贸易损益【现货贸易】= 执行合同定价总额 - 套期合同定价总额
	VATPL               float64   `json:"vatpl"  xorm:"VATPL"`                             // 增值税损益【现货贸易】= 现货贸易损益 * （增值税率 /（1+增值税率））
	SUMOBSPL            float64   `json:"sumobspl"  xorm:"SUMOBSPL"`                       // 汇总绝对损益【现货贸易】=现货贸易损益+增值税损益+期货套期损益
	SPOTBOOKAMOUNT      float64   `json:"spotbookamount"  xorm:"SPOTBOOKAMOUNT"`           // 现货账面总额
	CURSTOCK            float64   `json:"curstock"  xorm:"CURSTOCK"`                       // 期末库存量 = 采购总量 - 销售总量
	ENDDATE             time.Time `json:"enddate"  xorm:"ENDDATE"`                         // 完成日期
	ENDTRADEDATE        string    `json:"endtradedate"  xorm:"ENDTRADEDATE"`               // 完成交易日
	UPDATETIME          time.Time `json:"updatetime"  xorm:"UPDATETIME"`                   // 更新时间
	ORISPOTHEDGEPL      float64   `json:"orispothedgepl"  xorm:"ORISPOTHEDGEPL"`           // 期初现货实际损益
	ORIFUTUREHEDGEPL    float64   `json:"orifuturehedgepl"  xorm:"ORIFUTUREHEDGEPL"`       // 期初期货实际损益
	ORISPOTPL           float64   `json:"orispotpl"  xorm:"ORISPOTPL"`                     // 期初现货套期损益
	ORIFUTUREPL         float64   `json:"orifuturepl"  xorm:"ORIFUTUREPL"`                 // 期初期货套期损益
	SPOTFLOATPL         float64   `json:"spotfloatpl"  xorm:"SPOTFLOATPL"`                 // 现货浮动损益 =(当前市场价 - 期初市场价)*未执行现货量 * 方向(销售计划 为 -1, 其它为1)
	FUTUREFLOATPL       float64   `json:"futurefloatpl"  xorm:"FUTUREFLOATPL"`             // 期货浮动损益
}

// TableName is RECKON_ERMCP2_HEDGEDITEM
func (r *Reckonermcp2hedgeditem) TableName() string {
	return "RECKON_ERMCP2_HEDGEDITEM"
}

// Reportermcp2hedgeditem 被套期项目报表表
type Reportermcp2hedgeditem struct {
	CYCLETIME           string    `json:"cycletime"  xorm:"CYCLETIME"`                     // 周期时间 月(YYYYMM)  季(YYYYQ) 年(YYYY) 周(YYYYIW) 全(0)【原值】
	CYCLETYPE           int32     `json:"cycletype"  xorm:"CYCLETYPE"`                     // 周期类型 - 1:月 2:季 3:年 4:周 5:全报表【原值】
	HEDGEDITEMID        int64     `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`               // 被套期项目ID(624+Unix秒时间戳(10位)+xxxxxx)
	HEDGEDITEMNUM       string    `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM"`             // 项目编号
	HEDGEDITEMNAME      string    `json:"hedgeditemname"  xorm:"HEDGEDITEMNAME"`           // 项目名称
	HEDGEDTYPE          int32     `json:"hedgedtype"  xorm:"HEDGEDTYPE"`                   // 套期类型 - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	PLANSTARTDATE       time.Time `json:"planstartdate"  xorm:"PLANSTARTDATE"`             // 计划开始日期
	PLANENDDATE         time.Time `json:"planenddate"  xorm:"PLANENDDATE"`                 // 计划结束日期
	HEDGERATE           float64   `json:"hedgerate"  xorm:"HEDGERATE"`                     // 套期比率
	TRADEUSERID         int64     `json:"tradeuserid"  xorm:"TRADEUSERID"`                 // 交易用户ID
	AREAUSERID          int64     `json:"areauserid"  xorm:"AREAUSERID"`                   // 企业ID
	HEDGEDITEMSTATUS    int32     `json:"hedgeditemstatus"  xorm:"HEDGEDITEMSTATUS"`       // 项目状态 - 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回
	APPLYSRC            int32     `json:"applysrc"  xorm:"APPLYSRC"`                       // 申请来源 - 1:管理端 2:终端
	APPLYID             int64     `json:"applyid"  xorm:"APPLYID"`                         // 申请人
	REMARK              string    `json:"remark"  xorm:"REMARK"`                           // 备注
	CREATETIME          time.Time `json:"createtime"  xorm:"CREATETIME"`                   // 申请时间
	AUDITTRADEDATE      string    `json:"audittradedate"  xorm:"AUDITTRADEDATE"`           // 审核交易日(yyyyMMdd)
	AUDITID             int64     `json:"auditid"  xorm:"AUDITID"`                         // 审核人
	AUDITSRC            int32     `json:"auditsrc"  xorm:"AUDITSRC"`                       // 审核来源 - 1:管理端 2:终端
	AUDITTIME           time.Time `json:"audittime"  xorm:"AUDITTIME"`                     // 审核时间
	AUDITREMARK         string    `json:"auditremark"  xorm:"AUDITREMARK"`                 // 审核备注
	DELIVERYGOODSID     int64     `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`         // 现货品种ID
	WRSTANDARDID        int64     `json:"wrstandardid"  xorm:"WRSTANDARDID"`               // 现货商品ID
	VATRATE             float64   `json:"vatrate"  xorm:"VATRATE"`                         // 增值税
	HEDGEQTY            float64   `json:"hedgeqty"  xorm:"HEDGEQTY"`                       // 套期现货量
	HEDGEAMOUNT         float64   `json:"hedgeamount"  xorm:"HEDGEAMOUNT"`                 // 套期市价总额
	HEDGERESTAMOUNT     float64   `json:"hedgerestamount"  xorm:"HEDGERESTAMOUNT"`         // 套期剩余市价总额【现货贸易】
	HEDGECONTRACTAMOUNT float64   `json:"hedgecontractamount"  xorm:"HEDGECONTRACTAMOUNT"` // 套期定价总额 【定价采购合同】【现货贸易】
	ORIAVGPRICE         float64   `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                 // 期初市场均价 = 套期市价总额 / 套期现货量
	EXEQTY              float64   `json:"exeqty"  xorm:"EXEQTY"`                           // 执行现货量
	EXEAMOUNT           float64   `json:"exeamount"  xorm:"EXEAMOUNT"`                     // 执行市价总额
	EXERESTAMOUNT       float64   `json:"exerestamount"  xorm:"EXERESTAMOUNT"`             // 执行剩余市价总额【现货贸易】
	EXEAVGPRICE         float64   `json:"exeavgprice"  xorm:"EXEAVGPRICE"`                 // 执行市场均价= 执行市价总额 / 执行现货量
	EXECONTRACTAMOUNT   float64   `json:"execontractamount"  xorm:"EXECONTRACTAMOUNT"`     // 执行定价总额
	CURPRICE            float64   `json:"curprice"  xorm:"CURPRICE"`                       // 当前市场价
	UNEXEQTY            float64   `json:"unexeqty"  xorm:"UNEXEQTY"`                       // 未执行现货量 = 套期现货量 - 执行现货量
	SPOTHEDGEPL         float64   `json:"spothedgepl"  xorm:"SPOTHEDGEPL"`                 // 现货套期损益 =(执行市场均价-期初市场均价)*执行现货量 * 方向(销售计划 为 -1, 其它为1)
	SPOTPL              float64   `json:"spotpl"  xorm:"SPOTPL"`                           // 现货套期损益 = 现货实际损益 + 现货浮动损益
	FUTUREHEDGEPL       float64   `json:"futurehedgepl"  xorm:"FUTUREHEDGEPL"`             // 期货实际损益
	FUTUREPL            float64   `json:"futurepl"  xorm:"FUTUREPL"`                       // 期货套期损益
	HEDGESUMPL          float64   `json:"hedgesumpl"  xorm:"HEDGESUMPL"`                   // 套期汇总损益 = 期货汇总损益 + 现货汇总损益
	SPOTTRADEPL         float64   `json:"spottradepl"  xorm:"SPOTTRADEPL"`                 // 现货贸易损益【现货贸易】= 执行合同定价总额 - 套期合同定价总额
	VATPL               float64   `json:"vatpl"  xorm:"VATPL"`                             // 增值税损益【现货贸易】= 现货贸易损益 * （增值税率 /（1+增值税率））
	SUMOBSPL            float64   `json:"sumobspl"  xorm:"SUMOBSPL"`                       // 汇总绝对损益【现货贸易】=现货贸易损益+增值税损益+期货套期损益
	SPOTBOOKAMOUNT      float64   `json:"spotbookamount"  xorm:"SPOTBOOKAMOUNT"`           // 现货账面总额
	CURSTOCK            float64   `json:"curstock"  xorm:"CURSTOCK"`                       // 期末库存量 = 采购总量 - 销售总量
	ENDDATE             time.Time `json:"enddate"  xorm:"ENDDATE"`                         // 完成日期
	ENDTRADEDATE        string    `json:"endtradedate"  xorm:"ENDTRADEDATE"`               // 完成交易日
	UPDATETIME          time.Time `json:"updatetime"  xorm:"UPDATETIME"`                   // 更新时间
	ORISPOTHEDGEPL      float64   `json:"orispothedgepl"  xorm:"ORISPOTHEDGEPL"`           // 期初现货实际损益
	ORIFUTUREHEDGEPL    float64   `json:"orifuturehedgepl"  xorm:"ORIFUTUREHEDGEPL"`       // 期初期货实际损益
	ORISPOTPL           float64   `json:"orispotpl"  xorm:"ORISPOTPL"`                     // 期初现货套期损益
	ORIFUTUREPL         float64   `json:"orifuturepl"  xorm:"ORIFUTUREPL"`                 // 期初期货套期损益
	SPOTFLOATPL         float64   `json:"spotfloatpl"  xorm:"SPOTFLOATPL"`                 // 现货浮动损益 =(当前市场价 - 期初市场价)*未执行现货量 * 方向(销售计划 为 -1, 其它为1)
	FUTUREFLOATPL       float64   `json:"futurefloatpl"  xorm:"FUTUREFLOATPL"`             // 期货浮动损益
}

// TableName is REPORT_ERMCP2_HEDGEDITEM
func (r *Reportermcp2hedgeditem) TableName() string {
	return "REPORT_ERMCP2_HEDGEDITEM"
}

// Ermcp2hedgeditem 被套期项目表
type Ermcp2hedgeditem struct {
	Hedgeditemid        string  `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`                                 // 被套期项目ID(624+Unix秒时间戳(10位)+xxxxxx)
	Hedgeditemnum       string  `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM"`                               // 项目编号
	Hedgeditemname      string  `json:"hedgeditemname"  xorm:"HEDGEDITEMNAME"`                             // 项目名称
	Hedgedtype          int32   `json:"hedgedtype"  xorm:"HEDGEDTYPE" form:"hedgedtype"`                   // 套期类型 - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	Planstartdate       string  `json:"planstartdate"  xorm:"PLANSTARTDATE"`                               // 计划开始日期
	Planenddate         string  `json:"planenddate"  xorm:"PLANENDDATE"`                                   // 计划结束日期
	Hedgerate           float64 `json:"hedgerate"  xorm:"HEDGERATE"`                                       // 套保比率
	Tradeuserid         int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`                                   // 交易用户ID
	Areauserid          int64   `json:"areauserid"  xorm:"AREAUSERID"`                                     // 企业ID
	Hedgeditemstatus    int32   `json:"hedgeditemstatus"  xorm:"HEDGEDITEMSTATUS" form:"hedgeditemstatus"` // 项目状态 - 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回
	Applysrc            int32   `json:"applysrc"  xorm:"APPLYSRC"`                                         // 申请来源 - 1:管理端 2:终端
	Applyid             int64   `json:"applyid"  xorm:"APPLYID"`                                           // 申请人
	Remark              string  `json:"remark"  xorm:"REMARK"`                                             // 备注
	Createtime          string  `json:"createtime"  xorm:"CREATETIME"`                                     // 申请时间
	Audittradedate      string  `json:"audittradedate"  xorm:"AUDITTRADEDATE"`                             // 审核交易日(yyyyMMdd)
	Auditid             int64   `json:"auditid"  xorm:"AUDITID"`                                           // 审核人
	Auditsrc            int32   `json:"auditsrc"  xorm:"AUDITSRC"`                                         // 审核来源 - 1:管理端 2:终端
	Audittime           string  `json:"audittime"  xorm:"AUDITTIME"`                                       // 审核时间
	Auditremark         string  `json:"auditremark"  xorm:"AUDITREMARK"`                                   // 审核备注
	Deliverygoodsid     int64   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`                           // 现货品种ID
	Wrstandardid        int64   `json:"wrstandardid"  xorm:"WRSTANDARDID"`                                 // 现货商品ID
	Vatrate             float64 `json:"vatrate"  xorm:"VATRATE"`                                           // 增值税
	Hedgeqty            float64 `json:"hedgeqty"  xorm:"HEDGEQTY"`                                         // 套期现货量
	Hedgeamount         float64 `json:"hedgeamount"  xorm:"HEDGEAMOUNT"`                                   // 套期市价总额
	Hedgerestamount     float64 `json:"hedgerestamount"  xorm:"HEDGERESTAMOUNT"`                           // 套期剩余市价总额【现货贸易】
	Hedgecontractamount float64 `json:"hedgecontractamount"  xorm:"HEDGECONTRACTAMOUNT"`                   // 套期定价总额 【定价采购合同】【现货贸易】
	Oriavgprice         float64 `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                                   // 期初市场均价 = 套期市价总额 / 套期现货量
	Exeqty              float64 `json:"exeqty"  xorm:"EXEQTY"`                                             // 执行现货量
	Exeamount           float64 `json:"exeamount"  xorm:"EXEAMOUNT"`                                       // 执行市价总额
	Exerestamount       float64 `json:"exerestamount"  xorm:"EXERESTAMOUNT"`                               // 执行剩余市价总额【现货贸易】
	Exeavgprice         float64 `json:"exeavgprice"  xorm:"EXEAVGPRICE"`                                   // 执行市场均价= 执行市价总额 / 执行现货量
	Execontractamount   float64 `json:"execontractamount"  xorm:"EXECONTRACTAMOUNT"`                       // 执行定价总额
	Curprice            float64 `json:"curprice"  xorm:"CURPRICE"`                                         // 当前市场价
	Unexeqty            float64 `json:"unexeqty"  xorm:"UNEXEQTY"`                                         // 未执行现货量 = 套期现货量 - 执行现货量
	Spothedgepl         float64 `json:"spothedgepl"  xorm:"SPOTHEDGEPL"`                                   // 现货套期损益 =(执行市场均价-期初市场均价)*执行现货量 * 方向(销售计划 为 -1, 其它为1)
	Spotpl              float64 `json:"spotpl"  xorm:"SPOTPL"`                                             // 现货套期损益 = 现货实际损益 + 现货浮动损益
	Futurehedgepl       float64 `json:"futurehedgepl"  xorm:"FUTUREHEDGEPL"`                               // 期货实际损益
	Futurepl            float64 `json:"futurepl"  xorm:"FUTUREPL"`                                         // 期货套期损益
	Hedgesumpl          float64 `json:"hedgesumpl"  xorm:"HEDGESUMPL"`                                     // 套期汇总损益 = 期货汇总损益 + 现货汇总损益
	Spottradepl         float64 `json:"spottradepl"  xorm:"SPOTTRADEPL"`                                   // 现货贸易损益【现货贸易】= 执行合同定价总额 - 套期合同定价总额
	Vatpl               float64 `json:"vatpl"  xorm:"VATPL"`                                               // 增值税损益【现货贸易】= 现货贸易损益 * （增值税率 /（1+增值税率））
	Sumobspl            float64 `json:"sumobspl"  xorm:"SUMOBSPL"`                                         // 汇总绝对损益【现货贸易】=现货贸易损益+增值税损益+期货套期损益
	Spotbookamount      float64 `json:"spotbookamount"  xorm:"SPOTBOOKAMOUNT"`                             // 现货账面总额
	Curstock            float64 `json:"curstock"  xorm:"CURSTOCK"`                                         // 期末库存量 = 采购总量 - 销售总量
	Enddate             string  `json:"enddate"  xorm:"ENDDATE"`                                           // 完成日期
	Endtradedate        string  `json:"endtradedate"  xorm:"ENDTRADEDATE"`                                 // 完成交易日
	Updatetime          string  `json:"updatetime"  xorm:"UPDATETIME"`                                     // 更新时间
	Orispothedgepl      float64 `json:"orispothedgepl"  xorm:"ORISPOTHEDGEPL"`                             // 期初现货实际损益
	Orifuturehedgepl    float64 `json:"orifuturehedgepl"  xorm:"ORIFUTUREHEDGEPL"`                         // 期初期货实际损益
	Orispotpl           float64 `json:"orispotpl"  xorm:"ORISPOTPL"`                                       // 期初现货套期损益
	Orifuturepl         float64 `json:"orifuturepl"  xorm:"ORIFUTUREPL"`                                   // 期初期货套期损益
	Spotfloatpl         float64 `json:"spotfloatpl"  xorm:"SPOTFLOATPL"`                                   // 现货浮动损益 =(当前市场价 - 期初市场价)*未执行现货量 * 方向(销售计划 为 -1, 其它为1)
	Futurefloatpl       float64 `json:"futurefloatpl"  xorm:"FUTUREFLOATPL"`                               // 期货浮动损益

	SpotHedgePLChange   float64 `json:"spothedgeplchange" xorm:"SPOTHEDGEPLCHANGE"`     // 现货实际损益变动
	SpotPLChange        float64 `json:"spotplchange" xorm:"SPOTPLCHANGE"`               // 现货套期损益变动
	FutureHedgePLChange float64 `json:"futurehedgeplchange" xorm:"FUTUREHEDGEPLCHANGE"` // 期货实际损益变动
	FuturePLChange      float64 `json:"futureplchange" xorm:"FUTUREPLCHANGE"`           // 期货套期损益变动

	Wrstandardname string `json:"wrstandardname" xorm:"WRSTANDARDNAME"` // 商品名称
	EnumdicName    string `json:"enumdicname"  xorm:"ENUMDICNAME"`      // 单位
	AccountName    string `json:"accountname" xorm:"ACCOUNTNAME"`       // 套期主体

	MiddleGoodsList []Ermcp2himiddlegoods `json:"middlegoodslist"` // 套期商品列表

	USERID int64 `json:"-" form:"userid" binding:"required"` // 用户id, 用于过滤
}

// TableName is ERMCP2_HEDGEDITEM
func (r *Ermcp2hedgeditem) TableName() string {
	return "ERMCP2_HEDGEDITEM"
}

func (r *Ermcp2hedgeditem) calc() {

}

func (r *Ermcp2hedgeditem) buildSql() string {
	var sqlId utils.SQLVal = `
		SELECT 
			to_char(t.HEDGEDITEMID) HEDGEDITEMID,
			t.HEDGEDITEMNUM      ,
			t.HEDGEDITEMNAME     ,
			t.HEDGEDTYPE         ,
			to_char(t.PLANSTARTDATE, 'yyyy-mm-dd') PLANSTARTDATE,
			to_char(t.PLANENDDATE, 'yyyy-mm-dd') PLANENDDATE,
			t.HEDGERATE          ,
			t.TRADEUSERID        ,
			t.AREAUSERID         ,
			t.HEDGEDITEMSTATUS   ,
			t.APPLYSRC           ,
			t.APPLYID            ,
			t.REMARK             ,
			to_char(t.CREATETIME, 'yyyy-mm-dd hh24:mi:ss') CREATETIME,
			t.AUDITTRADEDATE     ,
			t.AUDITID            ,
			t.AUDITSRC           ,
			to_char(t.AUDITTIME, 'yyyy-mm-dd hh24:mi:ss') AUDITTIME,
			t.AUDITREMARK        ,
			t.DELIVERYGOODSID    ,
			t.WRSTANDARDID       ,
			t.VATRATE            ,
			t.HEDGEQTY           ,
			t.HEDGEAMOUNT        ,
			t.HEDGERESTAMOUNT    ,
			t.HEDGECONTRACTAMOUNT,
			t.ORIAVGPRICE        ,
			t.EXEQTY             ,
			t.EXEAMOUNT          ,
			t.EXERESTAMOUNT      ,
			t.EXEAVGPRICE        ,
			t.EXECONTRACTAMOUNT  ,
			t.CURPRICE           ,
			t.UNEXEQTY           ,
			t.SPOTHEDGEPL        ,
			t.SPOTPL             ,
			t.FUTUREHEDGEPL      ,
			t.FUTUREPL           ,
			t.HEDGESUMPL         ,
			t.SPOTTRADEPL        ,
			t.VATPL              ,
			t.SUMOBSPL           ,
			t.SPOTBOOKAMOUNT     ,
			t.CURSTOCK           ,
			to_char(t.ENDDATE, 'yyyy-mm-dd') ENDDATE,
			t.ENDTRADEDATE       ,
			to_char(t.UPDATETIME, 'yyyy-mm-dd hh24:mi:ss') UPDATETIME,
			t.ORISPOTHEDGEPL     ,
			t.ORIFUTUREHEDGEPL   ,
			t.ORISPOTPL          ,
			t.ORIFUTUREPL        ,
			t.SPOTFLOATPL        ,
			t.FUTUREFLOATPL      ,
			(t.SpotHedgePL - t.OriSpotHedgePL) SPOTHEDGEPLCHANGE,
			(t.SpotPL - t.OriSpotPL) SPOTPLCHANGE,
			(t.FutureHedgePL - t.OriFutureHedgePL) FUTUREHEDGEPLCHANGE,
			(t.FuturePL - t.OriFuturePL) FUTUREPLCHANGE,
			wr.WRSTANDARDNAME,
			e.ENUMDICNAME,
			u.ACCOUNTNAME
		FROM ERMCP2_HedgedItem t
		LEFT JOIN WRStandard wr ON wr.wrstandardid = t.wrstandardid
		LEFT JOIN enumdicitem e on wr.unitid=e.enumitemname and e.enumdiccode='goodsunit'
		LEFT JOIN useraccount u ON u.userid = t.tradeuserid
		WHERE 1 = 1
   			AND %v in (t.AreaUserID, t.TradeUserID)
	`
	sqlId.FormatParam(r.USERID)
	sqlId.AndEx("t.Hedgedtype", r.Hedgedtype, r.Hedgedtype > 0)
	sqlId.AndEx("t.hedgeditemstatus", r.Hedgeditemstatus, r.Hedgeditemstatus > 0)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp2hedgeditem) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp2hedgeditem, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	hedgeditemid := 0
	for i := range sData {
		hedgeditemid, _ = strconv.Atoi(sData[i].Hedgeditemid)
		sData[i].calc()
	}

	if len(sData) > 0 {
		// 获取关联期货品种
		m1 := Ermcp2himiddlegoods{HEDGEDITEMID: int64(hedgeditemid)}
		if d1, err := m1.GetDataEx(); err == nil {
			gpLst := d1.([]Ermcp2himiddlegoods)
			for i := range sData {
				sData[i].MiddleGoodsList = append(sData[i].MiddleGoodsList, gpLst...)
			}
		}
	}

	return sData, nil
}

// Ermcp2himiddlegoods 项目套保品种明细
type Ermcp2himiddlegoods struct {
	HEDGEDITEMID     int64   `json:"hedgeditemid"  xorm:"HEDGEDITEMID" binding:"required"`   // 被套期项目ID(624+Unix秒时间戳(10位)+xxxxxx)
	MIDDLEGOODSID    int64   `json:"middlegoodsid"  xorm:"MIDDLEGOODSID" binding:"required"` // 套保品种ID
	DELIVERYGOODSID  int64   `json:"-"  xorm:"DELIVERYGOODSID"`                              // 现货品种ID
	WRSTANDARDID     int64   `json:"-"  xorm:"WRSTANDARDID"`                                 // 现货商品ID
	VATRATE          float64 `json:"-"  xorm:"VATRATE"`                                      // 增值税
	SPOTCONVERTRATIO float64 `json:"-"  xorm:"SPOTCONVERTRATIO"`                             // 折算系数 [现货]
	UNEXESPOTQTY     float64 `json:"-"  xorm:"UNEXESPOTQTY"`                                 // 未执行现货量
	UNEXEHEDGEQTY    float64 `json:"unexehedgeqty"  xorm:"UNEXEHEDGEQTY"`                    // 未执行套期量 = 未执行现货量*折算系数* (1/(1+增值税)) * 套期比例(项目上)
	FUTUREHEDGEQTY   float64 `json:"futurehedgeqty"  xorm:"FUTUREHEDGEQTY"`                  // 期货持仓套期量
	HIEXPSOURE       float64 `json:"hiexpsoure"  xorm:"HIEXPSOURE"`                          // 期现敞口量 = 未执行套期量 + 期货持仓套期量
	TRADEUSERID      int64   `json:"-"  xorm:"TRADEUSERID"`                                  // 交易用户ID
	AREAUSERID       int64   `json:"-"  xorm:"AREAUSERID"`                                   // 企业ID
	CREATETIME       string  `json:"-"  xorm:"CREATETIME"`                                   // 创建时间
	UPDATETIME       string  `json:"-"  xorm:"UPDATETIME"`                                   // 更新时间

	MIDDLEGOODSNAME string `json:"middlegoodsname"  xorm:"MIDDLEGOODSNAME"` // 套保商品名称
	Middlegoodscode string `json:"middlegoodscode"  xorm:"MIDDLEGOODSCODE"` // 套保商品代码
}

// TableName is ERMCP2_HIMIDDLEGOODS
func (r *Ermcp2himiddlegoods) TableName() string {
	return "ERMCP2_HIMIDDLEGOODS"
}

func (r *Ermcp2himiddlegoods) calc() {

}

func (r *Ermcp2himiddlegoods) buildSql() string {
	var sqlId utils.SQLVal = `
		SELECT 
			t.MIDDLEGOODSID,
			t.UNEXEHEDGEQTY,
			t.FUTUREHEDGEQTY,
			t.HIEXPSOURE,
			m.MIDDLEGOODSNAME,
			m.MIDDLEGOODSCODE
		FROM ERMCP2_HIMIDDLEGOODS t 
		LEFT JOIN erms_middlegoods m ON m.middlegoodsid = t.middlegoodsid
		WHERE t.HEDGEDITEMID = %v
	`
	sqlId.FormatParam(r.HEDGEDITEMID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp2himiddlegoods) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp2himiddlegoods, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Ermcpjrlinkpos 项目期货关联头寸
type Ermcpjrlinkpos struct {
	SPOTCONTRACTID      string    `json:"spotcontractid"  xorm:"SPOTCONTRACTID" form:"hedgeditemid" binding:"required"` // 现货ID [套期项目ID - 金瑞:合同\虚拟合同ID
	GOODSID             int32     `json:"goodsid"  xorm:"GOODSID"`                                                      // 期货合约
	ORDERTYPE           int32     `json:"ordertype"  xorm:"ORDERTYPE"`                                                  // 单据类型[套期工具] - 1:期货单 2:看涨期权单 3:看跌期权单
	EXECUTEPRICE        int64     `json:"executeprice"  xorm:"EXECUTEPRICE"`                                            // 执行价 - 1:期货单 为 0
	OPTIONCODE          string    `json:"optioncode"  xorm:"OPTIONCODE"`                                                // 期权代码
	AREAUSERID          int64     `json:"areauserid"  xorm:"AREAUSERID"`                                                // 所属企业
	TOTALBUYAMOUNT      float64   `json:"totalbuyamount"  xorm:"TOTALBUYAMOUNT"`                                        // 买金额 [期货]
	TOTALBUYQTY         float64   `json:"totalbuyqty"  xorm:"TOTALBUYQTY"`                                              // 买数量
	TOTALSELLAMOUNT     float64   `json:"totalsellamount"  xorm:"TOTALSELLAMOUNT"`                                      // 卖金额 [期货]
	TOTALSELLQTY        float64   `json:"totalsellqty"  xorm:"TOTALSELLQTY"`                                            // 卖数量
	NETQTY              float64   `json:"netqty"  xorm:"NETQTY"`                                                        // 净头寸
	TOTALCHARGE         float64   `json:"totalcharge"  xorm:"TOTALCHARGE"`                                              // 手续费
	TOTALPREMIUM        float64   `json:"totalpremium"  xorm:"TOTALPREMIUM"`                                            // 权利金 [期权]
	CLOSEPL             float64   `json:"closepl"  xorm:"CLOSEPL"`                                                      // 总平仓盈亏 [期货损益]
	UPDATETIME          time.Time `json:"updatetime"  xorm:"UPDATETIME"`                                                // 更新时间
	TOTALBUYHOLDAMOUNT  float64   `json:"totalbuyholdamount"  xorm:"TOTALBUYHOLDAMOUNT"`                                // 买持仓总金额[期货]
	TOTALSELLHOLDAMOUNT float64   `json:"totalsellholdamount"  xorm:"TOTALSELLHOLDAMOUNT"`                              // 卖持仓总金额[期货]
	TODAYFUTURECLOSEPL  float64   `json:"todayfutureclosepl"  xorm:"TODAYFUTURECLOSEPL"`                                // 今日平仓盈亏
	RECKONPL            float64   `json:"reckonpl"  xorm:"RECKONPL"`                                                    // 总盈亏(平仓盈亏 + 结算盈亏 - 手续费)

	Middlegoodsname string  `json:"middlegoodsname" xorm:"MIDDLEGOODSNAME"` // 套保商品名称
	Middlegoodscode string  `json:"middlegoodscode" xorm:"MIDDLEGOODSCODE"` // 套保商品代码
	FUTUREHEDGEQTY  float64 `json:"futurehedgeqty" xorm:"FUTUREHEDGEQTY"`   // 期货套期量

	AVERAGEPRICE float64 `json:"averageprice" xorm:"AVERAGEPRICE"` // 持仓均价 (TotalBuyHoldAmount - TotalSellHoldAmount) / NetQty
}

// TableName is ERMCP_JR_LINKPOS
func (r *Ermcpjrlinkpos) TableName() string {
	return "ERMCP_JR_LINKPOS"
}

func (r *Ermcpjrlinkpos) calc() {

}

func (r *Ermcpjrlinkpos) buildSql() string {
	var sqlId utils.SQLVal = `
		SELECT DISTINCT
			to_char(t.SPOTCONTRACTID) SPOTCONTRACTID,
			t.ORDERTYPE,
			t.OPTIONCODE,
			t.CLOSEPL,
			t.NETQTY,
			decode(t.NetQty, 0, 0, ((t.TotalBuyHoldAmount - t.TotalSellHoldAmount) / (t.NetQty * g.agreeunit))) AVERAGEPRICE,
			mg.middlegoodsname,
			mg.middlegoodscode,
			(t.NETQTY * gc.convertratio * g.agreeunit) FUTUREHEDGEQTY
		FROM ERMCP_JR_LinkPos t
		LEFT JOIN Goods g ON g.goodsid = t.goodsid
		LEFT JOIN ERMCP_GGConvertConfig gc on gc.srcgoodsgroupid = g.goodsgroupid
		LEFT JOIN ERMS_MiddleGoods mg ON mg.goodsgroupid = gc.destgoodsgroupid
		WHERE mg.areauserid = t.areauserid AND t.SPOTCONTRACTID = %v
		ORDER BY t.OPTIONCODE 
	`
	// 只有期货合约ID(GoodsID)的情况下获取套保商品名称，需要以上的关联
	sqlId.FormatParam(r.SPOTCONTRACTID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcpjrlinkpos) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcpjrlinkpos, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Ermcp2hedgeditemspot 项目计划明细
type Ermcp2hedgeditemspot struct {
	HEDGEDITEMSPOTID      string  `json:"hedgeditemspotid"  xorm:"HEDGEDITEMSPOTID"`                                // 现货明细ID(625+Unix秒时间戳(10位)+xxxxxx)
	HEDGEDITEMID          string  `json:"hedgeditemid"  xorm:"HEDGEDITEMID" form:"hedgeditemid" binding:"required"` // 被套期项目ID
	HEDGEDTYPE            int32   `json:"hedgedtype"  xorm:"HEDGEDTYPE"`                                            // 套期类型[计划类型] - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	SPOTTYPE              int32   `json:"spottype"  xorm:"SPOTTYPE"`                                                // 现货类型 - 1:采购计划 2:销售计划 3:采购合同 4:销售合同 5:库存存货
	RELATEDTYPE           int32   `json:"relatedtype"  xorm:"RELATEDTYPE"`                                          // 关联类型 - 1:套期关联 2:执行关联
	RELATEDHEDGEPLANID    int64   `json:"relatedhedgeplanid"  xorm:"RELATEDHEDGEPLANID"`                            // 关联计划ID 【1:采购计划 2:销售计划】
	RELATEDSPOTCONTRACTID int64   `json:"relatedspotcontractid"  xorm:"RELATEDSPOTCONTRACTID"`                      // 关联合同ID 【3:采购合同 4:销售合同】
	CUSTOMERUSERID        int64   `json:"customeruserid"  xorm:"CUSTOMERUSERID"`                                    // 对手方 【3:采购合同 4:销售合同】
	DELIVERYGOODSID       int64   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`                                  // 现货品种ID
	WRSTANDARDID          int64   `json:"wrstandardid"  xorm:"WRSTANDARDID"`                                        // 现货商品ID
	SPOTGOODSBRANDID      int32   `json:"spotgoodsbrandid"  xorm:"SPOTGOODSBRANDID"`                                // 现货品牌ID -  存“DGFactoryItem”表"DGFactoryItemID" = 2
	RELATEDQTY            float64 `json:"relatedqty"  xorm:"RELATEDQTY"`                                            // 关联数量[数量]
	ORIAVGPRICE           float64 `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                                          // 期初市场价[当初市场价]
	RELATEDAMOUNT         float64 `json:"relatedamount"  xorm:"RELATEDAMOUNT"`                                      // 市价总额 = 关联数量 * 期初市场价
	SPOTPRICEDAMOUNT      float64 `json:"spotpricedamount"  xorm:"SPOTPRICEDAMOUNT"`                                // 定价总额
	SPOTPRICEDAVGPRICE    float64 `json:"spotpricedavgprice"  xorm:"SPOTPRICEDAVGPRICE"`                            // 现货均价 = 定价总额 / 关联数量
	CREATETIME            string  `json:"createtime"  xorm:"CREATETIME"`                                            // 创建时间
	TRADEUSERID           int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`                                          // 交易用户ID
	AREAUSERID            int64   `json:"areauserid"  xorm:"AREAUSERID"`                                            // 企业ID

	Wrstandardname string `json:"wrstandardname" xorm:"WRSTANDARDNAME"` // 现货商品
	EnumdicName    string `json:"enumdicname"  xorm:"ENUMDICNAME"`      // 单位
	Hedgeplanno    string `json:"hedgeplanno"  xorm:"HEDGEPLANNO"`      // 计划编号
}

// TableName is ERMCP2_HEDGEDITEMSPOT
func (r *Ermcp2hedgeditemspot) TableName() string {
	return "ERMCP2_HEDGEDITEMSPOT"
}

func (r *Ermcp2hedgeditemspot) calc() {

}

func (r *Ermcp2hedgeditemspot) buildSql() string {
	var sqlId utils.SQLVal = `
		SELECT 
			to_char(t.hedgeditemspotid) HEDGEDITEMSPOTID,
			to_char(t.hedgeditemid) HEDGEDITEMID,
			t.HEDGEDTYPE,
			wr.WRSTANDARDNAME,
			e.ENUMDICNAME,
			t.RELATEDQTY,
			t.ORIAVGPRICE,
			s.HEDGEPLANNO,
			to_char(t.CREATETIME, 'yyyy-mm-dd hh24:mi:ss') CREATETIME
		FROM ERMCP2_HEDGEDITEMSPOT t
		LEFT JOIN WRStandard wr ON wr.wrstandardid = t.wrstandardid
		LEFT JOIN enumdicitem e on wr.unitid=e.enumitemname and e.enumdiccode='goodsunit'
		LEFT JOIN ermcp_hedgeplan s ON s.HedgePlanID = t.RELATEDHEDGEPLANID
		WHERE t.SPOTTYPE IN (1,2) AND t.hedgeditemid = %v
		ORDER BY t.createtime
	`
	sqlId.FormatParam(r.HEDGEDITEMID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp2hedgeditemspot) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp2hedgeditemspot, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Ermcp2hedgeditemspotDetail 现货成交明细
type Ermcp2hedgeditemspotDetail struct {
	HEDGEDITEMSPOTID      string  `json:"hedgeditemspotid"  xorm:"HEDGEDITEMSPOTID"`                                // 现货明细ID(625+Unix秒时间戳(10位)+xxxxxx)
	HEDGEDITEMID          string  `json:"hedgeditemid"  xorm:"HEDGEDITEMID" form:"hedgeditemid" binding:"required"` // 被套期项目ID
	HEDGEDTYPE            int32   `json:"hedgedtype"  xorm:"HEDGEDTYPE"`                                            // 套期类型[计划类型] - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	SPOTTYPE              int32   `json:"spottype"  xorm:"SPOTTYPE"`                                                // 现货类型[合同类型] - 1:采购计划 2:销售计划 3:采购合同 4:销售合同 5:库存存货
	RELATEDTYPE           int32   `json:"relatedtype"  xorm:"RELATEDTYPE"`                                          // 关联类型 - 1:套期关联 2:执行关联
	RELATEDHEDGEPLANID    int64   `json:"relatedhedgeplanid"  xorm:"RELATEDHEDGEPLANID"`                            // 关联计划ID 【1:采购计划 2:销售计划】
	RELATEDSPOTCONTRACTID int64   `json:"relatedspotcontractid"  xorm:"RELATEDSPOTCONTRACTID"`                      // 关联合同ID 【3:采购合同 4:销售合同】
	CUSTOMERUSERID        int64   `json:"customeruserid"  xorm:"CUSTOMERUSERID"`                                    // 对手方 【3:采购合同 4:销售合同】
	DELIVERYGOODSID       int64   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`                                  // 现货品种ID
	WRSTANDARDID          int64   `json:"wrstandardid"  xorm:"WRSTANDARDID"`                                        // 现货商品ID
	SPOTGOODSBRANDID      int32   `json:"spotgoodsbrandid"  xorm:"SPOTGOODSBRANDID"`                                // 现货品牌ID -  存“DGFactoryItem”表"DGFactoryItemID" = 2
	RELATEDQTY            float64 `json:"relatedqty"  xorm:"RELATEDQTY"`                                            // 关联数量[数量]
	ORIAVGPRICE           float64 `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                                          // 期初市场价[当初市场价]
	RELATEDAMOUNT         float64 `json:"relatedamount"  xorm:"RELATEDAMOUNT"`                                      // 市价总额 = 关联数量 * 期初市场价
	SPOTPRICEDAMOUNT      float64 `json:"spotpricedamount"  xorm:"SPOTPRICEDAMOUNT"`                                // 定价总额[金额]
	SPOTPRICEDAVGPRICE    float64 `json:"spotpricedavgprice"  xorm:"SPOTPRICEDAVGPRICE"`                            // 现货均价 = 定价总额 / 关联数量
	CREATETIME            string  `json:"createtime"  xorm:"CREATETIME"`                                            // 创建时间
	TRADEUSERID           int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`                                          // 交易用户ID
	AREAUSERID            int64   `json:"areauserid"  xorm:"AREAUSERID"`                                            // 企业ID

	Wrstandardname string `json:"wrstandardname" xorm:"WRSTANDARDNAME"` // 现货商品
	EnumdicName    string `json:"enumdicname"  xorm:"ENUMDICNAME"`      // 单位
	AccountName    string `json:"accountname" xorm:"ACCOUNTNAME"`       // 对手方
	BRANDNAME      string `json:"brandname"  xorm:"BRANDNAME"`          // 品牌
	CONTRACTNO     string `json:"contractno"  xorm:"CONTRACTNO"`        // 合同编号
}

func (r *Ermcp2hedgeditemspotDetail) calc() {

}

func (r *Ermcp2hedgeditemspotDetail) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT 
		to_char(t.hedgeditemspotid) HEDGEDITEMSPOTID,
		to_char(t.hedgeditemid) HEDGEDITEMID,
		to_char(t.CREATETIME, 'yyyy-mm-dd hh24:mi:ss') CREATETIME,
		t.SPOTTYPE,
		u.ACCOUNTNAME,
		wr.WRSTANDARDNAME,
		e.ENUMDICNAME,
		gb.dgfactoryitemvalue BRANDNAME,
		t.RELATEDQTY,
		t.SPOTPRICEDAVGPRICE,
		t.SPOTPRICEDAMOUNT,
		t.ORIAVGPRICE,
		s.CONTRACTNO
	FROM ERMCP2_HEDGEDITEMSPOT t
	LEFT JOIN useraccount u ON u.userid = t.CUSTOMERUSERID
	LEFT JOIN WRStandard wr ON wr.wrstandardid = t.wrstandardid
	LEFT JOIN enumdicitem e on wr.unitid=e.enumitemname and e.enumdiccode='goodsunit'
	LEFT JOIN dgfactoryitem gb ON gb.dgfactoryitemid = t.SPOTGOODSBRANDID
	LEFT JOIN ermcp_spotcontract s on s.spotcontractid = t.RELATEDSPOTCONTRACTID
	WHERE t.SPOTTYPE IN (3,4,5) AND t.hedgeditemid = %v
	ORDER BY t.createtime
	`
	sqlId.FormatParam(r.HEDGEDITEMID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp2hedgeditemspotDetail) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp2hedgeditemspotDetail, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Ermcppatradelinkdetail 期货成交单关联明细表
type Ermcppatradelinkdetail struct {
	LINKDETAILID   string  `json:"linkdetailid"  xorm:"LINKDETAILID"`                                          // 期货明细ID(614+Unix秒时间戳(10位)+xxxxxx)
	TRADEID        string  `json:"tradeid"  xorm:"TRADEID"`                                                    // [成交单号]内部成交单ID
	BUYORSELL      int32   `json:"buyorsell"  xorm:"BUYORSELL"`                                                // 方向 - 0:买 1:卖
	HEDGEFLAG      int32   `json:"hedgeflag"  xorm:"HEDGEFLAG"`                                                // 投机套保标志 - 0:无 1:投机 2:套保 3:套利 4:套期保值(平安\合同) 5:单边(平安) 6:移仓(平安) 7:错单处理(平安) 8:跨期套利(平安) 9:套期保值(计划) 10:套利(合同)  11:换月(合同)  12:交割(金瑞) 13:被套期项目
	SPOTCONTRACTID int64   `json:"hedgeditemid"  xorm:"SPOTCONTRACTID" form:"hedgeditemid" binding:"required"` // 现货ID[套期项目ID] [13 - 被套期项目ID] [4,10,11 - 现货合同ID]  [9 - 套保计划ID]
	RELATEDLOT     float64 `json:"relatedlot"  xorm:"RELATEDLOT"`                                              // [数量]关联手数
	GOODSID        int32   `json:"goodsid"  xorm:"GOODSID"`                                                    // 商品ID
	GOODSGROUPID   int32   `json:"goodsgroupid"  xorm:"GOODSGROUPID"`                                          // 对冲品种ID[期货合约商品组ID]
	MIDDLEGOODSID  int64   `json:"middlegoodsid"  xorm:"MIDDLEGOODSID"`                                        // 套保品种ID
	RELATEDQTY     float64 `json:"relatedqty"  xorm:"RELATEDQTY"`                                              // 关联数量 = RelatedLot * AgreeUnit * ConvertRatio
	TRADEDATE      string  `json:"tradedate"  xorm:"TRADEDATE"`                                                // 关联交易日(yyyyMMdd)
	RELATEDMODE    int32   `json:"relatedmode"  xorm:"RELATEDMODE"`                                            // 关联方式 - 1:自动关联 2:手动关联 3:解绑关联
	TRADETRADEDATE string  `json:"tradetradedate"  xorm:"TRADETRADEDATE"`                                      // 成交交易日(yyyyMMdd)
	TRADEPRICE     float64 `json:"tradeprice"  xorm:"TRADEPRICE"`                                              // [价格]成交价格
	TRADELOT       int64   `json:"tradelot"  xorm:"TRADELOT"`                                                  // 成交手数
	SALEUSERID     int64   `json:"saleuserid"  xorm:"SALEUSERID"`                                              // 业务员ID
	BIZSUBJECTID   int64   `json:"bizsubjectid"  xorm:"BIZSUBJECTID"`                                          // 归属业务部门ID - SubjectID
	AGREEUNIT      float64 `json:"agreeunit"  xorm:"AGREEUNIT"`                                                // 合约乘数
	CONVERTRATIO   float64 `json:"convertratio"  xorm:"CONVERTRATIO"`                                          // 品种系数
	AREAUSERID     int64   `json:"areauserid"  xorm:"AREAUSERID"`                                              // 所属机构
	CREATORSRC     int32   `json:"creatorsrc"  xorm:"CREATORSRC"`                                              // 创建人来源 - 1:管理端 2:终端 3:交易
	CREATORID      int64   `json:"creatorid"  xorm:"CREATORID"`                                                // 创建人ID
	CREATETIME     string  `json:"createtime"  xorm:"CREATETIME"`                                              // 创建时间
	LINKSTATUS     int32   `json:"linkstatus"  xorm:"LINKSTATUS"`                                              // 关联状态 - 1:成功 2:失败 3:解绑
	RETCODE        int32   `json:"retcode"  xorm:"RETCODE"`                                                    // 返回码

	TRADETIME  string  `json:"tradetime"  xorm:"TRADETIME"`   // 日期时间
	ORDERTYPE  int32   `json:"ordertype"  xorm:"ORDERTYPE"`   // 单据类型[套期工具] - 1:期货单 2:看涨期权单 3:看跌期权单
	OPTIONCODE string  `json:"optioncode"  xorm:"OPTIONCODE"` // [期货合约]期权代码 [期权]
	AMOUNT     float64 `json:"amount"  xorm:"AMOUNT"`         // 金额 = RelatedLot * TradePrice * AgreeUnit
	NAME       string  `json:"name" xorm:"NAME"`              // 账户名/子账户
}

func (r *Ermcppatradelinkdetail) calc() {

}

func (r *Ermcppatradelinkdetail) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT
		to_char(p.TRADETIME, 'yyyy-mm-dd hh24:mi:ss') TRADETIME,
		p.ORDERTYPE,
		p.OPTIONCODE,
		t.BUYORSELL,
		t.TRADEPRICE,
		t.RELATEDLOT,
		(t.RelatedLot * t.TradePrice * t.AgreeUnit) AMOUNT,
		to_char(t.TRADEID) TRADEID,
		(u.ACCOUNTNAME || '/' || to_char(p.ACCOUNTID)) NAME
	FROM ERMCP_PA_TradeLinkDetail t
	LEFT JOIN ERMCP_PA_TradeLink p ON p.TradeID = t.TradeID AND p.BuyorSell = t.BuyorSell
	LEFT JOIN TAACCOUNT ta ON ta.ACCOUNTID = p.ACCOUNTID
	LEFT JOIN USERACCOUNT u on u.userid = ta.relateduserid
	WHERE 
		t.HedgeFlag = 13 
	AND t.SpotContractID = %v
	AND t.relatedmode in (1,2) AND t.linkstatus = 1
	ORDER BY p.TradeTime
	`
	sqlId.FormatParam(r.SPOTCONTRACTID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcppatradelinkdetail) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcppatradelinkdetail, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// InternalUncorrelatedTradeDetail 内部未关联成交单
type InternalUncorrelatedTradeDetail struct {
	LINKDETAILID     string    `json:"linkdetailid"  xorm:"LINKDETAILID"`            // 期货明细ID(614+Unix秒时间戳(10位)+xxxxxx)
	TRADEID          string    `json:"tradeid"  xorm:"TRADEID" form:"tradeid"`       // 成交单号
	BUYORSELL        int32     `json:"buyorsell"  xorm:"BUYORSELL" form:"buyorsell"` // 方向 - 0:买 1:卖
	HEDGEFLAG        int32     `json:"hedgeflag"  xorm:"HEDGEFLAG"`                  // 投机套保标志 - 0:无 1:投机 2:套保 3:套利 4:套期保值(平安\合同) 5:单边(平安) 6:移仓(平安) 7:错单处理(平安) 8:跨期套利(平安) 9:套期保值(计划) 10:套利(合同)  11:换月(合同)  12:交割(金瑞) 13:被套期项目
	SPOTCONTRACTID   int64     `json:"hedgeditemid"  xorm:"SPOTCONTRACTID"`          // 现货ID[套期项目ID] [13 - 被套期项目ID] [4,10,11 - 现货合同ID]  [9 - 套保计划ID]
	RELATEDLOT       float64   `json:"relatedlot"  xorm:"RELATEDLOT"`                // [数量]关联手数
	GOODSID          int32     `json:"goodsid"  xorm:"GOODSID"`                      // 商品ID
	GOODSGROUPID     int32     `json:"goodsgroupid"  xorm:"GOODSGROUPID"`            // 对冲品种ID[期货合约商品组ID]
	MIDDLEGOODSID    int64     `json:"middlegoodsid"  xorm:"MIDDLEGOODSID"`          // 套保品种ID
	RELATEDQTY       float64   `json:"relatedqty"  xorm:"RELATEDQTY"`                // 关联数量 = RelatedLot * AgreeUnit * ConvertRatio
	TRADEDATE        string    `json:"tradedate"  xorm:"TRADEDATE"`                  // 关联交易日(yyyyMMdd)
	RELATEDMODE      int32     `json:"relatedmode"  xorm:"RELATEDMODE"`              // 关联方式 - 1:自动关联 2:手动关联 3:解绑关联
	TRADETRADEDATE   string    `json:"tradetradedate"  xorm:"TRADETRADEDATE"`        // 成交交易日(yyyyMMdd)
	TRADEPRICE       float64   `json:"tradeprice"  xorm:"TRADEPRICE"`                // 成交价
	TRADELOT         int64     `json:"tradelot"  xorm:"TRADELOT"`                    // 成交手数
	SALEUSERID       int64     `json:"saleuserid"  xorm:"SALEUSERID"`                // 业务员ID
	BIZSUBJECTID     int64     `json:"bizsubjectid"  xorm:"BIZSUBJECTID"`            // 归属业务部门ID - SubjectID
	AGREEUNIT        float64   `json:"agreeunit"  xorm:"AGREEUNIT"`                  // 合约乘数
	CONVERTRATIO     float64   `json:"convertratio"  xorm:"CONVERTRATIO"`            // 品种系数
	AREAUSERID       int64     `json:"areauserid"  xorm:"AREAUSERID"`                // 所属机构
	CREATORSRC       int32     `json:"creatorsrc"  xorm:"CREATORSRC"`                // 创建人来源 - 1:管理端 2:终端 3:交易
	CREATORID        int64     `json:"creatorid"  xorm:"CREATORID"`                  // 创建人ID
	CREATETIME       time.Time `json:"createtime"  xorm:"CREATETIME"`                // 创建时间
	LINKSTATUS       int32     `json:"linkstatus"  xorm:"LINKSTATUS"`                // 关联状态 - 1:成功 2:失败 3:解绑
	RETCODE          int32     `json:"retcode"  xorm:"RETCODE"`                      // 返回码
	ACCOUNTID        int64     `json:"accountid"  xorm:"ACCOUNTID"`                  // 账号ID
	CHANNELBUILDTYPE int32     `json:"channelbuildtype"  xorm:"CHANNELBUILDTYPE"`    // 委托单据类型 0:无 1:建仓 2:平仓
	MIDDLEGOODSQTY   float64   `json:"middlegoodsqty"  xorm:"MIDDLEGOODSQTY"`        // [套期商品数量]套保品种数量 = TradeQty * AgreeUnit * ConvertRatio

	TRADETIME   string  `json:"tradetime"  xorm:"TRADETIME"`                       // 成交时间
	ACCOUNTNAME string  `json:"accountname" xorm:"ACCOUNTNAME" form:"accountname"` // 套期主体
	ENABLEQTY   float64 `json:"enableqty" xorm:"ENABLEQTY"`                        // 项目可关联数量 = 套保品种数量 - 关联数量
	EnumdicName string  `json:"enumdicname"  xorm:"ENUMDICNAME"`                   // 单位
	TRADEUSERID int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`                   // 交易用户ID

	USERID    int64  `json:"-" form:"userid" binding:"required"`          // 用户编号
	BEGINDATE string `json:"-" form:"begindate"`                          // 起始日期, 格式：yyyymmdd
	ENDDATE   string `json:"-" form:"enddate"`                            // 终止日期, 格式：yyyymmdd
	GOODSCODE string `json:"goodscode" xorm:"GOODSCODE" form:"goodscode"` // 合约代码
	GOODSNAME string `json:"goodsname" xorm:"GOODSNAME" form:"goodsname"` // 合约名称
}

func (r *InternalUncorrelatedTradeDetail) calc() {

}

func (r *InternalUncorrelatedTradeDetail) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT 
		to_char(ept.TRADETIME, 'yyyy-mm-dd hh24:mi:ss') TRADETIME,
		ept.GOODSID,
		g.GOODSCODE,
		g.GOODSNAME,
		ept.BUYORSELL,
		ept.TRADEPRICE,
		ept.TRADELOT,
		ept.RELATEDQTY,
		ept.RELATEDLOT,
		ept.MIDDLEGOODSQTY,
		e.ENUMDICNAME,
		to_char(ept.TRADEID) TRADEID,
		ua.ACCOUNTNAME,
		ta.accountname TAACCOUNTNAME,
		ept.ACCOUNTID,
		ept.CHANNELBUILDTYPE,
		(ept.MIDDLEGOODSQTY - ept.RELATEDQTY) ENABLEQTY,
		ta.RELATEDUSERID TRADEUSERID
	FROM ERMCP_PA_TRADELINK ept
	LEFT JOIN goods g ON ept.goodsid = g.goodsid
	LEFT JOIN taaccount ta ON ta.accountid = ept.accountid
	LEFT JOIN useraccount ua ON ta.RELATEDUSERID = ua.userid
	LEFT JOIN enumdicitem e ON e.enumitemname = g.goodunitid AND e.enumdiccode = 'goodsunit'
	WHERE ept.tradelot > ept.relatedlot
	and ept.areauserid in
		(select u1.userid
			FROM useraccount u1
			start with u1.userid = %v
			connect by prior u1.userid = u1.parentuserid)
	`

	sqlId.FormatParam(r.USERID)
	if r.BEGINDATE != "" {
		sqlId.JoinFormat(" and to_char(ept.tradetime, 'yyyymmdd') >= '%v", r.BEGINDATE)
	}
	if r.ENDDATE != "" {
		sqlId.JoinFormat(" and to_char(ept.tradetime, 'yyyymmdd') <= '%v", r.ENDDATE)
	}
	sqlId.AndLike("g.goodscode", r.GOODSCODE)
	sqlId.AndLike("g.goodsname", r.GOODSNAME)
	sqlId.AndEx("ept.TRADEID", r.TRADEID, r.TRADEID != "")
	sqlId.AndEx("ept.BUYORSELL", r.BUYORSELL, r.BUYORSELL != -1)
	sqlId.AndLikes2("ta.accountname", "ta.accountid", r.ACCOUNTNAME)
	sqlId.OrderByDesc("ept.tradetime")

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *InternalUncorrelatedTradeDetail) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]InternalUncorrelatedTradeDetail, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// InternalEnableTradeDetail 内部成交单可关联项目
type InternalEnableTradeDetail struct {
	HEDGEDITEMNUM     string  `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM"`         // 项目编号
	Deliverygoodsid   int32   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`     // 现货品种ID(SEQ_DELIVERYGOODS)
	Deliverygoodscode string  `json:"deliverygoodscode"  xorm:"DELIVERYGOODSCODE"` // 现货品种代码
	Deliverygoodsname string  `json:"deliverygoodsname"  xorm:"DELIVERYGOODSNAME"` // 现货品种名称
	Wrstandardid      int64   `json:"wrstandardid"  xorm:"WRSTANDARDID"`           // 现货品类ID(SEQ_WRSTANDARD)
	Wrstandardcode    string  `json:"wrstandardcode"  xorm:"WRSTANDARDCODE"`       // 现货品类代码
	Wrstandardname    string  `json:"wrstandardname"  xorm:"WRSTANDARDNAME"`       // 现货品类名称
	UNEXESPOTQTY      float64 `json:"unexespotqty"  xorm:"UNEXESPOTQTY"`           // 未执行现货量
	UNEXEHEDGEQTY     float64 `json:"unexehedgeqty"  xorm:"UNEXEHEDGEQTY"`         // 未执行套期量 = 未执行现货量*折算系数* (1/(1+增值税)) * 套期比例(项目上)
	FUTUREHEDGEQTY    float64 `json:"futurehedgeqty"  xorm:"FUTUREHEDGEQTY"`       // [已关联数量]期货持仓套期量
	HEDGEDITEMID      string  `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`           // 被套期项目ID
	AGREEUNIT         float64 `json:"agreeunit"  xorm:"AGREEUNIT"`                 // 合约乘数
	CONVERTRATIO      float64 `json:"convertratio"  xorm:"CONVERTRATIO"`           // 品种系数

	AREAUSERID  int64 `json:"areauserid"  xorm:"AREAUSERID" form:"areauserid" binding:"required"` // 企业ID
	GOODSID     int64 `form:"goodsid" binding:"required"`                                         // 期货合约ID
	TRADEUSERID int64 `form:"tradeuserid" binding:"required"`                                     // 交易用户ID
}

func (r *InternalEnableTradeDetail) calc() {

}

func (r *InternalEnableTradeDetail) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT DISTINCT
		hi.HEDGEDITEMNUM,
		dg.DELIVERYGOODSID,
		dg.DELIVERYGOODSCODE,
		dg.DELIVERYGOODSNAME,
		wr.WRSTANDARDID,
		wr.WRSTANDARDCODE,
		wr.WRSTANDARDNAME,
		t.UNEXESPOTQTY,
		t.UNEXEHEDGEQTY,
		t.FUTUREHEDGEQTY,
		to_char(T.HEDGEDITEMID) HEDGEDITEMID,
		G.AGREEUNIT,
		GC.CONVERTRATIO
	FROM ERMCP2_HIMiddleGoods t
	LEFT JOIN ERMCP2_HedgedItem hi ON hi.HEDGEDITEMID = t.HEDGEDITEMID
	LEFT JOIN DeliveryGoods dg ON dg.DELIVERYGOODSID = t.DELIVERYGOODSID
	LEFT JOIN WRStandard wr ON wr.WRStandardID = t.WRStandardID
	LEFT JOIN ERMS_MiddleGoods mg ON mg.MIDDLEGOODSID = t.MIDDLEGOODSID
	LEFT JOIN ERMCP_GGConvertConfig gc ON gc.destgoodsgroupid = mg.goodsgroupid
	LEFT JOIN Goods g ON g.GOODSGROUPID = gc.SRCGOODSGROUPID
	WHERE 1 = 1 AND HI.HEDGEDITEMSTATUS IN (2)
	`
	sqlId.And("t.AREAUSERID", r.AREAUSERID)
	sqlId.And("g.GOODSID", r.GOODSID)
	sqlId.And("hi.TRADEUSERID", r.TRADEUSERID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *InternalEnableTradeDetail) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]InternalEnableTradeDetail, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Ermcp8HedgeditemReport 套期项目报表
type Ermcp8HedgeditemReport struct {
	HEDGEDTYPE          int32   `json:"hedgedtype"  xorm:"HEDGEDTYPE" form:"hedgedtype"`                   // 套期类型 - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	TRADEUSERID         int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`                                   // 交易用户ID
	AREAUSERID          int64   `json:"areauserid"  xorm:"AREAUSERID"`                                     // 企业ID
	HEDGEDITEMSTATUS    int32   `json:"hedgeditemstatus"  xorm:"HEDGEDITEMSTATUS" form:"hedgeditemstatus"` // 项目状态 - 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回
	HEDGEDITEMNUM       string  `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM" form:"hedgeditemnum"`          // 项目编号，模糊查询
	WRSTANDARDID        int64   `json:"wrstandardid"  xorm:"WRSTANDARDID" form:"wrstandardid"`             // 现货商品ID
	Wrstandardcode      string  `json:"wrstandardcode"  xorm:"WRSTANDARDCODE"`                             // 现货品类代码
	Wrstandardname      string  `json:"wrstandardname"  xorm:"WRSTANDARDNAME"`                             // [现货商品]现货品类名称
	HEDGEQTY            float64 `json:"hedgeqty"  xorm:"HEDGEQTY"`                                         // [套期数量]套期现货量
	ORIAVGPRICE         float64 `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                                   // [期初价]期初市场均价 = 套期市价总额 / 套期现货量
	HEDGEAMOUNT         float64 `json:"hedgeamount"  xorm:"HEDGEAMOUNT"`                                   // [套期现货金额]套期市价总额
	EXEQTY              float64 `json:"exeqty"  xorm:"EXEQTY"`                                             // [执行数量]执行现货量
	EXEAVGPRICE         float64 `json:"exeavgprice"  xorm:"EXEAVGPRICE"`                                   // [执行价]执行市场均价= 执行市价总额 / 执行现货量
	EXEAMOUNT           float64 `json:"exeamount"  xorm:"EXEAMOUNT"`                                       // [执行现货金额]执行市价总额
	FUTUREHEDGEPL       float64 `json:"futurehedgepl"  xorm:"FUTUREHEDGEPL"`                               // 期货实际损益
	FUTUREHEDGEPLCHANGE float64 `json:"futurehedgeplchange"  xorm:"FUTUREHEDGEPLCHANGE"`                   // 期货实际变动 = 期货实际损益 - 期初期货实际损益
	FUTUREPL            float64 `json:"futurepl"  xorm:"FUTUREPL"`                                         // 期货套期损益
	FUTUREPLCHANGE      float64 `json:"futureplchange"  xorm:"FUTUREPLCHANGE"`                             // 期货套期变动 = 期货套期损益 - 期初期货套期损益
	SPOTHEDGEPL         float64 `json:"spothedgepl"  xorm:"SPOTHEDGEPL"`                                   // 现货实际损益 =(执行市场均价-期初市场均价)*执行现货量 * 方向(销售计划 为 -1, 其它为1)
	SPOTHEDGEPLCHANGE   float64 `json:"spothedgeplchange"  xorm:"SPOTHEDGEPLCHANGE"`                       // 现货实际变动 = 现货实际损益 - 期初现货实际损益
	SPOTPL              float64 `json:"spotpl"  xorm:"SPOTPL"`                                             // 现货套期损益 = 现货实际损益 + 现货浮动损益
	SPOTPLCHANGE        float64 `json:"spotplchange"  xorm:"SPOTPLCHANGE"`                                 // 现货套期变动 = 现货套期损益 - 期初现货套期损益
	UNEXEQTY            float64 `json:"unexeqty"  xorm:"UNEXEQTY"`                                         // 未执行现货量 = 套期现货量 - 执行现货量
	CURPRICE            float64 `json:"curprice"  xorm:"CURPRICE"`                                         // [当日现货市场价]当前市场价
	PLANSTARTDATE       string  `json:"planstartdate"  xorm:"PLANSTARTDATE"`                               // 计划开始日期
	PLANENDDATE         string  `json:"planenddate"  xorm:"PLANENDDATE"`                                   // 计划结束日期
	ORISPOTHEDGEPL      float64 `json:"orispothedgepl"  xorm:"ORISPOTHEDGEPL"`                             // 期初现货实际损益
	ORIFUTUREHEDGEPL    float64 `json:"orifuturehedgepl"  xorm:"ORIFUTUREHEDGEPL"`                         // 期初期货实际损益
	ORISPOTPL           float64 `json:"orispotpl"  xorm:"ORISPOTPL"`                                       // 期初现货套期损益
	ORIFUTUREPL         float64 `json:"orifuturepl"  xorm:"ORIFUTUREPL"`                                   // 期初期货套期损益

	EnumdicName string `json:"enumdicname"  xorm:"ENUMDICNAME"` // 单位
	AccountName string `json:"accountname" xorm:"ACCOUNTNAME"`  // 套期主体

	USERID    int64  `json:"-" form:"userid" binding:"required"`    // 用户ID
	CYCLETYPE int32  `json:"-" form:"cycletype"`                    // 周期类型 - 0:日 1:月 2:季 3:年 4:周 5:全报表【原值】
	CYCLETIME string `json:"-" form:"cycletime" binding:"required"` // 周期时间 日(YYYYMMDD) 月(YYYYMM) 季(YYYYQ) 年(YYYY) 周(YYYYMMDD周内任意一天) 全(0)【原值】
}

func (r *Ermcp8HedgeditemReport) calc() {

}

func (r *Ermcp8HedgeditemReport) buildSql() string {
	if r.CYCLETYPE == 0 {
		// 日
		return r.buildReckonSql()
	} else {
		// 周、月
		return r.buildReportSql()
	}
}

func (r *Ermcp8HedgeditemReport) buildReckonSql() string {
	var sqlId utils.SQLVal = `
	SELECT
		t.HEDGEDTYPE,
		t.TRADEUSERID,
		t.AREAUSERID,
		t.HEDGEDITEMSTATUS,
		t.HEDGEDITEMNUM,
		wr.WRSTANDARDID,
		wr.WRSTANDARDCODE,
		wr.WRSTANDARDNAME,
		t.HEDGEQTY,
		t.ORIAVGPRICE,
		t.HEDGEAMOUNT,
		t.EXEQTY,
		t.EXEAVGPRICE,
		t.EXEAMOUNT,
		t.FUTUREHEDGEPL,
		(t.FUTUREHEDGEPL - t.ORIFUTUREHEDGEPL) FUTUREHEDGEPLCHANGE,
		t.FUTUREPL,
		(t.FUTUREPL - t.ORIFUTUREPL) FUTUREPLCHANGE,
		t.SPOTHEDGEPL,
		(t.SPOTHEDGEPL - t.ORISPOTHEDGEPL) SPOTHEDGEPLCHANGE,
		t.SPOTPL,
		(t.SPOTPL - t.ORISPOTPL) SPOTPLCHANGE,
		t.UNEXEQTY,
		t.CURPRICE,
		to_char(t.PLANSTARTDATE, 'yyyy-mm-dd') PLANSTARTDATE,
		to_char(t.PLANENDDATE, 'yyyy-mm-dd') PLANENDDATE,
		e.ENUMDICNAME,
		u.ACCOUNTNAME
	FROM Reckon_ERMCP2_HedgedItem t
	LEFT JOIN WRStandard wr ON wr.WRStandardID = t.WRStandardID
	LEFT JOIN WRStandard wr ON wr.wrstandardid = t.wrstandardid
	LEFT JOIN enumdicitem e on wr.unitid=e.enumitemname and e.enumdiccode='goodsunit'
	LEFT JOIN useraccount u ON u.userid = t.tradeuserid
	WHERE (t.TRADEUSERID = %v OR t.AREAUSERID = %v)
	`
	sqlId.FormatParam(r.USERID, r.USERID)
	sqlId.And("t.RECKONDATE", r.CYCLETIME)
	sqlId.AndEx("t.HEDGEDTYPE", r.HEDGEDTYPE, r.HEDGEDTYPE > 0)
	sqlId.AndEx("t.HEDGEDITEMSTATUS", r.HEDGEDITEMSTATUS, r.HEDGEDITEMSTATUS > 0)
	sqlId.AndLike("t.HEDGEDITEMNUM", r.HEDGEDITEMNUM)
	sqlId.AndEx("t.WRSTANDARDID", r.WRSTANDARDID, r.WRSTANDARDID > 0)

	return sqlId.String()
}

func (r *Ermcp8HedgeditemReport) buildReportSql() string {
	var sqlId utils.SQLVal = `
	SELECT
		t.HEDGEDTYPE,
		t.TRADEUSERID,
		t.AREAUSERID,
		t.HEDGEDITEMSTATUS,
		t.HEDGEDITEMNUM,
		wr.WRSTANDARDID,
		wr.WRSTANDARDCODE,
		wr.WRSTANDARDNAME,
		t.HEDGEQTY,
		t.ORIAVGPRICE,
		t.HEDGEAMOUNT,
		t.EXEQTY,
		t.EXEAVGPRICE,
		t.EXEAMOUNT,
		t.FUTUREHEDGEPL,
		(t.FUTUREHEDGEPL - t.ORIFUTUREHEDGEPL) FUTUREHEDGEPLCHANGE,
		t.FUTUREPL,
		(t.FUTUREPL - t.ORIFUTUREPL) FUTUREPLCHANGE,
		t.SPOTHEDGEPL,
		(t.SPOTHEDGEPL - t.ORISPOTHEDGEPL) SPOTHEDGEPLCHANGE,
		t.SPOTPL,
		(t.SPOTPL - t.ORISPOTPL) SPOTPLCHANGE,
		t.UNEXEQTY,
		t.CURPRICE,
		to_char(t.PLANSTARTDATE, 'yyyy-mm-dd') PLANSTARTDATE,
		to_char(t.PLANENDDATE, 'yyyy-mm-dd') PLANENDDATE,
		e.ENUMDICNAME,
		u.ACCOUNTNAME
	FROM REPORT_ERMCP2_HEDGEDITEM t
	LEFT JOIN WRStandard wr ON wr.WRStandardID = t.WRStandardID
	LEFT JOIN enumdicitem e on wr.unitid=e.enumitemname and e.enumdiccode='goodsunit'
	LEFT JOIN useraccount u ON u.userid = t.tradeuserid
	WHERE (t.TRADEUSERID = %v OR t.AREAUSERID = %v)
	`
	sqlId.FormatParam(r.USERID, r.USERID)
	// 过滤周期类型
	if r.CYCLETYPE == 1 {
		// 月
		sqlId.And("t.cycletype", 1)
		sqlId.And("t.CYCLETIME", r.CYCLETIME)
	} else if r.CYCLETYPE == 4 {
		// 周
		// 获取查询日期的当前周
		sqlId.And("t.cycletype", 4)
		sqlId.And("t.CYCLETIME", mtpcache.GetWeekIW(r.CYCLETIME))
	}
	sqlId.AndEx("t.HEDGEDTYPE", r.HEDGEDTYPE, r.HEDGEDTYPE > 0)
	sqlId.AndEx("t.HEDGEDITEMSTATUS", r.HEDGEDITEMSTATUS, r.HEDGEDITEMSTATUS > 0)
	sqlId.AndLike("t.HEDGEDITEMNUM", r.HEDGEDITEMNUM)
	sqlId.AndEx("t.WRSTANDARDID", r.WRSTANDARDID, r.WRSTANDARDID > 0)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp8HedgeditemReport) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp8HedgeditemReport, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// 查询现货合同
type QrySpotContractExReq struct {
	USERID       int64  `form:"userid" binding:"required"` // 用户ID
	PRICETYPE    int32  `form:"pricetype"`                 // 定价类型 - 1:一口价 2:点价 3:暂定价
	CONTRACTNO   string `form:"contractno"`                // 合同编号, 模拟查询
	CUSTOMERNAME string `form:"customername"`              // 对手方, 模拟查询
	CONTRACTTYPE int32  `form:"contracttype"`              // 合同类型 - 1:采购 -1:销售
}

// ErmcpSpotContractModelEx 现货合同结构（对应现货合同菜单)
type ErmcpSpotContractModelEx struct {
	SPOTCONTRACTID    string  `json:"spotcontractid"  xorm:"SPOTCONTRACTID"`       // 现货合同ID(602+Unix秒时间戳(10位)+xxxxxx)
	CONTRACTNO        string  `json:"contractno"  xorm:"CONTRACTNO"`               // [合同编号]现货合同编号
	CONTRACTTYPE      int32   `json:"contracttype"  xorm:"CONTRACTTYPE"`           // [合同类型]现货合同类型 - 1:采购 -1:销售
	USERID            int64   `json:"userid"  xorm:"USERID"`                       // 机构ID
	BUYUSERID         int64   `json:"buyuserid"  xorm:"BUYUSERID"`                 // 采购方ID
	BUYUSERName       string  `json:"buyusername"  xorm:"BUYUSERName"`             // 采购方名称
	SELLUSERID        int64   `json:"selluserid"  xorm:"SELLUSERID"`               // 销售方ID
	SELLUSERNAME      string  `json:"sellusername"  xorm:"SELLUSERNAME"`           // 销售方名称
	DELIVERYGOODSID   int32   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`     // 现货品种ID
	WRSTANDARDID      int32   `json:"wrstandardid"  xorm:"wrstandardid"`           // 现货商品ID
	WRSTANDARDNAME    string  `json:"wrstandardname"  xorm:"WRSTANDARDNAME"`       // [现货商品]现货商品名称
	WRSTANDARDCODE    string  `json:"wrstandardcode"  xorm:"WRSTANDARDCODE"`       // 现货商品代码
	DELIVERYGOODSCODE string  `json:"deliverygoodscode"  xorm:"DELIVERYGOODSCODE"` // 现货品种代码
	DELIVERYGOODSNAME string  `json:"deliverygoodsname"  xorm:"DELIVERYGOODSNAME"` // 现货品种名称
	PRODUCTTYPE       int32   `json:"producttype"  xorm:"PRODUCTTYPE"`             // 产品类型 - 1:标准仓单 2:等标 3:非标
	CONVERTFACTOR     float64 `json:"convertfactor"  xorm:"CONVERTFACTOR"`         // 标仓系数
	SPOTGOODSDESC     string  `json:"spotgoodsdesc"  xorm:"SPOTGOODSDESC"`         // 商品型号
	PRICETYPE         int32   `json:"pricetype"  xorm:"PRICETYPE"`                 // 定价类型 - 1:一口价 2:点价 3:暂定价
	QTY               float64 `json:"qty"  xorm:"QTY"`                             // [合同数量]数量
	PRICE             float64 `json:"price"  xorm:"PRICE"`                         // 价格\暂定价 [1:一口价、3:暂定价]
	AMOUNT            float64 `json:"amount"  xorm:"AMOUNT"`                       // 金额 [1:一口价、3:暂定价]
	DELIVERYSTARTDATE string  `json:"deliverystartdate"  xorm:"DELIVERYSTARTDATE"` // 交收期(开始)
	DELIVERYENDDATE   string  `json:"deliveryenddate"  xorm:"DELIVERYENDDATE"`     // 交收期(结束)
	GOODSID           int32   `json:"goodsid"  xorm:"GOODSID"`                     // 点价合约ID - 0:为现货，其它为期货商品合约ID [2:点价 3:暂定价]
	GOODSCODE         string  `json:"goodscode"  xorm:"GOODSCODE"`                 // 点价合约代码
	GOODSNAME         string  `json:"goodsname"  xorm:"GOODSNAME"`                 // 点价商品名称
	PRICEMOVE         float64 `json:"pricemove"  xorm:"PRICEMOVE"`                 // 升贴水 [2:点价 3:暂定价]
	STARTDATE         string  `json:"startdate"  xorm:"STARTDATE"`                 // 点价开始日期 [2:点价 3:暂定价]
	ENDDATE           string  `json:"enddate"  xorm:"ENDDATE"`                     // 点价结束日期 [2:点价 3:暂定价]
	MARGIN            float64 `json:"margin"  xorm:"MARGIN"`                       // 当前保证金
	CONTRACTMARGIN    float64 `json:"contractmargin"  xorm:"CONTRACTMARGIN"`       // 合同保证金
	EnumdicName       string  `json:"enumdicname"  xorm:"ENUMDICNAME"`             // 单位名称
	CONTRACCTSTATUS   int32   `json:"contracctstatus"  xorm:"CONTRACTSTATUS"`      // 合同状态 - 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回
	Remark            string  `json:"remark"  xorm:"Remark"`                       // 备注
	AUDITREMARK       string  `json:"auditremark"  xorm:"AUDITREMARK"`             // 审核意见
	AUDITTIME         string  `json:"audittime"  xorm:"AUDITTIME"`                 // 审核时间
	CREATETIME        string  `json:"createtime"  xorm:"CREATETIME"`               // 创建时间
	UPDATETIME        string  `json:"updatetime"  xorm:"UPDATETIME"`               // 更新时间
	SPOTGOODSMODELID  int32   `json:"spotgoodsmodelid"  xorm:"SPOTGOODSMODELID"`   // 现货型号ID
	SPOTGOODSBRANDID  int32   `json:"spotgoodsbrandid"  xorm:"SPOTGOODSBRANDID"`   // 现货品牌ID
	BRANDNAME         string  `json:"brandname"  xorm:"brandname"`                 // 品牌名称
	MODELNAME         string  `json:"modelname"  xorm:"modelname"`                 // 型号名称
	ATTACHMENT        string  `json:"attachment"  xorm:"ATTACHMENT"`               // 附件
	PRICEDQTY         float64 `json:"pricedqty"  xorm:"PRICEDQTY"`                 // 已定价量
	PRICEDAMOUNT      float64 `json:"pricedamount"  xorm:"PRICEDAMOUNT"`           // 已定价金额 = (点价价格+升贴水) * 数量
	SPOTAMOUNT        float64 `json:"spotamount"  xorm:"SPOTAMOUNT"`               // 合同现货金额 [不含升贴水]
	TRADEUSERID       int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`             // 交易用户ID
	CUSTOMERUSERID    int64   `json:"customeruserid"  xorm:"CUSTOMERUSERID"`       // 客户ID
	ISRELATED         int32   `json:"isrelated"  xorm:"ISRELATED"`                 // 是否已关联计划项目 - 0:否 1:是
	ISRELATED2        int32   `json:"isrelated2"  xorm:"ISRELATED2"`               // 是否已关联现货项目 - 0:否 1:是

	ACCOUNTNAME  string `json:"accountname" xorm:"ACCOUNTNAME"`   // 套期主体
	CUSTOMERNAME string `json:"customername" xorm:"CUSTOMERNAME"` // 对手方

	UNPRICEDQTY  float64 `json:"unpricedqty" xorm:"UNPRICEDQTY"`   // 未定价量 = 合同数量 - 已定价量
	AVGPRICE     float64 `json:"avgprice" xorm:"AVGPRICE"`         // 定价均价 = 已定价金额 / 已定价量
	SPOTAVGPRICE float64 `json:"spotavgprice" xorm:"SPOTAVGPRICE"` // 现货均价 = 合同现货金额 / 已定价量
}

func (r *ErmcpSpotContractModelEx) buildSql(req QrySpotContractExReq) string {
	str := `
	SELECT to_char(t.SPOTCONTRACTID) SPOTCONTRACTID,
		t.CONTRACTNO,
		t.CONTRACTTYPE,
		t.USERID,
		t.BUYUSERID,
		t.SELLUSERID,
		t.DELIVERYGOODSID,
		t.wrstandardid,
		t.PRODUCTTYPE,
		w.CONVERTFACTOR,
		t.SPOTGOODSDESC,
		t.PRICETYPE,
		t.QTY,
		t.PRICE,
		t.AMOUNT,
		to_char(t.DELIVERYSTARTDATE, 'yyyy-mm-dd hh24:mi:ss') DELIVERYSTARTDATE,
		to_char(t.DELIVERYENDDATE, 'yyyy-mm-dd hh24:mi:ss') DELIVERYENDDATE,
		t.GOODSID,
		t.PRICEMOVE,
		to_char(t.STARTDATE, 'yyyy-mm-dd hh24:mi:ss') STARTDATE,
		to_char(t.ENDDATE, 'yyyy-mm-dd hh24:mi:ss') ENDDATE,
		t.MARGIN,
		t.contractmargin,
		t.remark,
		t.pointdesc,
		t.auditremark,
		to_char(t.contractattachment) attachment,
		t.contractstatus,
		t.SPOTGOODSBRANDID,
		to_char(t.audittime, 'yyyy-mm-dd hh24:mi:ss') audittime,
		to_char(t.createtime, 'yyyy-mm-dd hh24:mi:ss') createtime,
		to_char(t.updatetime, 'yyyy-mm-dd hh24:mi:ss') updatetime,
		g.deliverygoodscode,
		g.deliverygoodsname,
		g2.goodscode,
		g2.goodsname,
		gb.dgfactoryitemvalue brandname,
		w.wrstandardname,
		w.wrstandardcode,
		w.vatrate,
		w.unitid,
		t.tradeuserid,
		t.saleuserid,
		t.meruserid,
		t.currencyid,
		to_char(t.accountid) accountid,
		t.biztype,
		to_char(t.subjectid) subjectid,
		b.subjectname,
		(t.QTY - t.PRICEDQTY) UNPRICEDQTY,
		DECODE(t.PRICEDQTY, 0, 0, t.PRICEDAMOUNT/t.PRICEDQTY) AVGPRICE,
		DECODE(t.PRICEDQTY, 0, 0, t.SPOTAMOUNT/t.PRICEDQTY) SPOTAVGPRICE,
		t.PRICEDQTY,
		ua.ACCOUNTNAME,
		uc.ACCOUNTNAME CUSTOMERNAME
	FROM ERMCP_SPOTCONTRACT t
	left join ermcp_pa_areasubject b on t.subjectid=b.subjectid
	left join deliverygoods g
	on t.deliverygoodsid = g.deliverygoodsid
	left join goods g2
	on t.goodsid = g2.goodsid
	left join DGFACTORYITEM gb
	on t.spotgoodsbrandid = gb.dgfactoryitemid
	left join wrstandard w
	on t.wrstandardid = w.wrstandardid
	left join loginaccount l
	on t.applyid = l.loginid
	left join useraccount ua
		on ua.userid = t.tradeuserid
	left join useraccount uc
		on uc.userid = t.CUSTOMERUSERID
	where t.contractstatus = 2 and t.ISRELATED = 0 and t.ISRELATED2 = 0
		and (t.userid = %v or t.tradeuserid = %v)
	`
	str = fmt.Sprintf(str, req.USERID, req.USERID)
	if req.PRICETYPE > 0 {
		str += " and t.PRICETYPE = %v"
		str = fmt.Sprintf(str, req.PRICETYPE)
	}
	if len(req.CONTRACTNO) > 0 {
		str += " and t.CONTRACTNO like '%%%s%%'"
		str = fmt.Sprintf(str, req.CONTRACTNO)
	}
	if len(req.CUSTOMERNAME) > 0 {
		str += " and uc.ACCOUNTNAME like '%%%s%%'"
		str = fmt.Sprintf(str, req.CUSTOMERNAME)
	}
	if req.CONTRACTTYPE != 0 {
		str += " and t.CONTRACTTYPE = %v"
		str = fmt.Sprintf(str, req.CONTRACTTYPE)
	}
	str += " order by t.audittime desc"

	return str
}

// GetData 从数据库中查询现货合同
func (r *ErmcpSpotContractModelEx) GetData(req QrySpotContractExReq) ([]ErmcpSpotContractModelEx, error) {
	sData := make([]ErmcpSpotContractModelEx, 0)
	e := db.GetEngine()
	s := e.SQL(r.buildSql(req))
	if err := s.Find(&sData); err != nil {
		logger.GetLogger().Errorf("ermcp query fail:%v", err)
		return sData, err
	}
	return sData, nil
}

// Ermcp8EnableHedgeditem 可关联项目
type Ermcp8EnableHedgeditem struct {
	HEDGEDITEMID   string `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`     // 被套期项目ID(624+Unix秒时间戳(10位)+xxxxxx)
	HEDGEDITEMNUM  string `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM"`   // 项目编号
	HEDGEDITEMNAME string `json:"hedgeditemname"  xorm:"HEDGEDITEMNAME"` // 项目名称
	HEDGEDTYPE     int32  `json:"hedgedtype"  xorm:"HEDGEDTYPE"`         // 套期类型 - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	SPOTTYPE       int32  `json:"-" form:"spottype" binding:"required"`  // 现货类型 - 1:采购计划 2:销售计划 3:采购合同 4:销售合同 5:库存存货
	PLANSTARTDATE  string `json:"planstartdate"  xorm:"PLANSTARTDATE"`   // 计划开始日期
	PLANENDDATE    string `json:"planenddate"  xorm:"PLANENDDATE"`       // 计划结束日期

	ACCOUNTNAME string `json:"accountname" xorm:"ACCOUNTNAME"` // 套期主体

	USERID         int64  `json:"-" form:"userid" binding:"required"`    // 用户ID
	WRSTANDARDID   int64  `json:"wrstandardid" form:"wrstandardid"`      // 现货商品ID
	WRSTANDARDNAME string `json:"wrstandardname"  xorm:"WRSTANDARDNAME"` // 现货商品
}

func (r *Ermcp8EnableHedgeditem) calc() {

}

func (r *Ermcp8EnableHedgeditem) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT 
	to_char(t.HEDGEDITEMID) HEDGEDITEMID,
		t.HEDGEDITEMNUM,
		t.HEDGEDITEMNAME,
		t.HEDGEDTYPE,
		to_char(t.PLANSTARTDATE, 'yyyy-mm-dd') PLANSTARTDATE,
		to_char(t.PLANENDDATE, 'yyyy-mm-dd') PLANENDDATE,
		u.ACCOUNTNAME,
		wr.WRSTANDARDNAME
	FROM ERMCP2_HedgedItem t
	LEFT JOIN useraccount u ON u.userid = t.tradeuserid
	LEFT JOIN WRStandard wr ON wr.wrstandardid = t.wrstandardid
	WHERE 
		t.HEDGEDITEMSTATUS = 2
		AND (t.TRADEUSERID = %v OR t.AREAUSERID = %v)
		AND (t.WRSTANDARDID IS NULL OR t.WRSTANDARDID = %v)
	`
	sqlId.FormatParam(r.USERID, r.USERID, r.WRSTANDARDID)
	switch r.SPOTTYPE {
	case 1, 2:
		sqlId.And("t.HEDGEDTYPE", r.SPOTTYPE)
	case 3:
		sqlId.JoinFormat(" AND t.HEDGEDTYPE in (%v)", "1,3")
	case 4:
		sqlId.JoinFormat(" AND t.HEDGEDTYPE in (%v)", "2,3")
	}

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp8EnableHedgeditem) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp8EnableHedgeditem, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Ermcp8RunningHedgeditem 执行中项目
type Ermcp8RunningHedgeditem struct {
	Hedgeditemid        string  `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`               // 被套期项目ID(624+Unix秒时间戳(10位)+xxxxxx)
	Hedgeditemnum       string  `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM"`             // 项目编号
	Hedgeditemname      string  `json:"hedgeditemname"  xorm:"HEDGEDITEMNAME"`           // 项目名称
	Hedgedtype          int32   `json:"hedgedtype"  xorm:"HEDGEDTYPE"`                   // 套期类型 - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	Planstartdate       string  `json:"planstartdate"  xorm:"PLANSTARTDATE"`             // 计划开始日期
	Planenddate         string  `json:"planenddate"  xorm:"PLANENDDATE"`                 // 计划结束日期
	Hedgerate           float64 `json:"hedgerate"  xorm:"HEDGERATE"`                     // 套保比率
	Tradeuserid         int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`                 // 交易用户ID
	Areauserid          int64   `json:"areauserid"  xorm:"AREAUSERID"`                   // 企业ID
	Hedgeditemstatus    int32   `json:"hedgeditemstatus"  xorm:"HEDGEDITEMSTATUS"`       // 项目状态 - 0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回
	Applysrc            int32   `json:"applysrc"  xorm:"APPLYSRC"`                       // 申请来源 - 1:管理端 2:终端
	Applyid             int64   `json:"applyid"  xorm:"APPLYID"`                         // 申请人
	Remark              string  `json:"remark"  xorm:"REMARK"`                           // 备注
	Createtime          string  `json:"createtime"  xorm:"CREATETIME"`                   // 申请时间
	Audittradedate      string  `json:"audittradedate"  xorm:"AUDITTRADEDATE"`           // 审核交易日(yyyyMMdd)
	Auditid             int64   `json:"auditid"  xorm:"AUDITID"`                         // 审核人
	Auditsrc            int32   `json:"auditsrc"  xorm:"AUDITSRC"`                       // 审核来源 - 1:管理端 2:终端
	Audittime           string  `json:"audittime"  xorm:"AUDITTIME"`                     // 审核时间
	Auditremark         string  `json:"auditremark"  xorm:"AUDITREMARK"`                 // 审核备注
	Deliverygoodsid     int64   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`         // 现货品种ID
	Wrstandardid        int64   `json:"wrstandardid"  xorm:"WRSTANDARDID"`               // 现货商品ID
	Vatrate             float64 `json:"vatrate"  xorm:"VATRATE"`                         // 增值税
	Hedgeqty            float64 `json:"hedgeqty"  xorm:"HEDGEQTY"`                       // 套期现货量
	Hedgeamount         float64 `json:"hedgeamount"  xorm:"HEDGEAMOUNT"`                 // 套期市价总额
	Hedgerestamount     float64 `json:"hedgerestamount"  xorm:"HEDGERESTAMOUNT"`         // 套期剩余市价总额【现货贸易】
	Hedgecontractamount float64 `json:"hedgecontractamount"  xorm:"HEDGECONTRACTAMOUNT"` // 套期定价总额 【定价采购合同】【现货贸易】
	Oriavgprice         float64 `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                 // 期初市场均价 = 套期市价总额 / 套期现货量
	Exeqty              float64 `json:"exeqty"  xorm:"EXEQTY"`                           // 执行现货量
	Exeamount           float64 `json:"exeamount"  xorm:"EXEAMOUNT"`                     // 执行市价总额
	Exerestamount       float64 `json:"exerestamount"  xorm:"EXERESTAMOUNT"`             // 执行剩余市价总额【现货贸易】
	Exeavgprice         float64 `json:"exeavgprice"  xorm:"EXEAVGPRICE"`                 // 执行市场均价= 执行市价总额 / 执行现货量
	Execontractamount   float64 `json:"execontractamount"  xorm:"EXECONTRACTAMOUNT"`     // 执行定价总额
	Curprice            float64 `json:"curprice"  xorm:"CURPRICE"`                       // 当前市场价
	Unexeqty            float64 `json:"unexeqty"  xorm:"UNEXEQTY"`                       // 未执行现货量 = 套期现货量 - 执行现货量
	Spothedgepl         float64 `json:"spothedgepl"  xorm:"SPOTHEDGEPL"`                 // 现货套期损益 =(执行市场均价-期初市场均价)*执行现货量 * 方向(销售计划 为 -1, 其它为1)
	Spotpl              float64 `json:"spotpl"  xorm:"SPOTPL"`                           // 现货套期损益 = 现货实际损益 + 现货浮动损益
	Futurehedgepl       float64 `json:"futurehedgepl"  xorm:"FUTUREHEDGEPL"`             // 期货实际损益
	Futurepl            float64 `json:"futurepl"  xorm:"FUTUREPL"`                       // 期货套期损益
	Hedgesumpl          float64 `json:"hedgesumpl"  xorm:"HEDGESUMPL"`                   // 套期汇总损益 = 期货汇总损益 + 现货汇总损益
	Spottradepl         float64 `json:"spottradepl"  xorm:"SPOTTRADEPL"`                 // 现货贸易损益【现货贸易】= 执行合同定价总额 - 套期合同定价总额
	Vatpl               float64 `json:"vatpl"  xorm:"VATPL"`                             // 增值税损益【现货贸易】= 现货贸易损益 * （增值税率 /（1+增值税率））
	Sumobspl            float64 `json:"sumobspl"  xorm:"SUMOBSPL"`                       // 汇总绝对损益【现货贸易】=现货贸易损益+增值税损益+期货套期损益
	Spotbookamount      float64 `json:"spotbookamount"  xorm:"SPOTBOOKAMOUNT"`           // 现货账面总额
	Curstock            float64 `json:"curstock"  xorm:"CURSTOCK"`                       // 期末库存量 = 采购总量 - 销售总量
	Enddate             string  `json:"enddate"  xorm:"ENDDATE"`                         // 完成日期
	Endtradedate        string  `json:"endtradedate"  xorm:"ENDTRADEDATE"`               // 完成交易日
	Updatetime          string  `json:"updatetime"  xorm:"UPDATETIME"`                   // 更新时间
	Orispothedgepl      float64 `json:"orispothedgepl"  xorm:"ORISPOTHEDGEPL"`           // 期初现货实际损益
	Orifuturehedgepl    float64 `json:"orifuturehedgepl"  xorm:"ORIFUTUREHEDGEPL"`       // 期初期货实际损益
	Orispotpl           float64 `json:"orispotpl"  xorm:"ORISPOTPL"`                     // 期初现货套期损益
	Orifuturepl         float64 `json:"orifuturepl"  xorm:"ORIFUTUREPL"`                 // 期初期货套期损益
	Spotfloatpl         float64 `json:"spotfloatpl"  xorm:"SPOTFLOATPL"`                 // 现货浮动损益 =(当前市场价 - 期初市场价)*未执行现货量 * 方向(销售计划 为 -1, 其它为1)
	Futurefloatpl       float64 `json:"futurefloatpl"  xorm:"FUTUREFLOATPL"`             // 期货浮动损益

	SpotHedgePLChange   float64 `json:"spothedgeplchange" xorm:"SPOTHEDGEPLCHANGE"`     // 现货实际损益变动
	SpotPLChange        float64 `json:"spotplchange" xorm:"SPOTPLCHANGE"`               // 现货套期损益变动
	FutureHedgePLChange float64 `json:"futurehedgeplchange" xorm:"FUTUREHEDGEPLCHANGE"` // 期货实际损益变动
	FuturePLChange      float64 `json:"futureplchange" xorm:"FUTUREPLCHANGE"`           // 期货套期损益变动

	Wrstandardname string `json:"wrstandardname" xorm:"WRSTANDARDNAME"` // 商品名称
	EnumdicName    string `json:"enumdicname"  xorm:"ENUMDICNAME"`      // 单位
	AccountName    string `json:"accountname" xorm:"ACCOUNTNAME"`       // 套期主体

	MiddleGoodsList []Ermcp2himiddlegoods `json:"middlegoodslist"` // 套期商品列表

	USERID int64 `json:"-" form:"userid" binding:"required"` // 用户id, 用于过滤
}

type Ermcp8RunningHedgeditems []Ermcp8RunningHedgeditem

func (s Ermcp8RunningHedgeditems) Len() int           { return len(s) }
func (s Ermcp8RunningHedgeditems) Less(i, j int) bool { return s[i].Createtime < s[j].Createtime }
func (s Ermcp8RunningHedgeditems) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func (r *Ermcp8RunningHedgeditem) ParseFromProto(p *pb.Ermcp2HedgedItemInfo) {
	r.Hedgeditemid = strconv.Itoa(int(*p.Hedgeditemext.Item.HedgedItemID))
	r.Hedgeditemnum = p.Hedgeditemext.Item.GetHedgedItemNum()
	r.Hedgeditemname = p.Hedgeditemext.Item.GetHedgedItemName()
	r.Hedgedtype = int32(p.Hedgeditemext.Item.GetHedgedType())
	if f, err := time.Parse("2006-01-02 15:04:05", p.Hedgeditemext.Item.GetPlanStartDate().GetDateStr()); err == nil {
		r.Planstartdate = f.Format("2006-01-02")
	} else {
		r.Planstartdate = p.Hedgeditemext.Item.GetPlanStartDate().GetDateStr()
	}
	if f, err := time.Parse("2006-01-02 15:04:05", p.Hedgeditemext.Item.GetPlanEndDate().GetDateStr()); err == nil {
		r.Planenddate = f.Format("2006-01-02")
	} else {
		r.Planenddate = p.Hedgeditemext.Item.GetPlanEndDate().GetDateStr()
	}
	r.Hedgerate = p.Hedgeditemext.Item.GetHedgeRate()
	r.Tradeuserid = int64(*p.Hedgeditemext.Item.TradeUserID)
	r.Areauserid = int64(*p.Hedgeditemext.Item.AreaUserID)
	r.Hedgeditemstatus = int32(*p.Hedgeditemext.Item.HedgedItemStatus)
	r.Applysrc = int32(*p.Hedgeditemext.Item.ApplySrc)
	r.Applyid = int64(*p.Hedgeditemext.Item.ApplyID)
	r.Remark = p.Hedgeditemext.Item.GetRemark()
	r.Createtime = p.Hedgeditemext.Item.GetCreateTime().GetDateStr()
	r.Audittradedate = p.Hedgeditemext.Item.GetAuditTradeDate()
	r.Auditid = int64(p.Hedgeditemext.Item.GetAuditID())
	r.Auditsrc = int32(p.Hedgeditemext.Item.GetAuditSrc())
	r.Audittime = p.Hedgeditemext.Item.GetAuditTime()
	r.Auditremark = p.Hedgeditemext.Item.GetAuditRemark()
	r.Deliverygoodsid = int64(p.Hedgeditemext.Item.GetDeliveryGoodsID())
	r.Wrstandardid = int64(p.Hedgeditemext.Item.GetWrStandardID())
	r.Vatrate = p.Hedgeditemext.Item.GetVatRate()
	r.Hedgeqty = p.Hedgeditemext.Item.GetHedgeQty()
	r.Hedgeamount = p.Hedgeditemext.Item.GetHedgeAmount()
	r.Hedgerestamount = p.Hedgeditemext.Item.GetHedgeRestAmount()
	r.Hedgecontractamount = p.Hedgeditemext.Item.GetHedgeContractAmount()
	r.Oriavgprice = p.Hedgeditemext.Item.GetOriAvgPrice()
	r.Exeqty = p.Hedgeditemext.Item.GetExeQty()
	r.Exeamount = p.Hedgeditemext.Item.GetExeAmount()
	r.Exerestamount = p.Hedgeditemext.Item.GetExeRestAmount()
	r.Exeavgprice = p.Hedgeditemext.Item.GetExeAvgPrice()
	r.Execontractamount = p.Hedgeditemext.Item.GetExeContractAmount()
	r.Curprice = p.Hedgeditemext.Item.GetCurPrice()
	r.Unexeqty = p.Hedgeditemext.Item.GetUnExeQty()
	r.Spothedgepl = p.Hedgeditemext.Item.GetSpotHedgePL()
	r.Spotpl = p.Hedgeditemext.Item.GetSpotPL()
	r.Futurehedgepl = p.Hedgeditemext.Item.GetFutureHedgePL()
	r.Hedgesumpl = p.Hedgeditemext.Item.GetHedgeSumPL()
	r.Spottradepl = p.Hedgeditemext.Item.GetSpotTradePL()
	r.Vatpl = p.Hedgeditemext.Item.GetVatPL()
	r.Sumobspl = p.Hedgeditemext.Item.GetSumObsPL()
	r.Spotbookamount = p.Hedgeditemext.Item.GetSpotBookAmount()
	r.Curstock = p.Hedgeditemext.Item.GetCurStock()
	r.Enddate = p.Hedgeditemext.Item.GetEndDate().GetDateStr()
	r.Endtradedate = p.Hedgeditemext.Item.GetEndTradeDate()
	r.Updatetime = p.Hedgeditemext.Item.GetUpdateTime().GetDateStr()
	r.Orispothedgepl = p.Hedgeditemext.Item.GetOriSpotHedgePL()
	r.Orifuturehedgepl = p.Hedgeditemext.Item.GetOriFutureHedgePL()
	r.Orispotpl = p.Hedgeditemext.Item.GetOriSpotPL()
	r.Orifuturepl = p.Hedgeditemext.Item.GetOriFuturePL()
	r.Spotfloatpl = p.Hedgeditemext.Item.GetSpotFloatPL()
	r.Futurefloatpl = p.Hedgeditemext.Item.GetFutureFloatPL()
	r.Futurepl = p.Hedgeditemext.Item.GetFuturePL()
	r.SpotHedgePLChange = r.Spothedgepl - r.Orispothedgepl
	r.SpotPLChange = r.Spotpl - r.Orispotpl
	r.FutureHedgePLChange = r.Futurehedgepl - r.Orifuturehedgepl
	r.FuturePLChange = r.Futurepl - r.Orifuturepl

	r.Wrstandardname = p.Hedgeditemext.GetWrstandardname()
	r.AccountName = p.Hedgeditemext.GetAccountname()
	if p.Hedgeditemext.GetUnitid() != 0 {
		r.EnumdicName = mtpcache.GetEnumDicitemName(int32(p.Hedgeditemext.GetUnitid()))
	}

	// 套期商品列表
	r.MiddleGoodsList = make([]Ermcp2himiddlegoods, 0)
	for _, goods := range p.Himiddlegoodsext {
		g := Ermcp2himiddlegoods{
			HEDGEDITEMID:     int64(goods.Middlegoods.GetHedgedItemID()),
			MIDDLEGOODSID:    int64(goods.Middlegoods.GetMiddleGoodsID()),
			DELIVERYGOODSID:  int64(goods.Middlegoods.GetDeliveryGoodsID()),
			WRSTANDARDID:     int64(*goods.Middlegoods.WrstandardID),
			VATRATE:          goods.Middlegoods.GetVatRate(),
			SPOTCONVERTRATIO: goods.Middlegoods.GetSpotConvertRatio(),
			UNEXESPOTQTY:     goods.Middlegoods.GetUnexeSpotQty(),
			UNEXEHEDGEQTY:    goods.Middlegoods.GetUnexeHedgeQty(),
			FUTUREHEDGEQTY:   goods.Middlegoods.GetFutureHedgeQty(),
			HIEXPSOURE:       goods.Middlegoods.GetHIExpsoure(),
			TRADEUSERID:      int64(goods.Middlegoods.GetTradeUserID()),
			AREAUSERID:       int64(goods.Middlegoods.GetAreaUserID()),
			CREATETIME:       goods.Middlegoods.GetCreateTime().GetDateStr(),
			UPDATETIME:       goods.Middlegoods.GetUpdateTime().GetDateStr(),
			MIDDLEGOODSNAME:  *goods.Middlegoodsname,
		}
		r.MiddleGoodsList = append(r.MiddleGoodsList, g)
	}
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp8RunningHedgeditem) GetDataEx(userID int) (interface{}, error) {
	redisCli := rediscli.GetRedisClient()

	sData := make([]Ermcp8RunningHedgeditem, 0)
	key := "Ermcp2HedgedItemInfo:*"
	if ret, err := redisCli.Do("keys", key).Result(); err == nil {
		datas := ret.([]interface{})
		for _, item := range datas {
			itemKey := item.(string)
			// 判断是否目标数据
			s := strings.Split(itemKey, "_")
			if len(s) == 3 {
				areaUserID, _ := strconv.Atoi(strings.Replace(s[0], "Ermcp2HedgedItemInfo:", "", -1))
				traderUserID, _ := strconv.Atoi(s[1])
				if areaUserID == userID || traderUserID == userID {
					if itemValue, err := redisCli.Get(itemKey).Result(); err == nil {
						var data pb.Ermcp2HedgedItemInfo
						if err = proto.Unmarshal([]byte(itemValue), &data); err == nil {
							// 只加载执行中的项目
							if data.Hedgeditemext.Item.GetHedgedItemStatus() == 2 {
								m := Ermcp8RunningHedgeditem{}
								m.ParseFromProto(&data)
								sData = append(sData, m)
							}
						}
					}
				}
			}
		}
	}
	// 按Updatetime倒序排序
	sort.Sort(sort.Reverse(Ermcp8RunningHedgeditems(sData)))

	return sData, nil
}

// Ermcp2AreaExposure 企业敞口表_New
type Ermcp2AreaExposure struct {
	MiddleGoodsID          int     `json:"middlegoodsid"`          // 套保品种
	AreaUserID             int     `json:"areauserid"`             // 所属机构
	SpotQty                float64 `json:"spotqty"`                // 现货总量
	HedgeSpotQty           float64 `json:"hedgespotqty"`           // 被套期现货量
	HedgePlanQty           float64 `json:"hedgeplanqty"`           // 套期计划量
	FutureQty              float64 `json:"futureqty"`              // 期货套期量
	SpotExposure           float64 `json:"spotexposure"`           // 现货敞口量
	TotalExposure          float64 `json:"totalexposure"`          // 总敞口量 = 现货敞口量 + 期货套期量
	SpRatio                float64 `json:"spratio"`                // 总期现比例 = 期货套期量/现货敞口量
	HedgedSpotExposure     float64 `json:"hedgedspotexposure"`     // 被套期现货敞口量
	HedgedTotalExposure    float64 `json:"hedgedtotalexposure"`    // 套期敞口量 = 被套期现货敞口量+期货套期量
	HedgedSpRatio          float64 `json:"hedgedspratio"`          // 套期期现比例 = 期货套期量/被套期现货敞口量
	OriSpotQty             float64 `json:"orispotqty"`             // 期初现货总量
	OriHedgeSpotQty        float64 `json:"orihedgespotqty"`        // 期初被套期现货量
	OriHedgePlanQty        float64 `json:"orihedgeplanqty"`        // 期初套期计划量
	OriFutureQty           float64 `json:"orifutureqty"`           // 期初期货套期量
	OriSpotExposure        float64 `json:"orispotexposure"`        // 期初现货敞口量
	OriTotalExposure       float64 `json:"oritotalexposure"`       // 期初总敞口量
	OriHedgedSpotExposure  float64 `json:"orihedgedspotexposure"`  // 期初被套期现货敞口量
	OriHedgedTotalExposure float64 `json:"orihedgedtotalexposure"` // 期初套期敞口量
	UpdateTime             string  `json:"updatetime"`             // 更新时间  --DATE
	MiddleGoodsName        string  `json:"middlegoodsname"`        // 套保品种名称
	GoodsUnitID            int     `json:"goodsunitid"`            // 单位ID

	TotalExposureChange        float64 `json:"totalexposurechange"`        // 总敞口变动量 = TotalExposure - OriTotalExposure
	HedgedTotalExposoureChange float64 `json:"hedgedtotalexposourechange"` // 被套期敞口变动量 = HedgedTotalExposure - OriHedgedTotalExposure
	SpotQtyChange              float64 `json:"spotqtychange"`              // 现货变动量 = SpotQty - OriSpotQty
	HedgePlanQtyChange         float64 `json:"hedgeplanqtychange"`         // 计划变动量 = HedgePlanQty - OriHedgePlanQty
	FutureQtyChange            float64 `json:"futureqtychange"`            // 期货变动量 = FutureQty - OriFutureQty

	EnumdicName string `json:"enumdicname"` // 单位

	USERID int64 `json:"-" form:"userid" binding:"required"` // 用户id, 用于过滤
}

func (r *Ermcp2AreaExposure) ParseFromProto(p *pb.Ermcp2AreaExposure) {
	r.MiddleGoodsID = int(p.GetMiddleGoodsID())
	r.AreaUserID = int(p.GetAreaUserID())
	r.SpotQty = p.GetSpotQty()
	r.HedgeSpotQty = p.GetHedgeSpotQty()
	r.HedgePlanQty = p.GetHedgePlanQty()
	r.FutureQty = p.GetFutureQty()
	r.SpotExposure = p.GetSpotExposure()
	r.TotalExposure = p.GetTotalExposure()
	r.SpRatio = p.GetSpRatio()
	r.HedgedSpotExposure = p.GetHedgedSpotExposure()
	r.HedgedTotalExposure = p.GetHedgedTotalExposure()
	r.HedgedSpRatio = p.GetHedgedSpRatio()
	r.OriSpotQty = p.GetOriSpotQty()
	r.OriHedgeSpotQty = p.GetOriHedgeSpotQty()
	r.OriHedgePlanQty = p.GetOriHedgePlanQty()
	r.OriFutureQty = p.GetOriFutureQty()
	r.OriSpotExposure = p.GetOriSpotExposure()
	r.OriTotalExposure = p.GetOriTotalExposure()
	r.OriHedgedSpotExposure = p.GetOriHedgedSpotExposure()
	r.OriHedgedTotalExposure = p.GetOriHedgedTotalExposure()
	r.UpdateTime = p.GetUpdateTime().GetDateStr()
	r.MiddleGoodsName = p.GetMiddleGoodsName()
	r.GoodsUnitID = int(p.GetGoodsUnitID())
	if p.GetGoodsUnitID() != 0 {
		r.EnumdicName = mtpcache.GetEnumDicitemName(int32(p.GetGoodsUnitID()))
	}

	r.TotalExposureChange = r.TotalExposure - r.OriTotalExposure
	r.HedgedTotalExposoureChange = r.HedgedTotalExposure - r.OriHedgedTotalExposure
	r.SpotQtyChange = r.SpotQty - r.OriSpotQty
	r.HedgePlanQtyChange = r.HedgePlanQty - r.OriHedgePlanQty
	r.FutureQtyChange = r.FutureQty - r.OriFutureQty
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp2AreaExposure) GetDataEx(userID int) (interface{}, error) {
	redisCli := rediscli.GetRedisClient()

	sData := make([]Ermcp2AreaExposure, 0)
	key := "Ermcp2AreaExposure:*"
	if ret, err := redisCli.Do("keys", key).Result(); err == nil {
		datas := ret.([]interface{})
		for _, item := range datas {
			itemKey := item.(string)
			// 判断是否目标数据
			s := strings.Split(itemKey, "_")
			if len(s) == 2 {
				areaUserID, _ := strconv.Atoi(strings.Replace(s[0], "Ermcp2AreaExposure:", "", -1))
				if areaUserID == userID {
					if itemValue, err := redisCli.Get(itemKey).Result(); err == nil {
						var data pb.Ermcp2AreaExposure
						if err = proto.Unmarshal([]byte(itemValue), &data); err == nil {
							m := Ermcp2AreaExposure{}
							m.ParseFromProto(&data)
							sData = append(sData, m)
						}
					}
				}
			}
		}
	}

	return sData, nil
}

// Ermcp2stockspotchangelog 现货操作流水表
type Ermcp2stockspotchangelog struct {
	LOGID            string  `json:"logid"  xorm:"LOGID"`                       // 流水ID(604+Unix秒时间戳(10位)+xxxxxx)
	OPERATELOGTYPE   int32   `json:"operatelogtype"  xorm:"OPERATELOGTYPE"`     // 操作流水类型 -  2:点价数量 21:正常完结(合同) 22:异常终止(合同)  24:采购入库 25:销售出库 26:生产入库 27:生产出库
	DELIVERYGOODSID  int64   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`   // 现货品种ID
	WRSTANDARDID     int64   `json:"wrstandardid"  xorm:"WRSTANDARDID"`         // 现货商品ID
	SPOTGOODSBRANDID int32   `json:"spotgoodsbrandid"  xorm:"SPOTGOODSBRANDID"` // 现货品牌ID
	WRFACTORTYPEID   int64   `json:"wrfactortypeid"  xorm:"WRFACTORTYPEID"`     // 仓单要素类型ID(212+Unix秒时间戳(10位)+xxxxxx)
	WAREHOUSEINFOID  int64   `json:"warehouseinfoid"  xorm:"WAREHOUSEINFOID"`   // 仓库ID
	RELATEDID        int64   `json:"relatedid"  xorm:"RELATEDID"`               // 现货合同ID
	CONTRACTTYPE     int32   `json:"contracttype"  xorm:"CONTRACTTYPE"`         // 现货合同类型 - 1:采购 -1:销售
	EXETYPE          int32   `json:"exetype"  xorm:"EXETYPE"`                   // 执行类型 - 1:采购合同 2:销售合同 3:生产入库 4:生产出库
	LOGVALUE         float64 `json:"logvalue"  xorm:"LOGVALUE"`                 // [期间变化量]现货量变更值
	BEFOREVALUE      float64 `json:"beforevalue"  xorm:"BEFOREVALUE"`           // 变更前现货量
	AFTERVALUE       float64 `json:"aftervalue"  xorm:"AFTERVALUE"`             // 现货量
	TRADEDATE        string  `json:"tradedate"  xorm:"TRADEDATE"`               // 交易日(yyyyMMdd)
	CREATETIME       string  `json:"createtime"  xorm:"CREATETIME"`             // 创建时间
	USERID           int64   `json:"userid"  xorm:"USERID" form:"userid"`       // 机构ID

	CustomerUserName string `json:"customerusername" xorm:"CUSTOMERUSERNAME"` // 对手方
	Wrstandardname   string `json:"wrstandardname" xorm:"WRSTANDARDNAME"`     // 商品名称
	AccountName      string `json:"accountname" xorm:"ACCOUNTNAME"`           // 套期主体
	CONTRACTNO       string `json:"contractno"  xorm:"CONTRACTNO"`            // [编号]现货合同编号

	MiddleGoodsChange float64 `json:"middlegoodschange" xorm:"MIDDLEGOODSCHANGE"` // 套期商品变化量 = LogValue * 折算系数 * (1/(1+增值税))

	MIDDLEGOODSID int64 `json:"-"  form:"middlegoodsid"` // 套保品种ID
}

// TableName is ERMCP2_STOCKSPOTCHANGELOG
func (r *Ermcp2stockspotchangelog) TableName() string {
	return "ERMCP2_STOCKSPOTCHANGELOG"
}

func (r *Ermcp2stockspotchangelog) calc() {

}

func (r *Ermcp2stockspotchangelog) buildSql() string {
	var sqlId utils.SQLVal = `
		SELECT DISTINCT
			to_char(t.CREATETIME, 'yyyy-mm-dd hh24:mi:ss') CREATETIME,
			t.EXETYPE,
			u.ACCOUNTNAME CUSTOMERUSERNAME,
			ws.WRSTANDARDNAME,
			t.LOGVALUE,
			s.CONTRACTNO,
			u1.ACCOUNTNAME,
			t.TradeDate,
			(t.LOGVALUE * c.CONVERTRATIO * (1/(1 + ws.VATRATE))) MIDDLEGOODSCHANGE
		FROM ERMCP2_StockSpotChangeLog t
		LEFT JOIN ERMS2_WRSConvertDetail c ON c.WRStandardID = t.WRStandardID
		LEFT JOIN ERMS_MiddleGoods mg ON mg.MiddleGoodsID = c.MiddleGoodsID
		LEFT JOIN WRStandard ws ON ws.WRStandardID = t.WRStandardID
		LEFT JOIN ERMCP_SPOTCONTRACT s ON s.SPOTCONTRACTID = t.RELATEDID
		LEFT JOIN useraccount u ON u.userid = s.CUSTOMERUSERID
		LEFT JOIN useraccount u1 ON u1.userid = s.TRADEUSERID
		WHERE t.userid = %v AND mg.MiddleGoodsID = %v
	`
	// var sqlId utils.SQLVal = `
	// SELECT
	// 	to_char(t.CREATETIME, 'yyyy-mm-dd hh24:mi:ss') CREATETIME,
	// 	t.EXETYPE,
	// 	u.ACCOUNTNAME CUSTOMERUSERNAME,
	// 	ws.WRSTANDARDNAME,
	// 	t.LOGVALUE,
	// 	s.CONTRACTNO,
	// 	u1.ACCOUNTNAME
	// FROM ERMCP2_StockSpotChangeLog t
	// LEFT JOIN WRStandard ws ON ws.WRStandardID = t.WRStandardID
	// LEFT JOIN ERMCP_SPOTCONTRACT s ON s.SPOTCONTRACTID = t.RELATEDID
	// LEFT JOIN useraccount u ON u.userid = s.CUSTOMERUSERID
	// LEFT JOIN useraccount u1 ON u.userid = s.RELATEDUSERID
	// WHERE t.userid = %v
	// 	AND t.wrstandardid
	// 		IN (SELECT
	// 				wrc.wrstandardid
	// 			FROM ERMS2_WRSConvertDetail wrc
	// 			WHERE wrc.middlegoodsid = %v)
	// `
	sqlId.FormatParam(r.USERID, r.MIDDLEGOODSID)
	sqlId.OrderBy("CREATETIME")

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp2stockspotchangelog) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp2stockspotchangelog, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Ermcp2hedgeditemspot 计划变动明细
type Ermcp2hedgeditemsDetail struct {
	HEDGEDITEMSPOTID      string  `json:"hedgeditemspotid"  xorm:"HEDGEDITEMSPOTID"`           // 现货明细ID(625+Unix秒时间戳(10位)+xxxxxx)
	HEDGEDITEMID          string  `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`                   // 被套期项目ID
	HEDGEDTYPE            int32   `json:"hedgedtype"  xorm:"HEDGEDTYPE"`                       // 套期类型[计划类型] - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	SPOTTYPE              int32   `json:"spottype"  xorm:"SPOTTYPE"`                           // 现货类型 - 1:采购计划 2:销售计划 3:采购合同 4:销售合同 5:库存存货
	RELATEDTYPE           int32   `json:"relatedtype"  xorm:"RELATEDTYPE"`                     // 关联类型 - 1:套期关联 2:执行关联
	RELATEDHEDGEPLANID    int64   `json:"relatedhedgeplanid"  xorm:"RELATEDHEDGEPLANID"`       // 关联计划ID 【1:采购计划 2:销售计划】
	RELATEDSPOTCONTRACTID int64   `json:"relatedspotcontractid"  xorm:"RELATEDSPOTCONTRACTID"` // 关联合同ID 【3:采购合同 4:销售合同】
	CUSTOMERUSERID        int64   `json:"customeruserid"  xorm:"CUSTOMERUSERID"`               // 对手方 【3:采购合同 4:销售合同】
	DELIVERYGOODSID       int64   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`             // 现货品种ID
	WRSTANDARDID          int64   `json:"wrstandardid"  xorm:"WRSTANDARDID"`                   // 现货商品ID
	SPOTGOODSBRANDID      int32   `json:"spotgoodsbrandid"  xorm:"SPOTGOODSBRANDID"`           // 现货品牌ID -  存“DGFactoryItem”表"DGFactoryItemID" = 2
	RELATEDQTY            float64 `json:"relatedqty"  xorm:"RELATEDQTY"`                       // [期间变化量]关联数量
	ORIAVGPRICE           float64 `json:"oriavgprice"  xorm:"ORIAVGPRICE"`                     // 期初市场价[当初市场价]
	RELATEDAMOUNT         float64 `json:"relatedamount"  xorm:"RELATEDAMOUNT"`                 // 市价总额 = 关联数量 * 期初市场价
	SPOTPRICEDAMOUNT      float64 `json:"spotpricedamount"  xorm:"SPOTPRICEDAMOUNT"`           // 定价总额
	SPOTPRICEDAVGPRICE    float64 `json:"spotpricedavgprice"  xorm:"SPOTPRICEDAVGPRICE"`       // 现货均价 = 定价总额 / 关联数量
	CREATETIME            string  `json:"createtime"  xorm:"CREATETIME"`                       // [日期时间]创建时间
	TRADEUSERID           int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`                     // 交易用户ID
	AREAUSERID            int64   `json:"areauserid"  xorm:"AREAUSERID"`                       // 企业ID

	Wrstandardname    string  `json:"wrstandardname" xorm:"WRSTANDARDNAME"`       // 现货商品
	EnumdicName       string  `json:"enumdicname"  xorm:"ENUMDICNAME"`            // 单位
	Hedgeplanno       string  `json:"hedgeplanno"  xorm:"HEDGEPLANNO"`            // 计划编号
	UNEXEQTY          float64 `json:"unexeqty"  xorm:"UNEXEQTY"`                  // 未执行现货量 = 套期现货量 - 执行现货量
	AccountName       string  `json:"accountname" xorm:"ACCOUNTNAME"`             // 套期主体
	MiddleGoodsChange float64 `json:"middlegoodschange" xorm:"MIDDLEGOODSCHANGE"` // 套期商品变化量 = RELATEDQTY * 折算系数 * (1/(1+增值税))

	USERID        int64 `json:"-" form:"userid"`        // 用户ID
	MIDDLEGOODSID int64 `json:"-" form:"middlegoodsid"` // 套保品种ID
}

func (r *Ermcp2hedgeditemsDetail) calc() {

}

func (r *Ermcp2hedgeditemsDetail) buildSql() string {
	var sqlId utils.SQLVal = `
		SELECT DISTINCT
			to_char(t.CREATETIME, 'yyyy-mm-dd hh24:mi:ss') CREATETIME,
			t.SPOTTYPE,
			t.HEDGEDTYPE,
			wr.WRSTANDARDNAME,
			e.ENUMDICNAME,
			h.UNEXEQTY,
			t.RELATEDQTY,
			s.HEDGEPLANNO,
			u.ACCOUNTNAME,
			(t.RELATEDQTY * c.CONVERTRATIO * (1/(1 + wr.VATRATE))) MIDDLEGOODSCHANGE
		FROM ERMCP2_HEDGEDITEMSPOT t
		LEFT JOIN ERMS2_WRSConvertDetail c ON c.WRStandardID = t.WRStandardID
		LEFT JOIN ERMS_MiddleGoods mg ON mg.MiddleGoodsID = c.MiddleGoodsID
		LEFT JOIN WRStandard wr ON wr.wrstandardid = t.wrstandardid
		LEFT JOIN enumdicitem e on wr.unitid=e.enumitemname and e.enumdiccode='goodsunit'
		LEFT JOIN ermcp_hedgeplan s ON s.HedgePlanID = t.RELATEDHEDGEPLANID
		LEFT JOIN ERMCP2_HedgedItem h on h.HedgedItemID = t.HEDGEDITEMID
		LEFT JOIN useraccount u ON u.userid = t.TRADEUSERID
		WHERE t.SpotType IN (1,2) 
			AND t.areauserid = %v 
			AND mg.MiddleGoodsID = %v
	`
	sqlId.FormatParam(r.USERID, r.MIDDLEGOODSID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp2hedgeditemsDetail) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp2hedgeditemsDetail, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Patradelinkdetail 敞口 - 期货变动明细
type Patradelinkdetail struct {
	LINKDETAILID   string  `json:"linkdetailid"  xorm:"LINKDETAILID"`                        // 期货明细ID(614+Unix秒时间戳(10位)+xxxxxx)
	TRADEID        string  `json:"tradeid"  xorm:"TRADEID"`                                  // [成交单号]内部成交单ID
	BUYORSELL      int32   `json:"buyorsell"  xorm:"BUYORSELL"`                              // 方向 - 0:买 1:卖
	HEDGEFLAG      int32   `json:"hedgeflag"  xorm:"HEDGEFLAG"`                              // 投机套保标志 - 0:无 1:投机 2:套保 3:套利 4:套期保值(平安\合同) 5:单边(平安) 6:移仓(平安) 7:错单处理(平安) 8:跨期套利(平安) 9:套期保值(计划) 10:套利(合同)  11:换月(合同)  12:交割(金瑞) 13:被套期项目
	SPOTCONTRACTID int64   `json:"hedgeditemid"  xorm:"SPOTCONTRACTID"`                      // 现货ID[套期项目ID] [13 - 被套期项目ID] [4,10,11 - 现货合同ID]  [9 - 套保计划ID]
	RELATEDLOT     float64 `json:"relatedlot"  xorm:"RELATEDLOT"`                            // [数量]关联手数
	GOODSID        int32   `json:"goodsid"  xorm:"GOODSID"`                                  // 商品ID
	GOODSGROUPID   int32   `json:"goodsgroupid"  xorm:"GOODSGROUPID"`                        // 对冲品种ID[期货合约商品组ID]
	MIDDLEGOODSID  int64   `json:"middlegoodsid"  xorm:"MIDDLEGOODSID" form:"middlegoodsid"` // 套保品种ID
	RELATEDQTY     float64 `json:"relatedqty"  xorm:"RELATEDQTY"`                            // 关联数量 = RelatedLot * AgreeUnit * ConvertRatio
	TRADEDATE      string  `json:"tradedate"  xorm:"TRADEDATE"`                              // 关联交易日(yyyyMMdd)
	RELATEDMODE    int32   `json:"relatedmode"  xorm:"RELATEDMODE"`                          // 关联方式 - 1:自动关联 2:手动关联 3:解绑关联
	TRADETRADEDATE string  `json:"tradetradedate"  xorm:"TRADETRADEDATE"`                    // 成交交易日(yyyyMMdd)
	TRADEPRICE     float64 `json:"tradeprice"  xorm:"TRADEPRICE"`                            // [价格]成交价格
	TRADELOT       int64   `json:"tradelot"  xorm:"TRADELOT"`                                // 成交手数
	SALEUSERID     int64   `json:"saleuserid"  xorm:"SALEUSERID"`                            // 业务员ID
	BIZSUBJECTID   int64   `json:"bizsubjectid"  xorm:"BIZSUBJECTID"`                        // 归属业务部门ID - SubjectID
	AGREEUNIT      float64 `json:"agreeunit"  xorm:"AGREEUNIT"`                              // 合约乘数
	CONVERTRATIO   float64 `json:"convertratio"  xorm:"CONVERTRATIO"`                        // 品种系数
	AREAUSERID     int64   `json:"areauserid"  xorm:"AREAUSERID"`                            // 所属机构
	CREATORSRC     int32   `json:"creatorsrc"  xorm:"CREATORSRC"`                            // 创建人来源 - 1:管理端 2:终端 3:交易
	CREATORID      int64   `json:"creatorid"  xorm:"CREATORID"`                              // 创建人ID
	CREATETIME     string  `json:"createtime"  xorm:"CREATETIME"`                            // [日期时间]创建时间
	LINKSTATUS     int32   `json:"linkstatus"  xorm:"LINKSTATUS"`                            // 关联状态 - 1:成功 2:失败 3:解绑
	RETCODE        int32   `json:"retcode"  xorm:"RETCODE"`                                  // 返回码

	ORDERTYPE          int32   `json:"ordertype"  xorm:"ORDERTYPE"`                  // 单据类型[套期工具] - 1:期货单 2:看涨期权单 3:看跌期权单
	OPTIONCODE         string  `json:"optioncode"  xorm:"OPTIONCODE"`                // [期货合约]期权代码 [期权]
	AMOUNT             float64 `json:"amount"  xorm:"AMOUNT"`                        // 金额 = RelatedLot * TradePrice * AgreeUnit
	NAME               string  `json:"name" xorm:"NAME"`                             // 账户名/子账户
	GOODSCODE          string  `json:"goodscode"  xorm:"GOODSCODE"`                  // 商品代码(内部)
	CONVERTRATIOCHANGE float64 `json:"convertratiochange" xorm:"CONVERTRATIOCHANGE"` // 套期商品变化量 = RelatedLot * AgreeUnit * ConvertRatio
	AccountName        string  `json:"accountname" xorm:"ACCOUNTNAME"`               // 套期主体

	USERID int64 `json:"-" form:"userid"` // 用户ID
}

func (r *Patradelinkdetail) calc() {

}

func (r *Patradelinkdetail) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT 
	   to_char(p.tradetime, 'yyyy-mm-dd hh24:mi:ss') CREATETIME,
       p.ORDERTYPE,
       g.GOODSCODE,
       p.BUYORSELL,
       p.TRADEPRICE,
       p.TRADELOT RELATEDLOT,
       p.TRADEAMOUNT AMOUNT,
       p.MIDDLEGOODSQTY CONVERTRATIOCHANGE,
       to_char(p.TRADEID) TRADEID,
       u.ACCOUNTNAME
	FROM ERMCP_PA_TradeLink p
	LEFT JOIN TAACCOUNT ta on ta.accountid = p.ACCOUNTID
  	LEFT JOIN USERACCOUNT u on u.userid = ta.relateduserid
	LEFT JOIN GOODS g ON g.goodsid = p.goodsid
	WHERE p.areauserid = %v AND p.middlegoodsid = %v
	ORDER BY p.TRADEID
	`
	sqlId.FormatParam(r.USERID, r.MIDDLEGOODSID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Patradelinkdetail) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Patradelinkdetail, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Unlinkermcphedgeplan 未关联购销计划
type Unlinkermcphedgeplan struct {
	HEDGEPLANID     string    `json:"hedgeplanid"  xorm:"HEDGEPLANID"`                                    // 套保计划ID(601+Unix秒时间戳(10位)+xxxxxx)
	HEDGEPLANNO     string    `json:"hedgeplanno"  xorm:"HEDGEPLANNO" form:"hedgeplanno"`                 // [计划编号]套保计划编号，模糊查询
	CONTRACTTYPE    int32     `json:"contracttype"  xorm:"CONTRACTTYPE" form:"contracttype"`              // 计划类型 - 1:采购 -1:销售
	AREAUSERID      int64     `json:"areauserid"  xorm:"AREAUSERID" form:"areauserid" binding:"required"` // [企业ID]机构ID
	DELIVERYGOODSID int64     `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`                            // 现货品种ID
	PRODUCTTYPE     int32     `json:"producttype"  xorm:"PRODUCTTYPE"`                                    // 产品类型 - 1:标准仓单 2:等标 3:非标
	SPOTGOODSDESC   string    `json:"spotgoodsdesc"  xorm:"SPOTGOODSDESC"`                                // 商品型号
	PLANQTY         float64   `json:"planqty"  xorm:"PLANQTY"`                                            // [计划量]计划数量
	CONVERTFACTOR   float64   `json:"convertfactor"  xorm:"CONVERTFACTOR"`                                // 标仓系数 - 作废
	PLANTIME        time.Time `json:"plantime"  xorm:"PLANTIME"`                                          // 计划时间
	TRADEDATE       string    `json:"tradedate"  xorm:"TRADEDATE"`                                        // 交易日(yyyyMMdd)
	HEDGEPLANSTATUS int32     `json:"hedgeplanstatus"  xorm:"HEDGEPLANSTATUS"`                            // [状态]套保计划状态 -  0:未提交 1:待审核 2:执行中 3:正常完结 4:审核拒绝 5:异常完结 6:已撤回
	CREATETIME      time.Time `json:"createtime"  xorm:"CREATETIME"`                                      // 创建时间
	UPDATETIME      time.Time `json:"updatetime"  xorm:"UPDATETIME"`                                      // 更新时间
	APPLYSRC        int32     `json:"applysrc"  xorm:"APPLYSRC"`                                          // 申请来源 - 1:管理端 2:终端
	APPLYID         int64     `json:"applyid"  xorm:"APPLYID"`                                            // 申请人
	REMARK          string    `json:"remark"  xorm:"REMARK"`                                              // 备注
	APPLYTIME       time.Time `json:"applytime"  xorm:"APPLYTIME"`                                        // 申请时间
	AUDITTRADEDATE  string    `json:"audittradedate"  xorm:"AUDITTRADEDATE"`                              // 审核交易日(yyyyMMdd)
	AUDITID         int64     `json:"auditid"  xorm:"AUDITID"`                                            // 审核人
	AUDITSRC        int32     `json:"auditsrc"  xorm:"AUDITSRC"`                                          // 审核来源 - 1:管理端 2:终端
	AUDITTIME       time.Time `json:"audittime"  xorm:"AUDITTIME"`                                        // 审核时间
	AUDITREMARK     string    `json:"auditremark"  xorm:"AUDITREMARK"`                                    // 审核备注
	WRSTANDARDID    int64     `json:"wrstandardid"  xorm:"WRSTANDARDID"`                                  // 现货商品ID
	ACCOUNTID       int64     `json:"accountid"  xorm:"ACCOUNTID"`                                        // 期货账户ID - 作废
	TRADEUSERID     int64     `json:"tradeuserid"  xorm:"TRADEUSERID"`                                    // 交易用户ID
	CURRENCYID      int64     `json:"currencyid"  xorm:"CURRENCYID"`                                      // 结算币种ID - 作废
	BIZTYPE         int32     `json:"biztype"  xorm:"BIZTYPE"`                                            // 业务类型 - 1:套保
	ISRELATED       int32     `json:"isrelated"  xorm:"ISRELATED"`                                        // 是否已关联计划项目 - 0:否 1:是

	AccountName    string `json:"accountname" xorm:"ACCOUNTNAME"`                             // 交易用户
	EnumdicName    string `json:"enumdicname"  xorm:"ENUMDICNAME"`                            // 结算币种
	Wrstandardname string `json:"wrstandardname" xorm:"WRSTANDARDNAME" form:"wrstandardname"` // 现货商品，模糊查询
}

func (r *Unlinkermcphedgeplan) calc() {

}

func (r *Unlinkermcphedgeplan) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT
		to_char(t.HEDGEPLANID) HEDGEPLANID,
		t.HEDGEPLANNO,
		u.ACCOUNTNAME,
		t.CONTRACTTYPE,
		wr.WRSTANDARDNAME,
		t.PLANQTY,
		e.ENUMDICNAME,
		t.HEDGEPLANSTATUS,
		t.WRSTANDARDID
	FROM ERMCP_HedgePlan t
	LEFT JOIN USERACCOUNT u on u.userid = t.tradeuserid
	LEFT JOIN WRStandard wr ON wr.wrstandardid = t.wrstandardid
	LEFT JOIN ENUMDICITEM e ON e.ENUMITEMNAME = t.CURRENCYID and e.ENUMDICCODE = 'currency'
	WHERE t.areauserid = %v AND T.ISRELATED = 0 AND T.HEDGEPLANSTATUS = 2 
	`
	sqlId.FormatParam(r.AREAUSERID)
	sqlId.AndEx("t.contracttype", r.CONTRACTTYPE, r.CONTRACTTYPE > 0)
	sqlId.AndLike("t.hedgeplanno", r.HEDGEPLANNO)
	sqlId.AndLike("wr.WRSTANDARDNAME", r.HEDGEPLANNO)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Unlinkermcphedgeplan) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Unlinkermcphedgeplan, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Ermcp2hedgeditemlink 项目现货关联表
type Ermcp2hedgeditemlink struct {
	HEDGEDITEMLINKID      int64   `json:"hedgeditemlinkid"  xorm:"HEDGEDITEMLINKID"`                                                    // 现货关联表ID(626+Unix秒时间戳(10位)+xxxxxx)
	HEDGEDITEMID          int64   `json:"hedgeditemid"  xorm:"HEDGEDITEMID"`                                                            // 被套期项目ID
	HEDGEDTYPE            int32   `json:"hedgedtype"  xorm:"HEDGEDTYPE"`                                                                // 套期类型 - 1:采购计划项目 2:销售计划项目 3:现货贸易项目 4:库存存货项目 5:定价采购合同项目
	SPOTTYPE              int32   `json:"spottype"  xorm:"SPOTTYPE"`                                                                    // 现货类型 - 1:采购计划 2:销售计划 3:采购合同 4:销售合同 5:库存存货
	RELATEDTYPE           int32   `json:"relatedtype"  xorm:"RELATEDTYPE"`                                                              // 关联类型 - 1:套期关联 2:执行关联
	RELATEDHEDGEPLANID    int64   `json:"relatedhedgeplanid"  xorm:"RELATEDHEDGEPLANID"`                                                // 关联计划ID 【1:采购计划 2:销售计划】
	RELATEDSPOTCONTRACTID int64   `json:"relatedspotcontractid"  xorm:"RELATEDSPOTCONTRACTID" form:"spotcontractid" binding:"required"` // 关联合同ID 【3:采购合同 4:销售合同】
	CUSTOMERUSERID        int64   `json:"customeruserid"  xorm:"CUSTOMERUSERID"`                                                        // 对手方 【3:采购合同 4:销售合同】
	DELIVERYGOODSID       int64   `json:"deliverygoodsid"  xorm:"DELIVERYGOODSID"`                                                      // 现货品种ID
	WRSTANDARDID          int64   `json:"wrstandardid"  xorm:"WRSTANDARDID"`                                                            // 现货商品ID
	SPOTGOODSBRANDID      int32   `json:"spotgoodsbrandid"  xorm:"SPOTGOODSBRANDID"`                                                    // 现货品牌ID
	TRADEUSERID           int64   `json:"tradeuserid"  xorm:"TRADEUSERID"`                                                              // 交易用户ID
	AREAUSERID            int64   `json:"areauserid"  xorm:"AREAUSERID"`                                                                // 企业ID
	RELATEDQTY            float64 `json:"relatedqty"  xorm:"RELATEDQTY"`                                                                // 关联数量
	RELATEDAMOUNT         float64 `json:"relatedamount"  xorm:"RELATEDAMOUNT"`                                                          // 市价总额 = 关联数量 * 期初市场价
	SPOTPRICEDAMOUNT      float64 `json:"spotpricedamount"  xorm:"SPOTPRICEDAMOUNT"`                                                    // [关联定价总额]定价总额
	SPOTPRICEDAVGPRICE    float64 `json:"spotpricedavgprice"  xorm:"SPOTPRICEDAVGPRICE"`                                                // [关联现货均价]现货均价 = 定价总额 / 关联数量
	UNEXEQTY              float64 `json:"unexeqty"  xorm:"UNEXEQTY"`                                                                    // 未执行现货量【项目关联时值】
	CREATETIME            string  `json:"createtime"  xorm:"CREATETIME"`                                                                // [关联时间]创建时间

	HEDGEDITEMNUM  string `json:"hedgeditemnum"  xorm:"HEDGEDITEMNUM"`  // 项目编号
	Wrstandardname string `json:"wrstandardname" xorm:"WRSTANDARDNAME"` // 现货商品
	EnumdicName    string `json:"enumdicname"  xorm:"ENUMDICNAME"`      // 单位
}

// TableName is ERMCP2_HEDGEDITEMLINK
func (r *Ermcp2hedgeditemlink) TableName() string {
	return "ERMCP2_HEDGEDITEMLINK"
}

func (r *Ermcp2hedgeditemlink) calc() {

}

func (r *Ermcp2hedgeditemlink) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT
		to_char(t.CREATETIME, 'yyyy-mm-dd hh24:mi:ss') CREATETIME,
		h.HEDGEDITEMNUM,
		wr.WRSTANDARDNAME,
		e.ENUMDICNAME,
		t.RELATEDQTY,
		t.SPOTPRICEDAMOUNT,
		t.SPOTPRICEDAVGPRICE,
		t.HEDGEDTYPE
	FROM ERMCP2_HEDGEDITEMLINK t
	LEFT JOIN ERMCP2_HedgedItem h ON h.HEDGEDITEMID = t.HEDGEDITEMID
	LEFT JOIN WRStandard wr ON wr.wrstandardid = t.wrstandardid
	LEFT JOIN enumdicitem e on wr.unitid=e.enumitemname and e.enumdiccode='goodsunit'
	WHERE t.RELATEDSPOTCONTRACTID = %v
	`
	sqlId.FormatParam(r.RELATEDSPOTCONTRACTID)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Ermcp2hedgeditemlink) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Ermcp2hedgeditemlink, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}

// Marketcalendar 市场节假日表
type Marketcalendar struct {
	MARKETID    int32  `json:"marketid"  xorm:"MARKETID" form:"marketid"` // 市场ID
	HOLIDAYDATE string `json:"holidaydate"  xorm:"HOLIDAYDATE"`           // 节假日期(yyyy-MM-dd)
}

// TableName is MARKETCALENDAR
func (r *Marketcalendar) TableName() string {
	return "MARKETCALENDAR"
}

func (r *Marketcalendar) calc() {

}

func (r *Marketcalendar) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT 
		t.MARKETID,
		to_char(to_date(t.HOLIDAYDATE,'yyyyMMdd'), 'yyyy-MM-dd') HOLIDAYDATE
	FROM MarketCalendar t
	WHERE 1 = 1
	`
	sqlId.AndEx("t.MARKETID", r.MARKETID, r.MARKETID > 0)

	return sqlId.String()
}

// GetDataEx 从数据库中查询数据
func (r *Marketcalendar) GetDataEx() (interface{}, error) {
	e := db.GetEngine()
	s := e.SQL(r.buildSql())
	sData := make([]Marketcalendar, 0)
	if err := s.Find(&sData); err != nil {
		return nil, err
	}
	for i := range sData {
		sData[i].calc()
	}
	return sData, nil
}