MTP20_IF/models/common.go

package models

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"mtp2_if/db"
	"mtp2_if/mtpcache"
	"mtp2_if/utils"
	"net/http"
	"strconv"
	"strings"
	"time"
)

// Funcmenulist 功能菜单表
type Funcmenulist struct {
	Resourcecode  string `json:"resourcecode"  xorm:"'RESOURCECODE'" binding:"required"` // 资源代码
	Resourcename  string `json:"resourcename"  xorm:"'RESOURCENAME'"`                    // 资源名
	Resourcelevel uint32 `json:"resourcelevel"  xorm:"'RESOURCELEVEL'"`                  // 级别 1-一级 2-二级 3-三级 4-四级
	Menutype      uint32 `json:"menutype"  xorm:"'MENUTYPE'"`                            // 菜单类型 1-管理端 2-交易端 3-终端权限
	Parentcode    string `json:"parentcode"  xorm:"'PARENTCODE'"`                        // 上级资源代码
	URL           string `json:"url"  xorm:"'URL'"`                                      // URL
	Sort          uint32 `json:"sort"  xorm:"'SORT'"`                                    // 排序 - 一级时，是所有一级菜单的排序顺序；二级时是所属同一个一级菜单下的排序、三级时是同一个二级菜单下的排序
	Iconame       string `json:"iconame"  xorm:"'ICONAME'"`                              // 菜单图标
	Remark        string `json:"remark"  xorm:"'REMARK'"`                                // 备注
}

// TableName is FUNCMENULIST
func (Funcmenulist) TableName() string {
	return "FUNCMENULIST"
}

// GetPCMenuList 获取PC版本功能菜单表
func (t *Funcmenulist) GetPCMenuList(resourceCode, parentCode string) ([]Funcmenulist, error) {
	funcMenuLists := make([]Funcmenulist, 0)
	session := db.GetEngine().Table("FUNCMENULIST T").Where("T.MENUTYPE = 2")
	if len(resourceCode) != 0 {
		session = session.And("T.RESOURCECODE = ?", resourceCode)
	}
	if len(parentCode) != 0 {
		session = session.And("T.PARENTCODE = ?", parentCode)
	}
	if err := session.Find(&funcMenuLists); err != nil {
		return nil, err
	}

	return funcMenuLists, nil
}

// GetMenuList 获取指定类型的功能菜单表
func (t *Funcmenulist) GetMenuList(menuType int) ([]Funcmenulist, error) {
	funcMenuLists := make([]Funcmenulist, 0)
	session := db.GetEngine().Table("FUNCMENULIST T").Where("T.MENUTYPE = ?", menuType)
	if err := session.Find(&funcMenuLists); err != nil {
		return nil, err
	}

	return funcMenuLists, nil
}

// Rolefuncmenu 角色菜单表
type Rolefuncmenu struct {
	Roleid       uint32 `json:"roleid"  xorm:"'ROLEID'" binding:"required"`             // 角色权限ID
	Resourcecode string `json:"resourcecode"  xorm:"'RESOURCECODE'" binding:"required"` // 菜单代码
}

// TableName is ROLEFUNCMENU
func (Rolefuncmenu) TableName() string {
	return "ROLEFUNCMENU"
}

// Tabledefine 列表定义表
type Tabledefine struct {
	Tablekey  string `json:"tablekey"  xorm:"'TABLEKEY'" binding:"required"` // 列表Key
	Tabletype uint32 `json:"tabletype"  xorm:"'TABLETYPE'"`                  // 列表类型 - 1:管理端 2:终端
	Tablename string `json:"tablename"  xorm:"'TABLENAME'"`                  // 列表名称
	Tabelmenu string `json:"tabelmenu"  xorm:"'TABELMENU'"`                  // 列表菜单
	Remark    string `json:"remark"  xorm:"'REMARK'"`                        // Remark
}

// TableName is TABLEDEFINE
func (Tabledefine) TableName() string {
	return "TABLEDEFINE"
}

// Tablecolumnconfig 列表表头配置表
type Tablecolumnconfig struct {
	Autoid          uint64 `json:"autoid"  xorm:"'AUTOID'" binding:"required"` // AutoID
	Tablekey        string `json:"tablekey"  xorm:"'TABLEKEY'"`                // 列表Key
	Columnfield     string `json:"columnfield"  xorm:"'COLUMNFIELD'"`          // 列字段
	Columntitle     string `json:"columntitle"  xorm:"'COLUMNTITLE'"`          // 列Title
	Columnwidth     string `json:"columnwidth"  xorm:"'COLUMNWIDTH'"`          // 列宽
	Orderindex      uint32 `json:"orderindex"  xorm:"'ORDERINDEX'"`            // 顺序
	Isshow          uint32 `json:"isshow"  xorm:"'ISSHOW'"`                    // 是否显示 - 0:不显示 1:显示
	Aligntype       uint32 `json:"aligntype"  xorm:"'ALIGNTYPE'"`              // 对齐方式 - 1:居中对齐 2:左对齐 3:右对齐
	Formattertype   string `json:"formattertype"  xorm:"'FORMATTERTYPE'"`      // 格式化类型
	Formatterstring string `json:"formatterstring"  xorm:"'FORMATTERSTRING'"`  // 格式化字符
	Remark          string `json:"remark"  xorm:"'REMARK'"`                    // 备注
	Needsummary     uint32 `json:"needsummary"  xorm:"'NEEDSUMMARY'"`          // 是否需要汇总 - 0:不需要 1:需要
	Summarytype     uint32 `json:"summarytype"  xorm:"'SUMMARYTYPE'"`          // 汇总类型 - 1:加总 2:最后一个
	Groupname       string `json:"groupname"  xorm:"'GROUPNAME'"`              // 表头分组名称
	ISMERGE         int32  `json:"ismerge"  xorm:"ISMERGE"`                    // 是否合并显示 - 0:不合并 1:合并
	FIXED           string `json:"fixed"  xorm:"FIXED"`                        // 固定类型 - 空 | left | right
}

// TableName is TABLECOLUMNCONFIG
func (Tablecolumnconfig) TableName() string {
	return "TABLECOLUMNCONFIG"
}

// Enumdicitem 枚举项字典表
type Enumdicitem struct {
	Autoid           int64  `json:"-"  xorm:"'AUTOID'" binding:"required"`                  // 自增ID
	Enumdicid        int32  `json:"-"  xorm:"'ENUMDICID'" binding:"required"`               // 所属枚举ID
	Enumdiccode      string `json:"enumdiccode"  xorm:"'ENUMDICCODE'" binding:"required"`   // 所属枚举代码
	Enumdicname      string `json:"enumdicname"  xorm:"'ENUMDICNAME'"`                      // 枚举项名称
	Enumitemname     int64  `json:"enumitemname"  xorm:"'ENUMITEMNAME'" binding:"required"` // 枚举项值
	Enumitemstatus   int32  `json:"enumitemstatus"  xorm:"'ENUMITEMSTATUS'"`                // 枚举项状态 - 1.启用 2.不启用
	Bankmappedvalue  string `json:"-"  xorm:"'BANKMAPPEDVALUE'"`                            // 银行服务对应值
	Remark           string `json:"-"  xorm:"'REMARK'"`                                     // 备注
	Enumitemvalue    string `json:"enumitemvalue"  xorm:"'ENUMITEMVALUE'"`                  // 通用值 - [币种通用简写]
	Param1           string `json:"param1"  xorm:"'PARAM1'"`                                // 参数1[币种:币种小数位]
	Param2           string `json:"param2"  xorm:"'PARAM2'"`                                // 参数1[币种:币种显示单位]
	EnumdicnameEn    string `json:"enumdicnameen"  xorm:"'ENUMDICNAMEEN'"`                  // 枚举项名称 - 英文
	EnumdicnameZh_Tw string `json:"enumdicnamezh_tw"  xorm:"'ENUMDICNAMEZH_TW'"`            // 枚举项名称 - 繁体
	EnumdicnameTh    string `json:"enumdicnameth"  xorm:"'ENUMDICNAMETH'"`                  // 枚举项名称 - 泰文
	EnumdicnameVi    string `json:"enumdicnamevi"  xorm:"'ENUMDICNAMEVI'"`                  // 枚举项名称 - 越南语
}

// TableName is ENUMDICITEM
func (Enumdicitem) TableName() string {
	return "ENUMDICITEM"
}

// Noticemsg 公告消息表
type Noticemsg struct {
	Autoid  int32  `json:"autoid"  xorm:"'AUTOID'" binding:"required"` // 自增ID
	Msgtype int32  `json:"msgtype"  xorm:"'MSGTYPE'"`                  // 消息类型 - 1:公告通知 2:系统消息 3:商品到期提货通知
	Title   string `json:"title"  xorm:"'TITLE'"`                      // 标题
	// Content        string    `json:"content"  xorm:"'CONTENT'"`                  // 内容
	Scheduletime   time.Time `json:"-"  xorm:"'SCHEDULETIME'"`                // 计划发送时间
	Publisher      string    `json:"publisher"  xorm:"'PUBLISHER'"`           // 消息发布者
	Sendtype       int32     `json:"-"  xorm:"'SENDTYPE'"`                    // 推送方式 - 1：全体广播 2：按会员广播 3：个人推送 4:按会员广播(仅会员)
	Userid         int64     `json:"-"  xorm:"'USERID'"`                      // 会员/投资者ID推送方式 为 个人时，填写投资者ID
	Istop          int32     `json:"istop"  xorm:"'ISTOP'"`                   // 是否置顶 - 0:不置顶 1:置顶
	Sentstatus     int32     `json:"sentstatus"  xorm:"'SENTSTATUS'"`         // 推送状态 - 0:未推送 1:已推送 2:审核拒绝
	Endtime        time.Time `json:"-"  xorm:"'ENDTIME'"`                     // 结束时间
	Creatorid      int64     `json:"-"  xorm:"'CREATORID'"`                   // 建仓人
	Createtime     time.Time `json:"createtime"  xorm:"'CREATETIME'"`         // 创建时间
	Auditoruserid  int64     `json:"-"  xorm:"'AUDITORUSERID'"`               // 审核人
	Audittime      time.Time `json:"-"  xorm:"'AUDITTIME'"`                   // 审核日期
	Auditremark    string    `json:"-"  xorm:"'AUDITREMARK'"`                 // 审核备注
	Msgiconurl     string    `json:"msgiconurl"  xorm:"'MSGICONURL'"`         // 消息图标Url
	IsforceDisplay int32     `json:"isforcedisplay"  xorm:"'ISFORCEDISPLAY'"` // 是否强制显示 - 0:不强制 1:强制
	Content        string    `json:"content"  xorm:"'CONTENT2'"`              // 内容 - 返回content2

	TitleEn   string `json:"titleen" xorm:"TITLEEN"`         // 标题(英文)
	TitleTw   string `json:"titletw" xorm:"TITLETW"`         // 标题(繁体)
	TitleTh   string `json:"titleth" xorm:"TITLETH"`         // 标题(泰文)
	TitleVi   string `json:"titlevi" xorm:"TITLEVI"`         // 标题(越南语)
	ContentEn string `json:"contenten"  xorm:"'CONTENT2EN'"` // 内容 - 返回content2(英文)
	ContentTw string `json:"contenttw"  xorm:"'CONTENT2TW'"` // 内容 - 返回content2(繁体)
	ContentTh string `json:"contentth"  xorm:"'CONTENT2TH'"` // 内容 - 返回content2(泰文)
	ContentVi string `json:"contentvi"  xorm:"'CONTENT2VI'"` // 内容 - 返回content2(越南语)
}

// TableName is NOTICEMSG
func (Noticemsg) TableName() string {
	return "NOTICEMSG"
}

// Memberrecv 会员消息接受表
type Memberrecv struct {
	Msgid    int32 `json:"msgid"  xorm:"'MSGID'" binding:"required"`       // 消息ID
	Memberid int64 `json:"memberid"  xorm:"'MEMBERID'" binding:"required"` // 会员用户ID
}

// TableName is MEMBERRECV
func (Memberrecv) TableName() string {
	return "MEMBERRECV"
}

// Msgreceiver 管理端消息接收者
type Msgreceiver struct {
	Autoid       int32     `json:"autoid"  xorm:"'AUTOID'" binding:"required"`             // 消息ID
	Managerid    int64     `json:"managerid"  xorm:"'MANAGERID'" binding:"required"`       // 用户ID
	Readstatus   int32     `json:"readstatus"  xorm:"'READSTATUS'" binding:"required"`     // 消息状态 - 1：未阅读 2：已阅读 3：已删除
	Receivertype int32     `json:"receivertype"  xorm:"'RECEIVERTYPE'" binding:"required"` // 接收用户类型 - 1:管理端用户 2:终端用户
	Updatetime   time.Time `json:"updatetime"  xorm:"'UPDATETIME'"`                        // 更新时间
}

// TableName is MSGRECEIVER
func (Msgreceiver) TableName() string {
	return "MSGRECEIVER"
}

// Division 行政区域表
type Division struct {
	Autoid        int64     `json:"autoid"  xorm:"'AUTOID'" binding:"required"`             // 自增ID
	Divisioncode  string    `json:"divisioncode"  xorm:"'DIVISIONCODE'" binding:"required"` // 行政代码
	Shortcode     string    `json:"shortcode"  xorm:"'SHORTCODE'"`                          // 地区简码
	Parentcode    string    `json:"parentcode"  xorm:"'PARENTCODE'"`                        // 上级行政代码
	Divisionlevel string    `json:"divisionlevel"  xorm:"'DIVISIONLEVEL'"`                  // 行政级别
	Divisionname  string    `json:"divisionname"  xorm:"'DIVISIONNAME'"`                    // 行政名称
	Pathname      string    `json:"pathname"  xorm:"'PATHNAME'"`                            // 路径名称
	Separablename string    `json:"separablename"  xorm:"'SEPARABLENAME'"`                  // 可拆分的全称
	Postcode      string    `json:"postcode"  xorm:"'POSTCODE'"`                            // 邮政编码
	Modifytime    time.Time `json:"modifytime"  xorm:"'MODIFYTIME'"`                        // 修改时间
	Modifierid    int64     `json:"modifierid"  xorm:"'MODIFIERID'"`                        // 修改人
}

// TableName is DIVISION
func (Division) TableName() string {
	return "DIVISION"
}

// Szdz2imageconfig 终端图片配置  - 通用功能
type Szdz2imageconfig struct {
	Configid        int64     `json:"configid"  xorm:"'CONFIGID'" binding:"required"` // 配置ID(SEQ_SZDZ2_IMAGECONFIG)
	Imagetype       int32     `json:"imagetype"  xorm:"'IMAGETYPE'"`                  // 类型 - 1:首页轮播(移动) 2:我的(移动)
	Title           string    `json:"title"  xorm:"'TITLE'"`                          // 标题
	Imagepath       string    `json:"imagepath"  xorm:"'IMAGEPATH'"`                  // 图片
	URL             string    `json:"url"  xorm:"'URL'"`                              // 链接(地址或商品ID)
	Sort            int64     `json:"sort"  xorm:"'SORT'"`                            // 排序
	Isshow          int32     `json:"isshow"  xorm:"'ISSHOW'"`                        // 是否展示 - 0:不展示 1:展示
	Createdate      time.Time `json:"createdate"  xorm:"'CREATEDATE'"`                // 创建时间
	Creatorid       int64     `json:"creatorid"  xorm:"'CREATORID'"`                  // 创建人
	Updatedate      time.Time `json:"updatedate"  xorm:"'UPDATEDATE'"`                // 修改时间
	Modifierid      int64     `json:"modifierid"  xorm:"'MODIFIERID'"`                // 操作人
	Areauserid      int64     `json:"areauserid"  xorm:"'AREAUSERID'"`                // 所属机构ID
	Urltype         int32     `json:"urltype"  xorm:"'URLTYPE'"`                      // 链接类型 - 1:直接地址 2:商品ID
	IMAGEDETAILPATH string    `json:"imagedetailpath"  xorm:"'IMAGEDETAILPATH'"`      // 详情图片 [UrlType = 3时 有且必填，其它类型不需要]
}

// TableName is SZDZ2_IMAGECONFIG
func (Szdz2imageconfig) TableName() string {
	return "SZDZ2_IMAGECONFIG"
}

// Errorcode 异常代码表
type Errorcode struct {
	Errorid     int64  `json:"errorid"  xorm:"'ERRORID'" binding:"required"` // 异常ID
	Errorcode   string `json:"errorcode"  xorm:"'ERRORCODE'"`                // 异常代码
	Modulecode  string `json:"modulecode"  xorm:"'MODULECODE'"`              // 所属模块
	Operatecode string `json:"operatecode"  xorm:"'OPERATECODE'"`            // 所属操作
	Description string `json:"description"  xorm:"'DESCRIPTION'"`            // 异常描述
}

// TableName is ERRORCODE
func (Errorcode) TableName() string {
	return "ERRORCODE"
}

// Systemparam 系统参数表
type Systemparam struct {
	Paramcode   string    `json:"paramcode"  xorm:"'PARAMCODE'" binding:"required"` // 参数代码
	Paramname   string    `json:"-"  xorm:"'PARAMNAME'"`                            // 参数名
	Paramvalue  string    `json:"paramvalue"  xorm:"'PARAMVALUE'"`                  // 参数值
	Paramtype   int32     `json:"-"  xorm:"'PARAMTYPE'"`                            // 参数类型  0-通用 1-管理端 2-终端  3-后台 4-商城
	Showflag    int32     `json:"-"  xorm:"'SHOWFLAG'"`                             // 是否显示0 不显示   1 显示
	Modifyflag  int32     `json:"-"  xorm:"'MODIFYFLAG'"`                           // 修改标志0 不允许修改   1 允许修改
	Serverip    string    `json:"-"  xorm:"'SERVERIP'"`                             // 限制服务器IP,备份参数，现在界面不用显示0.0.0.0则无限制，是通用参数192.168.0.211 指定服务器的参数配置
	Userid      int64     `json:"-"  xorm:"'USERID'"`                               // 更新用户ID
	Loginid     string    `json:"-"  xorm:"'LOGINID'"`                              // 更新用户账号,登录账号
	Updatetime  time.Time `json:"-"  xorm:"'UPDATETIME'"`                           // 更新时间
	Remark      string    `json:"-"  xorm:"'REMARK'"`                               // 备注
	Paramvalue2 string    `json:"paramvalue2"  xorm:"'PARAMVALUE2'"`                // 参数值(CLOB)
	Regexpress  string    `json:"-"  xorm:"'REGEXPRESS'"`                           // 正则表达式
}

// TableName is SYSTEMPARAM
func (Systemparam) TableName() string {
	return "SYSTEMPARAM"
}

// Ermcpmemberfuncmenu 企业成员菜单表
type Ermcpmemberfuncmenu struct {
	Userid       int64     `json:"userid"  xorm:"'USERID'" binding:"required"`             // 用户ID
	Roleid       int32     `json:"roleid"  xorm:"'ROLEID'" binding:"required"`             // 角色权限ID(0-管理员 22-业务员 23-跟单员 24-交易员)
	Resourcecode string    `json:"resourcecode"  xorm:"'RESOURCECODE'" binding:"required"` // 菜单代码
	Modifysrc    int32     `json:"modifysrc"  xorm:"'MODIFYSRC'"`                          // 修改来源 - 1:管理端 2:终端
	Modifytime   time.Time `json:"modifytime"  xorm:"'MODIFYTIME'"`                        // 修改时间
	Modifyid     int64     `json:"modifyid"  xorm:"'MODIFYID'"`                            // 修改人
	Modifyremark string    `json:"modifyremark"  xorm:"'MODIFYREMARK'"`                    // 修改备注
	Isvalid      int32     `json:"isvalid"  xorm:"'ISVALID'"`                              // 是否有效 - 0:无效 1:有效
}

// TableName is ERMCP_MEMBERFUNCMENU
func (Ermcpmemberfuncmenu) TableName() string {
	return "ERMCP_MEMBERFUNCMENU"
}

// QuotePrimaryMenu 报价牌一级分类菜单
type QuotePrimaryMenu struct {
	Index        int                  `json:"Index"`        // 序号
	Key          string               `json:"Key"`          // 键名
	Name         string               `json:"Name"`         // 菜单名称
	SubTitleType int                  `json:"SubTitleType"` // 子菜单标题模式：0-市场名称；1-外部交易所名称
	TradeModes   string               `json:"TradeModes"`   // 包含市场交易类型
	SubMenus     []QuoteSecondaryMenu `json:"SubMenus"`     // 子菜单
}

// QuoteSecondaryMenu 报价牌二级分类菜单
type QuoteSecondaryMenu struct {
	Index          int    `json:"Index"`                                  // 序号
	MarketID       int    `json:"MarketID"`                               // 市场ID
	TradeMode      int    `json:"TradeMode"`                              // 交易模式
	MenuTitle      string `json:"MenuTitle" xorm:"'ExExchangeName'"`      // 菜单标题（市场名称或外部交易所名称）
	GoodsGroupIDs  []int  `json:"GoodsGroupIDs"`                          // 商品组ID列表
	ExExchangeID   int    `json:"ExExchangeID" xorm:"'ExExchangeID'"`     // 外部交易所ID
	ExExchangeCode string `json:"ExExchangeCode" xorm:"'ExExchangeCode'"` // 外部交易所代码
}

// OperationPrimaryMenu 一级功能菜单
type OperationPrimaryMenu struct {
	Key      string                   `json:"Key"`      // 菜单KEY
	Label    string                   `json:"Label"`    // 菜单标题
	Children []OperationSecondaryMenu `json:"Children"` // 二级功能菜单
}

// OperationSecondaryMenu 二级功能菜单
type OperationSecondaryMenu struct {
	Key     string             `json:"Key"`     // 菜单KEY
	Label   string             `json:"Label"`   // 菜单标题
	TabList []OperationTabMenu `json:"TabList"` // 三级功能菜单
}

// OperationTabMenu 三级功能菜单
type OperationTabMenu struct {
	Key   string `json:"Key"`   // 菜单KEY
	Label string `json:"Label"` // 菜单标题
}

// GetQuoteMenu 获取行情报价牌分类菜单
func GetQuoteMenu(loginID int) ([]QuotePrimaryMenu, error) {
	engine := db.GetEngine()
	rst := make([]QuotePrimaryMenu, 0)

	// 账户下有权限的市场ID列表
	var marketIDs []int

	// 获取账户类型 - 1:交易所 2:机构 3:会员子机构 4:经纪人 5:投资者 6:客户  (目前可能登录交易端的账号类型为 2 5)
	userAccount := new(Useraccount)
	has, err := engine.Join("INNER", "LOGINACCOUNT", "USERACCOUNT.UserID = LOGINACCOUNT.UserID").Where("LOGINACCOUNT.LoginID = ?", loginID).Get(userAccount)
	if err != nil || !has {
		return nil, err
	}
	if userAccount.Usertype == 5 {
		// 如果账户类型为5（投资者），则需要通过其所属经济会员来获取市场权限（表：AreaRoleMarket, 条件：对应市场状态为正常；角色类型：经济会员）
		if err := engine.Table("AREAROLEMARKET").
			Cols("AREAROLEMARKET.MARKETID").
			Join("INNER", "MARKET", "MARKET.MARKETID = AREAROLEMARKET.MARKETID").
			Where("MARKET.MARKETSTATUS = 2 and AREAROLEMARKET.ROLETYPE = 7 and AREAROLEMARKET.AREAUSERID = ?", userAccount.Memberuserid).Find(&marketIDs); err != nil {
			return nil, err
		}
	} else {
		// 非投资者账号直接通过资金账号获取市场权限（表：TAAccountMarket）
		var taAccounts []string // 账户下所有资金账户

		// 先要获取当前登录账户对应的资金账户；如果为外部子资金账号（TaAccount.TaAccountType = 1），则使用TaAccount.FromAccountID来获取市场权限
		type taAccount struct {
			AccountID     int `xorm:"ACCOUNTID"`
			TaAccountType int `xorm:"TAACCOUNTTYPE"`
			FromAccountID int `xorm:"FROMACCOUNTID"`
		}
		datas := make([]taAccount, 0)
		if err := engine.Table("LOGINTAACCOUNT").
			Join("INNER", "TAACCOUNT", "LOGINTAACCOUNT.ACCOUNTID = TAACCOUNT.ACCOUNTID").
			Cols("TAACCOUNT.ACCOUNTID", "TAACCOUNT.TAACCOUNTTYPE", "TAACCOUNT.FROMACCOUNTID").
			Where("LOGINTAACCOUNT.LOGINID = ?", loginID).Find(&datas); err != nil {
			return nil, err
		}
		// 如果一条记录都没有(未配置自营会员资金账户)则直接通过资金账户表获取
		if len(datas) == 0 {
			// 这里要注意，TaAccount表与LoginAccount表关联时，要使用TaAccount.RelatedUserID
			if err := engine.Table("TAACCOUNT").
				Join("INNER", "LOGINACCOUNT", "TAACCOUNT.RELATEDUSERID = LOGINACCOUNT.USERID").
				Cols("TAACCOUNT.ACCOUNTID", "TAACCOUNT.TAACCOUNTTYPE", "TAACCOUNT.FROMACCOUNTID").
				Where("LOGINACCOUNT.LOGINID = ?", loginID).Find(&datas); err != nil {
				return nil, err
			}
		}
		for _, v := range datas {
			if v.TaAccountType == 1 {
				// 外部资金账户使用TaAccount.FromAccountID来获取市场权限
				taAccounts = append(taAccounts, strconv.Itoa(v.FromAccountID))
			} else {
				taAccounts = append(taAccounts, strconv.Itoa(v.AccountID))
			}
		}

		// 获取资金账户对应的市场权限（有权限的市场ID）
		if len(taAccounts) > 0 {
			// taAccountStr := strings.Join(taAccounts, ",")
			if err := engine.Table("TAACCOUNTMARKET").
				Join("INNER", "MARKET", "MARKET.MARKETID = TAACCOUNTMARKET.MARKETID").
				Cols("TAACCOUNTMARKET.MARKETID").
				In("TAACCOUNTMARKET.ACCOUNTID", taAccounts).
				And("MARKET.MARKETSTATUS = 2").Find(&marketIDs); err != nil {
				return nil, err
			}
		}
	}

	// ********************* 构建行情报价牌菜单 *********************
	datas := make([]Funcmenulist, 0)
	if err := engine.Join("INNER", "ROLEFUNCMENU", "FUNCMENULIST.RESOURCECODE = ROLEFUNCMENU.RESOURCECODE").
		Where("FUNCMENULIST.PARENTCODE = 'trader_master_menu'").
		Asc("SORT").
		Find(&datas); err != nil {
		return nil, err
	}
	// 构建一级菜单对象
	for i, v := range datas {
		quotePrimaryMenu := QuotePrimaryMenu{
			Index:    i,
			Key:      v.Resourcecode,
			Name:     v.Resourcename,
			SubMenus: make([]QuoteSecondaryMenu, 0),
		}
		// 跳过自选
		if v.Resourcecode == "optional" {
			rst = append(rst, quotePrimaryMenu)
			continue
		}
		// URL：模式，0-使用市场名称，1-使用外部交易所名称；Remark：包含市场交易模式
		quotePrimaryMenu.SubTitleType, _ = strconv.Atoi(v.URL)
		quotePrimaryMenu.TradeModes = v.Remark

		// 如果传入的LoginID获取不到有权限的市场ID列表（有可能LoginID是错误的），则不构建二级子菜单
		if len(marketIDs) == 0 {
			rst = append(rst, quotePrimaryMenu)
			continue
		}

		// 构建二级子菜单对象
		marketIDsStr := utils.JoinItoString(marketIDs, ",")
		if quotePrimaryMenu.SubTitleType == 0 {
			// 获取目标交易模式的市场信息
			markets := make([]Market, 0)
			if err := engine.Where(fmt.Sprintf(`TradeMode in (%s) and MarketID in (%s)`, quotePrimaryMenu.TradeModes, marketIDsStr)).Find(&markets); err != nil {
				return nil, err
			}
			// 使用市场名称
			for mi, mv := range markets {
				quoteSecondaryMenu := QuoteSecondaryMenu{
					Index:         mi,
					MarketID:      int(mv.MARKETID),
					TradeMode:     int(mv.TRADEMODE),
					MenuTitle:     mv.MARKETNAME,
					GoodsGroupIDs: make([]int, 0),
				}
				quotePrimaryMenu.SubMenus = append(quotePrimaryMenu.SubMenus, quoteSecondaryMenu)
			}
		} else {
			// 使用外部交易所名称
			quoteSecondaryMenus := make([]QuoteSecondaryMenu, 0)
			sql := fmt.Sprintf(`select distinct
									e.autoid ExExchangeID,
									e.ExExchangeName,
									e.ExExchangeCode 
								from ExternalExchange e
								inner join goodsgroup g  on g.exexchangeid = e.autoid
								inner join Market m on g.marketid = m.marketid
								where m.trademode in (%s) and m.marketid in (%s)`, quotePrimaryMenu.TradeModes, marketIDsStr)
			if err := engine.SQL(sql).Find(&quoteSecondaryMenus); err != nil {
				return nil, err
			}
			// 获取外部交易所对应的商品组信息
			for ei, ev := range quoteSecondaryMenus {
				q := &quoteSecondaryMenus[ei]
				q.Index = ei
				// 商品组列表
				goodsgroups := make([]Goodsgroup, 0)
				if err := engine.Where("Exexchangeid = ?", ev.ExExchangeID).Find(&goodsgroups); err != nil {
					return nil, err
				}
				marketID := 0
				var goodsGroupIDs []int
				for _, gv := range goodsgroups {
					marketID = int(gv.Marketid)
					goodsGroupIDs = append(goodsGroupIDs, int(gv.Goodsgroupid))
				}
				q.MarketID = marketID
				q.GoodsGroupIDs = goodsGroupIDs
			}
			quotePrimaryMenu.SubMenus = quoteSecondaryMenus
		}

		rst = append(rst, quotePrimaryMenu)
	}

	return rst, nil
}

// GetOperationMenu 获取功能菜单
func GetOperationMenu() ([]OperationPrimaryMenu, error) {
	engine := db.GetEngine()
	rst := make([]OperationPrimaryMenu, 0)

	// 获取一级功能菜单
	opm := make([]Funcmenulist, 0)
	if err := engine.Join("INNER", "ROLEFUNCMENU", "FUNCMENULIST.RESOURCECODE = ROLEFUNCMENU.RESOURCECODE").
		Where("FUNCMENULIST.PARENTCODE = 'trader_operation_master_menu'").
		Asc("SORT").
		Find(&opm); err != nil {
		return nil, err
	}
	for _, pv := range opm {
		var operationPrimaryMenu = OperationPrimaryMenu{
			Key:      pv.Resourcecode,
			Label:    pv.Resourcename,
			Children: make([]OperationSecondaryMenu, 0),
		}

		// 获取二级功能菜单
		osm := make([]Funcmenulist, 0)
		if err := engine.Join("INNER", "ROLEFUNCMENU", "FUNCMENULIST.RESOURCECODE = ROLEFUNCMENU.RESOURCECODE").
			Where("FUNCMENULIST.PARENTCODE = ?", operationPrimaryMenu.Key).
			Asc("SORT").
			Find(&osm); err != nil {
			return nil, err
		}
		for _, sv := range osm {
			var operationSecondaryMenu = OperationSecondaryMenu{
				Key:     sv.Resourcecode,
				Label:   sv.Resourcename,
				TabList: make([]OperationTabMenu, 0),
			}

			// 获取三级功能菜单
			otm := make([]Funcmenulist, 0)
			if err := engine.Join("INNER", "ROLEFUNCMENU", "FUNCMENULIST.RESOURCECODE = ROLEFUNCMENU.RESOURCECODE").
				Where("FUNCMENULIST.PARENTCODE = ?", operationSecondaryMenu.Key).
				Asc("SORT").
				Find(&otm); err != nil {
				return nil, err
			}
			for _, tv := range otm {
				var operationTabMenu = OperationTabMenu{
					Key:   tv.Resourcecode,
					Label: tv.Resourcename,
				}

				operationSecondaryMenu.TabList = append(operationSecondaryMenu.TabList, operationTabMenu)
			}

			operationPrimaryMenu.Children = append(operationPrimaryMenu.Children, operationSecondaryMenu)
		}

		rst = append(rst, operationPrimaryMenu)
	}

	return rst, nil
}

// GetClientTableDefines 获取终端列表定义信息
func GetClientTableDefines(tableKey string, tableType int) ([]Tabledefine, error) {
	engine := db.GetEngine()

	tableDefiles := make([]Tabledefine, 0)
	s := engine.Table("TABLEDEFINE")
	if tableType != 0 {
		s = s.Where("TABLEDEFINE.TableType = ?", tableType)
	}
	if len(tableKey) > 0 {
		s = s.And("TABLEDEFINE.TableKey = ?", tableKey)
	}
	if err := s.Find(&tableDefiles); err != nil {
		return nil, err
	}

	return tableDefiles, nil
}

// GetClientTableColumns 获取客户端指定表的列头信息
// tableKey 列表Key
func GetClientTableColumns(tableKey string, tableType int) ([]Tablecolumnconfig, error) {
	engine := db.GetEngine()

	// 获取列表数据 2 - H5; 3 - APP
	tablecolumnconfigs := make([]Tablecolumnconfig, 0)
	// 这里的表名必须要大写 （Oracle的表名都是大写）
	if err := engine.Join("INNER", "TABLEDEFINE", "TABLEDEFINE.TableKey = TABLECOLUMNCONFIG.TableKey").
		Where("TABLEDEFINE.TableType = ?", tableType).And("TABLEDEFINE.TableKey = ?", tableKey).OrderBy("TABLECOLUMNCONFIG.ORDERINDEX").Find(&tablecolumnconfigs); err != nil {
		return nil, err
	}

	return tablecolumnconfigs, nil
}

// GetNotices 获取指定账户的通知信息（终端）
// 参数 loginID int 登录账号
// 参数 msgType int 消息类型 - 1:公告通知 2:系统消息
// 参数 onlyUnRead bool 是否只获取未读信息
func GetNotices(loginID, msgType int, onlyUnRead bool) ([]Noticemsg, error) {
	engine := db.GetEngine()

	rst := make([]Noticemsg, 0)

	// 获取登录账号所属会员信息
	var userAccount Useraccount
	if has, _ := engine.Join("LEFT", "LOGINACCOUNT", "LOGINACCOUNT.USERID = USERACCOUNT.USERID").
		Where("LOGINACCOUNT.LOGINID = ?", loginID).Get(&userAccount); !has {
		return nil, errors.New("获取登录账号所属会员ID失败")
	}

	// 获取登录账号已读公告ID, 这里要使用的是个人的UserID来查询
	var msgReceivers []int
	engine.Table("MSGRECEIVER").Select("AUTOID").Where("RECEIVERTYPE = 2 and MANAGERID = ?", userAccount.Userid).Find(&msgReceivers)

	// 查询SENDTYPE = 1的数据
	datas1 := make([]Noticemsg, 0)
	s := engine.Where("SENDTYPE = 1 and SYSDATE > SCHEDULETIME and SYSDATE < ENDTIME and SENTSTATUS=1").
		And("PUBLISHER = ? or PUBLISHER in (select USERACCOUNT.USERID from USERACCOUNT where USERACCOUNT.USERTYPE = 1)", userAccount.Memberuserid)
	if msgType > 0 {
		s = s.And("MSGTYPE = ?", msgType)
	}
	if onlyUnRead && len(msgReceivers) > 0 {
		s = s.NotIn("AUTOID", msgReceivers)
	}
	if err := s.Find(&datas1); err != nil {
		// 查询失败
		return nil, err
	}
	rst = append(rst, datas1...)

	// 查询SENDTYPE = 2的数据
	datas2 := make([]Noticemsg, 0)
	s = engine.Where(fmt.Sprintf(`AUTOID in (select MEMBERRECV.MSGID from MEMBERRECV where MEMBERRECV.MEMBERID = %d)`, userAccount.Memberuserid)).
		And("SENDTYPE = 2 and SYSDATE > SCHEDULETIME and SYSDATE < ENDTIME and SENTSTATUS=1")
	if msgType > 0 {
		s = s.And("MSGTYPE = ?", msgType)
	}
	if onlyUnRead && len(msgReceivers) > 0 {
		s = s.NotIn("AUTOID", msgReceivers)
	}
	if err := s.Find(&datas2); err != nil {
		// 查询失败
		return nil, err
	}
	rst = append(rst, datas2...)

	// 查询SENDTYPE = 3的数据
	datas3 := make([]Noticemsg, 0)
	s = engine.Where(fmt.Sprintf(`USERID = (SELECT USERID FROM LOGINACCOUNT WHERE LOGINID = %d)`, loginID)).
		And("SENDTYPE = 3 and SYSDATE > SCHEDULETIME and SYSDATE < ENDTIME and SENTSTATUS=1")
	if msgType > 0 {
		s = s.And("MSGTYPE = ?", msgType)
	}
	if onlyUnRead && len(msgReceivers) > 0 {
		s = s.NotIn("AUTOID", msgReceivers)
	}
	if err := s.Find(&datas3); err != nil {
		// 查询失败
		return nil, err
	}
	rst = append(rst, datas3...)

	return rst, nil
}

// GetEnumDicItem 获取枚举信息数组
// 参数 enumDicCode string 所属枚举代码，必填
// 参数 enumItemName int 枚举项值，选填，不需要则传入0
// 返回 []Enumdicitem 枚举信息数组
// 返回 error error
func GetEnumDicItem(enumDicCode string, enumItemName int) ([]Enumdicitem, error) {
	engine := db.GetEngine()

	enumDicItems := make([]Enumdicitem, 0)
	session := engine.Table("ENUMDICITEM E").
		Join("LEFT", "ENUMDICITEMEX EX", "E.ENUMDICCODE = EX.ENUMDICCODE AND E.ENUMITEMNAME = EX.ENUMITEMNAME").
		Select("E.*, EX.ENUMDICNAMEEN, EX.ENUMDICNAMEZH_TW, EX.ENUMDICNAMETH,EX.ENUMDICNAMEVI").
		Where("E.ENUMDICCODE = ?", enumDicCode)
	if enumItemName > 0 {
		session = session.And("E.ENUMITEMNAME = ?", enumItemName)
	}
	if err := session.Find(&enumDicItems); err != nil {
		return nil, err
	}

	return enumDicItems, nil
}

// GetEnums 获取所有枚举信息
func GetEnums(autoID int) ([]Enumdicitem, error) {
	engine := db.GetEngine()

	enumDicItems := make([]Enumdicitem, 0)
	session := engine.Table("ENUMDICITEM E").
		Join("LEFT", "ENUMDICITEMEX EX", "E.ENUMDICCODE = EX.ENUMDICCODE AND E.ENUMITEMNAME = EX.ENUMITEMNAME").
		Select("E.*, EX.ENUMDICNAMEEN, EX.ENUMDICNAMEZH_TW, EX.ENUMDICNAMETH,EX.ENUMDICNAMEVI")
	if autoID != 0 {
		session = session.Where("E.AUTOID > ?", autoID)
	}
	if err := session.OrderBy("E.AUTOID").Find(&enumDicItems); err != nil {
		return nil, err
	}

	return enumDicItems, nil
}

// GetProvincesAndCities 获取省市信息数组
// 参数 provinceID int 省ID，选填
// 返回 []Division 枚举信息数组
// 返回 error error
func GetProvincesAndCities(provinceID int) ([]Division, error) {
	engine := db.GetEngine()

	divisions := make([]Division, 0)
	session := engine.Where("DIVISIONLEVEL = 'province' or DIVISIONLEVEL = 'city'")
	if provinceID > 0 {
		session = session.And("AUTOID = ?", provinceID)
	}
	if err := session.Find(&divisions); err != nil {
		return nil, err
	}

	return divisions, nil
}

// GetDivisions 获取所有区域信息
func GetDivisions() ([]Division, error) {
	engine := db.GetEngine()

	divisions := make([]Division, 0)
	if err := engine.Find(&divisions); err != nil {
		return nil, err
	}

	return divisions, nil
}

// GetImageConfigs 获取轮播图配置信息
func GetImageConfigs(userId int64, imageType int) ([]Szdz2imageconfig, error) {
	engine := db.GetEngine()

	imageConfigs := make([]Szdz2imageconfig, 0)
	session := engine.Where("ISSHOW = 1")
	if userId > 0 {
		session = session.And("AREAUSERID = ?", mtpcache.GetAreaUserId(userId, 0))
	}
	if imageType > 0 {
		session = session.And("IMAGETYPE = ?", imageType)
	}
	session = session.Asc("SORT")
	if err := session.Find(&imageConfigs); err != nil {
		return nil, err
	}

	return imageConfigs, nil
}

// GetServerTime 获取服务器时间
func GetServerTime() (*string, error) {
	engine := db.GetEngine()

	// rst, err := engine.QueryString("select sysdate from dual")
	rst, err := engine.QueryString(`select TO_CHAR(SYSDATE, 'YYYY-MM-DD"T"HH24:MI:SS') || (select sessiontimezone from dual) "SYSDATE" from dual`)
	if err != nil {
		return nil, err
	}
	if len(rst) > 0 {
		r := rst[0]["SYSDATE"]
		return &r, nil
	}

	return nil, nil
}

func GetServerTime2() (*string, error) {
	engine := db.GetEngine()

	rst, err := engine.QueryString("select sysdate from dual")
	if err != nil {
		return nil, err
	}
	if len(rst) > 0 {
		r := rst[0]["SYSDATE"]
		return &r, nil
	}

	return nil, nil
}

// QueryErrorInfosRsp 获取数据库错误信息模型
type QueryErrorInfosRsp struct {
	Errorid          int64  `json:"errorid"  xorm:"'ERRORID'" binding:"required"` // 异常ID
	Errorcode        string `json:"-"  xorm:"'ERRORCODE'"`                        // 异常代码
	Modulecode       string `json:"-"  xorm:"'MODULECODE'"`                       // 所属模块
	Operatecode      string `json:"-"  xorm:"'OPERATECODE'"`                      // 所属操作
	Description      string `json:"description"  xorm:"'DESCRIPTION'"`            // 异常描述
	Rownumber        string `json:"-" xorm:"ROWNUMBER"`                           // 行号
	DescriptionEn    string `json:"descriptionen"  xorm:"'DESCRIPTIONEN'"`        // 异常描述 - 英文
	DescriptionZh_Tw string `json:"descriptionzh_tw"  xorm:"'DESCRIPTIONZH_TW'"`  // 异常描述 - 繁体
	DescriptionTh    string `json:"descriptionth"  xorm:"'DESCRIPTIONTH'"`        // 异常描述 - 泰文
	DescriptionVi    string `json:"descriptionvi"  xorm:"'DESCRIPTIONVI'"`        // 异常描述 - 越南语
}

// GetErrorInfos 获取数据库错误信息
func GetErrorInfos(rowNumber string) ([]QueryErrorInfosRsp, error) {
	engine := db.GetEngine()

	errorCodes := make([]QueryErrorInfosRsp, 0)
	session := engine.Table("ERRORCODE E").
		Join("LEFT", "ERRORCODEEX EX", "E.ERRORID = EX.ERRORID").
		Select("E.*, E.rowid ROWNUMBER, EX.DESCRIPTIONEN, EX.DESCRIPTIONZH_TW, EX.DESCRIPTIONTH, EX.DESCRIPTIONVI").Where("1 = 1")
	if len(rowNumber) != 0 {
		session = session.And("E.rowid > ?", rowNumber)
	}
	if err := session.Find(&errorCodes); err != nil {
		return nil, err
	}

	return errorCodes, nil
}

// GetTableUpdateTimeStamp 获取目标表最后记录变更时间
func GetTableUpdateTimeStamp(tableName string) (*string, error) {
	engine := db.GetEngine()

	var timeStamp string
	if _, err := engine.SQL(fmt.Sprintf("SELECT to_char(SCN_TO_TIMESTAMP(MAX(ora_rowscn)), 'yyyy-MM-dd hh24:mi:ss') TIMESTAMP from %s", tableName)).
		Get(&timeStamp); err != nil {
		return nil, err
	}

	return &timeStamp, nil
}

// GetSystemParams 获取系统参数信息
func GetSystemParams() ([]Systemparam, error) {
	systemParams := make([]Systemparam, 0)
	if err := db.GetEngine().Where("PARAMTYPE in (0,2)").Or("PARAMCODE in ('112','113')").Find(&systemParams); err != nil {
		return nil, err
	}

	return systemParams, nil
}

// GetSystemParam 获取系统参数信息
func GetSystemParamsByCodes(paramcodes string) ([]Systemparam, error) {
	systemParams := make([]Systemparam, 0)

	if paramcodes != "" {
		session := db.GetEngine().Where("PARAMTYPE in (0,2,3)")
		s := strings.Split(paramcodes, ",")
		session = session.In("PARAMCODE", s)
		if err := session.Find(&systemParams); err != nil {
			return nil, err
		}
	} else {
		if err := db.GetEngine().Where("PARAMTYPE in (0,2)").Or("PARAMCODE in ('112','113')").Find(&systemParams); err != nil {
			return nil, err
		}
	}

	return systemParams, nil
}

// GetRoleFuncMenuLists 获取终端权限（交易所版本）
func GetRoleFuncMenuLists(loginID int, resourceCode string) ([]Funcmenulist, error) {
	funcMenuLists := make([]Funcmenulist, 0)

	sql := fmt.Sprintf(`select F.* from FUNCMENULIST F where F.MENUTYPE = 3 
						and 
						F.RESOURCECODE in 
						(select R.RESOURCECODE from ROLEFUNCMENU R 
							inner join LOGINACCOUNT L on L.CLIENTROLEID = R.ROLEID where L.LOGINID = %d)`, loginID)
	if len(resourceCode) != 0 {
		sql += fmt.Sprintf(" and F.RESOURCECODE = '%s'", resourceCode)
	}
	if err := db.GetEngine().SQL(sql).Find(&funcMenuLists); err != nil {
		return nil, err
	}

	return funcMenuLists, nil
}

// GetErmcpRoleFuncMenuLists 获取终端权限（企业风管专用，区分企业和企业成员）
func GetErmcpRoleFuncMenuLists(loginID int, resourceCode string) ([]Funcmenulist, error) {
	funcMenuLists := make([]Funcmenulist, 0)

	// 获取对应的Loginaccount信息
	var loginAccount Loginaccount
	has, err := db.GetEngine().Where("LOGINID = ?", loginID).Get(&loginAccount)
	if err != nil {
		return nil, err
	}
	if !has {
		return nil, errors.New("没有对应的登录用户信息")
	}

	// 获取对应的Useraccount信息
	var userAccount Useraccount
	has, err = db.GetEngine().Table("USERACCOUNT U").
		Join("INNER", "LOGINACCOUNT L", "L.USERID = U.USERID").
		Where("L.LOGINID = ?", loginID).Get(&userAccount)
	if err != nil {
		return nil, err
	}
	if !has {
		return nil, errors.New("没有对应的用户信息")
	}

	// 是否企业
	isEnterprise := false
	// 是否自营会员
	isTrader := false
	// 查询机构角色表
	var arearole Arearole
	arearoles, err := arearole.GetAreaRoles(int(userAccount.Userid), 0)
	if err != nil {
		return nil, err
	}
	for _, v := range arearoles {
		if v.Roletype == 6 {
			isTrader = true
		} else if v.Roletype == 20 {
			arearole = arearoles[0]
			if arearole.Suborgtype == 0 {
				isEnterprise = true
			}
		}
	}

	if userAccount.Usertype == 5 || (userAccount.Usertype == 2 && isTrader) {
		// 交易所，自营会员及投资者的权限不进行判断
		sql := "select F.* from FUNCMENULIST F where F.MENUTYPE = 4"
		if len(resourceCode) != 0 {
			sql += fmt.Sprintf(" and F.RESOURCECODE = '%s'", resourceCode)
		}
		if err := db.GetEngine().SQL(sql).Find(&funcMenuLists); err != nil {
			return nil, err
		}
	} else {
		// 判断是企业还是企业成员
		// 账户类型 -  1:交易所 2:机构 3:会员子机构 4:经纪人 5:投资者 6:客户 7:企业成员(云平台)
		if userAccount.Usertype == 2 && isEnterprise {
			// UserType=2：企业。原逻辑：根据LoginAccount表"ClientRoleID"查询”ERMCP_MemberFuncMenu“表中该用户对应角色的菜单权限
			sql := fmt.Sprintf(`select F.* from FUNCMENULIST F where F.MENUTYPE in (3,5) 
							and 
							F.RESOURCECODE in 
							(select R.RESOURCECODE from ERMCP_MEMBERFUNCMENU R 
								where R.ISVALID = 1 and R.USERID = %d and R.ROLEID = %d)`, loginAccount.Userid, loginAccount.Clientroleid)
			if len(resourceCode) != 0 {
				sql += fmt.Sprintf(" and F.RESOURCECODE = '%s'", resourceCode)
			}
			if err := db.GetEngine().SQL(sql).Find(&funcMenuLists); err != nil {
				return nil, err
			}
		} else if userAccount.Usertype == 6 || userAccount.Usertype == 7 || (userAccount.Usertype == 2 && !isEnterprise) {
			// UserType=7：企业成员
			// 查询本用户的角色ID  - AreaRole表
			// 根据 Rootuserid 和 自己的角色查询 ERMCP_MemberFuncMenu 表中的菜单权限
			areaRoles := make([]Arearole, 0)
			if err := db.GetEngine().Where("USERID = ?", loginAccount.Userid).Find(&areaRoles); err != nil {
				return nil, err
			}
			if len(areaRoles) == 0 {
				// 无角色，返回空数组s
				return make([]Funcmenulist, 0), nil
			}
			// 构建RoleID列表
			roleIDs := ""
			for _, areaRole := range areaRoles {
				roleIDs += "," + strconv.Itoa(int(areaRole.Roletype))
			}
			if len(roleIDs) > 0 {
				roleIDs = roleIDs[1:]
			}
			sql := fmt.Sprintf(`select F.* from FUNCMENULIST F where F.MENUTYPE in (3,5) 
							and 
							F.RESOURCECODE in 
							(select R.RESOURCECODE from ERMCP_MEMBERFUNCMENU R 
								where R.ISVALID = 1 and R.USERID = %d and R.ROLEID in (%s))`, userAccount.Rootuserid, roleIDs)
			if len(resourceCode) != 0 {
				sql += fmt.Sprintf(" and F.RESOURCECODE = '%s'", resourceCode)
			}
			if err := db.GetEngine().SQL(sql).Find(&funcMenuLists); err != nil {
				return nil, err
			}
		} else {
			return nil, errors.New("错误的用户类型")
		}
	}

	return funcMenuLists, nil
}

// IsTrader 判断是否交易所，自营会员及投资者
func IsTrader(loginID int) (bool, error) {
	// 获取对应的Loginaccount信息
	var loginAccount Loginaccount
	has, err := db.GetEngine().Where("LOGINID = ?", loginID).Get(&loginAccount)
	if err != nil {
		return false, err
	}
	if !has {
		return false, errors.New("没有对应的登录用户信息")
	}

	// 获取对应的Useraccount信息
	var userAccount Useraccount
	has, err = db.GetEngine().Table("USERACCOUNT U").
		Join("INNER", "LOGINACCOUNT L", "L.USERID = U.USERID").
		Where("L.LOGINID = ?", loginID).Get(&userAccount)
	if err != nil {
		return false, err
	}
	if !has {
		return false, errors.New("没有对应的用户信息")
	}

	// 是否自营会员
	isTrader := false
	// 查询机构角色表
	var arearole Arearole
	arearoles, err := arearole.GetAreaRoles(int(userAccount.Userid), 0)
	if err != nil {
		return false, err
	}
	for _, v := range arearoles {
		if v.Roletype == 6 {
			isTrader = true
		}
	}

	// 交易所，自营会员及投资者的权限不进行判断
	if userAccount.Usertype == 5 || (userAccount.Usertype == 2 && isTrader) {
		return true, nil
	}

	return false, nil
}

// NewFuncmenulist 功能菜单表
type NewFuncmenulist struct {
	RESOURCECODE  *string `json:"resourcecode"  xorm:"RESOURCECODE" binding:"required"` // 资源代码
	RESOURCENAME  *string `json:"resourcename"  xorm:"RESOURCENAME"`                    // 资源名(Title)
	RESOURCELEVEL *int32  `json:"resourcelevel"  xorm:"RESOURCELEVEL"`                  // 级别1-一级 2-二级 3-三级4-四级
	MENUTYPE      *int32  `json:"menutype"  xorm:"MENUTYPE"`                            // 菜单类型 - 1:管理端 2:PC(C#) 3:移动(云平台) 4:终端(交易所) 5:PC(云平台)
	PARENTCODE    *string `json:"parentcode"  xorm:"PARENTCODE"`                        // 上级资源代码
	URL           *string `json:"url"  xorm:"URL"`                                      // Url
	SORT          *int32  `json:"sort"  xorm:"SORT"`                                    // 排序
	ICONAME       *string `json:"iconame"  xorm:"ICONAME"`                              // 菜单图标
	REMARK        *string `json:"remark"  xorm:"REMARK"`                                // Remark
	AUTHTYPE      *int32  `json:"authtype"  xorm:"AUTHTYPE"`                            // 权限类型 - 1:菜单 2:组件 3:按钮
	URLTYPE       *int32  `json:"urltype"  xorm:"URLTYPE"`                              // 地址类型 - 1:路由 2:外链 3:内联框架
	COMPONENT     *string `json:"component"  xorm:"COMPONENT"`                          // 组件名或组件地址
	BUTTONTYPE    *string `json:"buttontype"  xorm:"BUTTONTYPE"`                        // 按钮类型 - 存按钮样式
	HIDDEN        *int32  `json:"hidden"  xorm:"HIDDEN"`                                // 是否隐藏 - 0:显示 1:隐藏
	BUTTONNAME    *string `json:"buttonname"  xorm:"BUTTONNAME"`                        // 按钮名称
}

type NewFuncmenulistReq struct {
	RESOURCECODE string `form:"resourcecode"` // 资源代码
	PARENTCODE   string `form:"parentcode"`   // 上级资源代码
	RESOURCENAME string `form:"resourcename"` // 资源名(Title), 模糊查询
	MENUTYPE     string `form:"menutype"`     // 菜单类型（格式：1,2,3） - 1:管理端 2:PC(C#) 3:移动(云平台) 4:终端(交易所) 5:PC(云平台)
}

// TableName is FUNCMENULIST
func (r *NewFuncmenulist) TableName() string {
	return "FUNCMENULIST"
}

func (r *NewFuncmenulist) Find(req NewFuncmenulistReq) ([]NewFuncmenulist, error) {
	funcMenuLists := make([]NewFuncmenulist, 0)
	session := db.GetEngine().Table("FUNCMENULIST T")
	if len(req.RESOURCECODE) != 0 {
		session = session.And("T.RESOURCECODE = ?", req.RESOURCECODE)
	}
	if len(req.PARENTCODE) != 0 {
		session = session.And("T.PARENTCODE = ?", req.PARENTCODE)
	}
	if len(req.RESOURCENAME) != 0 {
		session = session.And("T.RESOURCENAME LIKE ?", "%"+req.RESOURCENAME+"%")
	}
	if len(req.MENUTYPE) != 0 {
		session = session.And(fmt.Sprintf("T.MENUTYPE in (%s)", req.MENUTYPE))
	}
	if err := session.Find(&funcMenuLists); err != nil {
		return nil, err
	}

	return funcMenuLists, nil
}

func (r *NewFuncmenulist) Insert() error {
	_, err := db.GetEngine().Insert(r)
	return err
}

func (r *NewFuncmenulist) Update() error {
	_, err := db.GetEngine().Where("RESOURCECODE = ?", r.RESOURCECODE).Update(r)
	return err
}

func (r *NewFuncmenulist) Delete() error {
	_, err := db.GetEngine().Where("RESOURCECODE = ?", r.RESOURCECODE).Delete(r)
	return err
}

// GetNewErmcpRoleFuncMenuLists
func GetNewErmcpRoleFuncMenuLists(loginID int, menuType int) ([]NewFuncmenulist, error) {
	funcMenuLists := make([]NewFuncmenulist, 0)

	// 获取对应的Loginaccount信息
	var loginAccount Loginaccount
	has, err := db.GetEngine().Where("LOGINID = ?", loginID).Get(&loginAccount)
	if err != nil {
		return nil, err
	}
	if !has {
		return nil, errors.New("没有对应的登录用户信息")
	}

	// 获取对应的Useraccount信息
	var userAccount Useraccount
	has, err = db.GetEngine().Table("USERACCOUNT U").
		Join("INNER", "LOGINACCOUNT L", "L.USERID = U.USERID").
		Where("L.LOGINID = ?", loginID).Get(&userAccount)
	if err != nil {
		return nil, err
	}
	if !has {
		return nil, errors.New("没有对应的用户信息")
	}

	// 是否企业
	isEnterprise := false
	// 是否自营会员
	isTrader := false
	// 查询机构角色表
	var arearole Arearole
	arearoles, err := arearole.GetAreaRoles(int(userAccount.Userid), 0)
	if err != nil {
		return nil, err
	}
	for _, v := range arearoles {
		if v.Roletype == 6 {
			isTrader = true
		} else if v.Roletype == 20 {
			arearole = arearoles[0]
			if arearole.Suborgtype == 0 {
				isEnterprise = true
			}
		}
	}

	if userAccount.Usertype == 5 || (userAccount.Usertype == 2 && isTrader) {
		// 交易所，自营会员及投资者的权限不进行判断
		sql := fmt.Sprintf("select F.* from FUNCMENULIST F where F.MENUTYPE = %d", menuType)
		if err := db.GetEngine().SQL(sql).Find(&funcMenuLists); err != nil {
			return nil, err
		}
	} else {
		// 判断是企业还是企业成员
		// 账户类型 -  1:交易所 2:机构 3:会员子机构 4:经纪人 5:投资者 6:客户 7:企业成员(云平台)
		if userAccount.Usertype == 2 && isEnterprise {
			// UserType=2：企业。原逻辑：根据LoginAccount表"ClientRoleID"查询”ERMCP_MemberFuncMenu“表中该用户对应角色的菜单权限
			sql := fmt.Sprintf(`select F.* from FUNCMENULIST F where F.MENUTYPE = %d 
							and 
							F.RESOURCECODE in 
							(select R.RESOURCECODE from ERMCP_MEMBERFUNCMENU R 
								where R.ISVALID = 1 and R.USERID = %d and R.ROLEID = %d)`, menuType, loginAccount.Userid, loginAccount.Clientroleid)
			if err := db.GetEngine().SQL(sql).Find(&funcMenuLists); err != nil {
				return nil, err
			}
		} else if userAccount.Usertype == 6 || userAccount.Usertype == 7 || (userAccount.Usertype == 2 && !isEnterprise) {
			// UserType=7：企业成员
			// 查询本用户的角色ID  - AreaRole表
			// 根据 Rootuserid 和 自己的角色查询 ERMCP_MemberFuncMenu 表中的菜单权限
			areaRoles := make([]Arearole, 0)
			if err := db.GetEngine().Where("USERID = ?", loginAccount.Userid).Find(&areaRoles); err != nil {
				return nil, err
			}
			if len(areaRoles) == 0 {
				// 无角色，返回空数组s
				return make([]NewFuncmenulist, 0), nil
			}
			// 构建RoleID列表
			roleIDs := ""
			for _, areaRole := range areaRoles {
				roleIDs += "," + strconv.Itoa(int(areaRole.Roletype))
			}
			if len(roleIDs) > 0 {
				roleIDs = roleIDs[1:]
			}
			sql := fmt.Sprintf(`select F.* from FUNCMENULIST F where F.MENUTYPE = %d 
							and 
							F.RESOURCECODE in 
							(select R.RESOURCECODE from ERMCP_MEMBERFUNCMENU R 
								where R.ISVALID = 1 and R.USERID = %d and R.ROLEID in (%s))`, menuType, userAccount.Rootuserid, roleIDs)
			if err := db.GetEngine().SQL(sql).Find(&funcMenuLists); err != nil {
				return nil, err
			}
		} else {
			return nil, errors.New("错误的用户类型")
		}
	}

	return funcMenuLists, nil
}

// Exchangerateconfig 汇率配置表
type ExchangeRateConfig struct {
	ORICURRENCYID int32     `json:"oricurrencyid" xorm:"ORICURRENCYID" form:"oricurrencyid"` // 源币种ID
	DESCURRENCYID int32     `json:"descurrencyid" xorm:"DESCURRENCYID" form:"descurrencyid"` // 目标币种ID
	EXCHANGERATE  float64   `json:"exchangerate" xorm:"EXCHANGERATE"`                        // 汇率
	REMARK        string    `json:"remark" xorm:"REMARK"`                                    // 备注
	UPDATEBY      int64     `json:"-" xorm:"UPDATEBY"`                                       // 更新人
	UPDATETIME    time.Time `json:"-" xorm:"UPDATETIME"`                                     // 更新时间
}

func (r *ExchangeRateConfig) TableName() string {
	return "EXCHANGERATECONFIG"
}

// Exchangerateconfig 汇率配置表
type Exchangerateconfig struct {
	ORICURRENCYID int32     `json:"oricurrencyid" xorm:"ORICURRENCYID" form:"oricurrencyid"` // 源币种ID
	DESCURRENCYID int32     `json:"descurrencyid" xorm:"DESCURRENCYID" form:"descurrencyid"` // 目标币种ID
	EXCHANGERATE  float64   `json:"exchangerate" xorm:"EXCHANGERATE"`                        // 汇率
	REMARK        string    `json:"-" xorm:"REMARK"`                                         // 备注
	UPDATEBY      int64     `json:"-" xorm:"UPDATEBY"`                                       // 更新人
	UPDATETIME    time.Time `json:"-" xorm:"UPDATETIME"`                                     // 更新时间

	PageEx `xorm:"extends"` // 页码信息
}

func (r *Exchangerateconfig) TableName() string {
	return "EXCHANGERATECONFIG"
}

func (r *Exchangerateconfig) calc() {

}

func (r *Exchangerateconfig) buildSql() string {
	var sqlId utils.SQLVal = `
	SELECT 
		t.*
	FROM ExchangeRateConfig t
	`

	sqlId.AndEx("t.ORICURRENCYID", r.ORICURRENCYID, r.ORICURRENCYID > 0)
	sqlId.AndEx("t.DESCURRENCYID", r.DESCURRENCYID, r.DESCURRENCYID > 0)

	sqlId.Page(r.Page, r.PageSize)
	return sqlId.String()
}

func (r *Exchangerateconfig) GetDataByPage() (interface{}, error, int, int, int) {
	sData := make([]Exchangerateconfig, 0)
	err := db.GetEngine().SQL(r.buildSql()).Find(&sData)
	total := 0
	for i := range sData {
		sData[i].calc()
		total = sData[i].Total
	}
	return sData, err, r.Page, r.PageSize, total
}

func (r *Exchangerateconfig) GetAll() (data []Exchangerateconfig, err error) {
	data = make([]Exchangerateconfig, 0)
	err = db.GetEngine().Table("EXCHANGERATECONFIG").Select("ORICURRENCYID,DESCURRENCYID,EXCHANGERATE,REMARK").Find(&data)
	return
}

// QueryNewTitlesReq 获取资讯标题列表请求参数
type QueryNewTitlesReq struct {
	COLUMNID int `form:"columnid"` // 所属栏目

	Page     int `json:"-" form:"page"`     // 页码
	PageSize int `json:"-" form:"pagesize"` // 每页大小
}

type QueryNewTitlesRsp struct {
	ID          int64     `json:"id" xorm:"ID"`                   // ID(SEQ_SITE_COLUMNDETAIL)
	COLUMNID    int64     `json:"columnid" xorm:"COLUMNID"`       // 所属栏目
	USERID      int64     `json:"userid" xorm:"USERID"`           // 用户ID(默认为0， 核心为为机构用户ID)
	TITLE       string    `json:"title" xorm:"TITLE"`             // 标题
	COVERIMAGE  string    `json:"coverimage" xorm:"COVERIMAGE"`   // 封面图片
	AUTHOR      string    `json:"author" xorm:"AUTHOR"`           // 作者
	BRIEF       string    `json:"brief" xorm:"BRIEF"`             // 简介
	STATUS      int32     `json:"status" xorm:"STATUS"`           // 状态 - 1:暂存 10:待审核 20:审核通过 30:审核拒绝
	ISTOP       int32     `json:"istop" xorm:"ISTOP"`             // 是否置顶 - 0:不置 1:置顶
	HITS        int64     `json:"hits" xorm:"HITS"`               // 点击数
	PUBLISHDATE time.Time `json:"publishdate" xorm:"PUBLISHDATE"` // 发布日期
	CREAEDATE   time.Time `json:"creaedate" xorm:"CREAEDATE"`     // 创建时间
	CREATORID   int64     `json:"creatorid" xorm:"CREATORID"`     // 创建人
	UPDATEDATE  time.Time `json:"updatedate" xorm:"UPDATEDATE"`   // 修改时间
	MODIFIERID  int64     `json:"modifierid" xorm:"MODIFIERID"`   // 操作人
	ISSHOW      int32     `json:"isshow" xorm:"ISSHOW"`           // 是否展示 - 0:不展示 1:展示

	TITLEEN string `json:"titleen" xorm:"TITLEEN"` // 标题(英文)
	TITLETW string `json:"titletw" xorm:"TITLETW"` // 标题(繁体)
	TITLETH string `json:"titleth" xorm:"TITLETH"` // 标题(泰文)
	TITLEVI string `json:"titlevi" xorm:"TITLEVI"` // 标题(越南语)

	AUTHOREN string `json:"authoren" xorm:"AUTHOREN"` // 作者(英文)
	AUTHORTW string `json:"authortw" xorm:"AUTHORTW"` // 作者(繁体)
	AUTHORTH string `json:"authorth" xorm:"AUTHORTH"` // 作者(泰文)
	AUTHORVI string `json:"authorvi" xorm:"AUTHORVI"` // 作者()

	BRIEFEN string `json:"briefen" xorm:"BRIEFEN"` // 简介(英文)
	BRIEFTW string `json:"brieftw" xorm:"BRIEFTW"` // 简介(繁体)
	BRIEFTH string `json:"briefth" xorm:"BRIEFTH"` // 简介(泰文)
	BRIEFVI string `json:"briefvi" xorm:"BRIEFVI"` // 简介(越南语)

}

// GetNewTitles 取资讯标题列表
func GetNewTitles(req QueryNewTitlesReq) (rsp []QueryNewTitlesRsp, total int64, err error) {
	engine := db.GetEngine()

	session := engine.Table("SITE_COLUMNDETAIL").Where("ISSHOW = 1")
	if req.COLUMNID != 0 {
		session = session.And("COLUMNID = ?", req.COLUMNID)
	}
	total, err = session.Count(new(QueryNewTitlesRsp))
	if err != nil {
		return
	}

	rsp = make([]QueryNewTitlesRsp, 0)
	session = engine.Table("SITE_COLUMNDETAIL").Where("ISSHOW = 1 AND STATUS = 20")
	if req.COLUMNID != 0 {
		session = session.And("COLUMNID = ?", req.COLUMNID)
	}
	session = session.Desc("ISTOP", "PUBLISHDATE")
	page := req.Page - 1
	err = session.Limit(req.PageSize, page*req.PageSize).Find(&rsp)

	return
}

type QueryNewTitles2Rsp struct {
	Time string              `json:"time"` // 时间
	List []QueryNewTitlesRsp `json:"list"` // 列表
}

// GetNewTitles2 取资讯标题列表
func GetNewTitles2(req QueryNewTitlesReq) (rsp []QueryNewTitles2Rsp, total int64, err error) {
	engine := db.GetEngine()

	session := engine.Table("SITE_COLUMNDETAIL").Where("ISSHOW = 1")
	if req.COLUMNID != 0 {
		session = session.And("COLUMNID = ?", req.COLUMNID)
	}
	total, err = session.Count(new(QueryNewTitlesRsp))
	if err != nil {
		return
	}

	r := make([]QueryNewTitlesRsp, 0)
	session = engine.Table("SITE_COLUMNDETAIL").Where("ISSHOW = 1 AND STATUS = 20")
	if req.COLUMNID != 0 {
		session = session.And("COLUMNID = ?", req.COLUMNID)
	}
	session = session.Desc("ISTOP", "PUBLISHDATE")
	page := req.Page - 1
	err = session.Limit(req.PageSize, page*req.PageSize).Find(&r)

	m := make(map[string][]QueryNewTitlesRsp)
	for _, v := range r {
		t := v.PUBLISHDATE.Format("2006-01-02")
		m[t] = append(m[t], v)
	}
	rsp = make([]QueryNewTitles2Rsp, 0)
	for k, v := range m {
		rsp = append(rsp, QueryNewTitles2Rsp{
			Time: k,
			List: v,
		})
	}

	return
}

type QueryNewContentsRsp struct {
	ID          int64     `json:"id" xorm:"ID"`                   // ID(SEQ_SITE_COLUMNDETAIL)
	COLUMNID    int64     `json:"columnid" xorm:"COLUMNID"`       // 所属栏目
	USERID      int64     `json:"userid" xorm:"USERID"`           // 用户ID(默认为0， 核心为为机构用户ID)
	TITLE       string    `json:"title" xorm:"TITLE"`             // 标题
	COVERIMAGE  string    `json:"coverimage" xorm:"COVERIMAGE"`   // 封面图片
	AUTHOR      string    `json:"author" xorm:"AUTHOR"`           // 作者
	BRIEF       string    `json:"brief" xorm:"BRIEF"`             // 简介
	CONTEXT     string    `json:"context" xorm:"CONTEXT"`         // 内容
	STATUS      int32     `json:"status" xorm:"STATUS"`           // 状态 - 1:暂存 10:待审核 20:审核通过 30:审核拒绝
	ISTOP       int32     `json:"istop" xorm:"ISTOP"`             // 是否置顶 - 0:不置 1:置顶
	HITS        int64     `json:"hits" xorm:"HITS"`               // 点击数
	PUBLISHDATE time.Time `json:"publishdate" xorm:"PUBLISHDATE"` // 发布日期
	CREAEDATE   time.Time `json:"creaedate" xorm:"CREAEDATE"`     // 创建时间
	CREATORID   int64     `json:"creatorid" xorm:"CREATORID"`     // 创建人
	UPDATEDATE  time.Time `json:"updatedate" xorm:"UPDATEDATE"`   // 修改时间
	MODIFIERID  int64     `json:"modifierid" xorm:"MODIFIERID"`   // 操作人
	ISSHOW      int32     `json:"isshow" xorm:"ISSHOW"`           // 是否展示 - 0:不展示 1:展示
	SRCID       int64     `json:"srcid" xorm:"SRCID"`             // 来源ID

	MEMBERNAME string `json:"srcname" xorm:"MEMBERNAME"` // 会员名称\来源名称
	MEMBERTAGS string `json:"srcurl" xorm:"MEMBERTAGS"`  // 标签(逗号分隔)\来源网址
	IMAGEURL   string `json:"srclogo" xorm:"IMAGEURL"`   // 图片地址\来源LOGO

	MEMBERNAMEEN string `json:"srcnameen" xorm:"MEMBERNAMEEN"` // 会员名称\来源名称(英文)
	MEMBERNAMETW string `json:"srcnametw" xorm:"MEMBERNAMETW"` // 会员名称\来源名称(繁体)
	MEMBERNAMETH string `json:"srcnameth" xorm:"MEMBERNAMETH"` // 会员名称\来源名称(泰文)
	MEMBERNAMEVI string `json:"srcnamevi" xorm:"MEMBERNAMEVI"` // 会员名称\来源名称(越南语)

	TITLEEN string `json:"titleen" xorm:"TITLEEN"` // 标题(英文)
	TITLETW string `json:"titletw" xorm:"TITLETW"` // 标题(繁体)
	TITLETH string `json:"titleth" xorm:"TITLETH"` // 标题(泰文)
	TITLEVI string `json:"titlevi" xorm:"TITLEVI"` // 标题(越南语)

	AUTHOREN string `json:"authoren" xorm:"AUTHOREN"` // 作者(英文)
	AUTHORTW string `json:"authortw" xorm:"AUTHORTW"` // 作者(繁体)
	AUTHORTH string `json:"authorth" xorm:"AUTHORTH"` // 作者(泰文)
	AUTHORVI string `json:"authorvi" xorm:"AUTHORVI"` // 作者()

	BRIEFEN string `json:"briefen" xorm:"BRIEFEN"` // 简介(英文)
	BRIEFTW string `json:"brieftw" xorm:"BRIEFTW"` // 简介(繁体)
	BRIEFTH string `json:"briefth" xorm:"BRIEFTH"` // 简介(泰文)
	BRIEFVI string `json:"briefvi" xorm:"BRIEFVI"` // 简介(越南语)

	CONTEXTEN string `json:"contexten" xorm:"CONTEXTEN"` // 内容(英文)
	CONTEXTTW string `json:"contexttw" xorm:"CONTEXTTW"` // 内容(繁体)
	CONTEXTTH string `json:"contextth" xorm:"CONTEXTTH"` // 内容(泰文)
	CONTEXTVI string `json:"contextvi" xorm:"CONTEXTVI"` // 内容(越南语)

}

func GetNewContents(ids []string) (rsp []QueryNewContentsRsp, error error) {
	engine := db.GetEngine()

	// 增加点击数
	if len(ids) != 0 {
		sql := fmt.Sprintf("UPDATE SITE_COLUMNDETAIL SET HITS = nvl(HITS, 0) + 1 WHERE ID IN (%v)", strings.Join(ids, ","))
		engine.Exec(sql)
	}

	rsp = make([]QueryNewContentsRsp, 0)
	session := engine.Table("SITE_COLUMNDETAIL T").
		Select(`
			T.*, 
			GM.MEMBERNAME,
			GM.MEMBERNAMEEN,
			GM.MEMBERNAMETW,
			GM.MEMBERNAMETH,
			GM.MEMBERNAMEVI,
			GM.MEMBERTAGS,
			GM.IMAGEURL
			`).Join("LEFT", "GZ_MEMBERINFO GM", "GM.MEMBERID = T.SRCID").Where("T.ISSHOW = 1")
	if len(ids) != 0 {
		session = session.In("T.ID", ids)
	}

	if err := session.Find(&rsp); err != nil {
		return nil, err
	}

	return
}

type GetJ10NewsData struct {
	Pic     string `json:"pic"`
	Title   string `json:"title"`
	Content string `json:"content"`
}

// GetJ10NewsRsp 金10资讯数据
type GetJ10NewsRsp struct {
	Id   string         `json:"id"`
	Time string         `json:"time"`
	Type int            `json:"type"`
	Data GetJ10NewsData `json:"data"`
}

func GetJ10News(limit int) (datas []GetJ10NewsRsp, err error) {
	datas = make([]GetJ10NewsRsp, 0)

	rsp, err := http.Get("https://www.jin10.com/flash_newest.js")
	if err != nil {
		return
	}
	defer rsp.Body.Close()
	buf := new(bytes.Buffer)
	buf.ReadFrom(rsp.Body)
	newStr := buf.String()
	if strings.Contains(newStr, "var newest = ") {
		a := strings.Replace(newStr, "var newest = ", "", -1)
		b := a[:len(a)-1]

		err = json.Unmarshal([]byte(b), &datas)

		// 去掉<打头的记录，以及空的记录
		r := make([]GetJ10NewsRsp, 0)
		for _, item := range datas {
			if item.Data.Content != "" && item.Data.Content[0] != []byte("<")[0] {
				r = append(r, item)
			}
		}

		if len(r) > limit {
			datas = r[:limit]
		}
	}

	return
}

// Membergoodslimitconfig 会员商品限制配置表(不显示、不能交易的权限)
type Membergoodslimitconfig struct {
	AUTOID       int64     `json:"autoid" xorm:"AUTOID"`                                          // AutoID(SEQ_MEMBERGOODSLIMITCONFIG)
	USERID       int64     `json:"userid" xorm:"USERID" form:"userid" binding:"required"`         // 会员用户ID
	ROLETYPE     int32     `json:"roletype" xorm:"ROLETYPE"  form:"roletype"  binding:"required"` // 会员角色 - 6:自营会员 7:经纪会员
	GOODSID      int64     `json:"goodsid" xorm:"GOODSID"`                                        // 商品ID
	ISNODISPLAY  int32     `json:"isnodisplay" xorm:"ISNODISPLAY"`                                // 是否显示 0:否 1:是
	ISCANNOTBUY  int32     `json:"iscannotbuy" xorm:"ISCANNOTBUY"`                                // 是否不能挂买 0:否 1:是
	ISCANNOTSELL int32     `json:"iscannotsell" xorm:"ISCANNOTSELL"`                              // 是否不能挂卖 0:否 1:是
	UPDATETIME   time.Time `json:"updatetime" xorm:"UPDATETIME"`                                  // 更新时间
}

func (r *Membergoodslimitconfig) calc() {

}

func (r *Membergoodslimitconfig) buildSql() string {
	var sqlId utils.SQLVal = `
	select 
		t.autoid,
		t.userid,
		t.roletype,
		t.goodsid,
		t.isnodisplay,
		t.iscannotbuy,
		t.iscannotsell,
		t.updatetime
	from Membergoodslimitconfig t 
	where 1=1 
	`

	sqlId.And("t.userid", r.USERID)
	sqlId.And("t.roletype", r.ROLETYPE)

	return sqlId.String()
}

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

type GetTodayAccountConfigInfoRsp struct {
	TodayAccountMargins    []Todayaccountmargin    `json:"todayAccountMargins"`    // 今日账户保证金表
	TodayAccountTradefees  []Todayaccounttradefee  `json:"todayAccountTradefees"`  // 今日账户交易费用表
	TodayAccountTradeRules []Todayaccounttraderule `json:"todayAccountTradeRules"` // 今日账户交易规则信表
	RiskRatioType          *Riskratiotype          `json:"riskRatioType"`          // 风险率类型表
}

func GetTodayAccountConfigInfo(accountid int) (rsp GetTodayAccountConfigInfoRsp, err error) {
	todayAccountMargins := make([]Todayaccountmargin, 0)
	if err = db.GetEngine().In("ACCOUNTID", []int{0, accountid}).Find(&todayAccountMargins); err != nil {
		return
	}
	for i := range todayAccountMargins {
		item := &todayAccountMargins[i]
		item.INFOCONTENT = base64.StdEncoding.EncodeToString([]byte(item.INFOCONTENT))
	}

	todayAccountTradefees := make([]Todayaccounttradefee, 0)
	if err = db.GetEngine().In("ACCOUNTID", []int{0, accountid}).Find(&todayAccountTradefees); err != nil {
		return
	}
	for i := range todayAccountTradefees {
		item := &todayAccountTradefees[i]
		item.INFOCONTENT = base64.StdEncoding.EncodeToString([]byte(item.INFOCONTENT))
	}

	todayAccountTradeRules := make([]Todayaccounttraderule, 0)
	if err = db.GetEngine().In("ACCOUNTID", []int{0, accountid}).Find(&todayAccountTradeRules); err != nil {
		return
	}
	for i := range todayAccountTradeRules {
		item := &todayAccountTradeRules[i]
		item.INFOCONTENT = base64.StdEncoding.EncodeToString([]byte(item.INFOCONTENT))
	}

	rsp = GetTodayAccountConfigInfoRsp{
		TodayAccountMargins:    todayAccountMargins,
		TodayAccountTradefees:  todayAccountTradefees,
		TodayAccountTradeRules: todayAccountTradeRules,
	}

	sql := fmt.Sprintf(`
	SELECT TA.ACCOUNTID,
		NVL(NVL(NVL(UG.CUSTOMERTYPE, ARC.CUSTOMERTYPE), CTAD.CUSTOMERTYPE),
			-1) AS RISKID
	FROM TAACCOUNT TA
	LEFT JOIN USERACCOUNT UA
		ON UA.USERID = TA.USERID
	LEFT JOIN USERGROUPDETAIL UGD
		ON TA.USERID = UGD.USERID
	LEFT JOIN USERGROUP UG
		ON UGD.USERGROUPID = UG.AUTOID
	LEFT JOIN ACCOUNTRISKCONFIG ARC
		ON ARC.ACCOUNTID = TA.ACCOUNTID
	LEFT JOIN CUSTOMERTYPEAREADETAIL CTAD
		ON TA.USERID = CTAD.USERID
	WHERE 
	TA.TAACCOUNTTYPE IN (2)
	AND TA.ACCOUNTID = %v
	`, accountid)
	results, err := db.GetEngine().QueryInterface(sql)
	if err != nil {
		return
	}
	if len(results) > 0 {
		if riskid, ok := results[0]["RISKID"].(float64); ok {
			if riskid == -1 {
				var riskatiotype Riskratiotype
				if ok, err = db.GetEngine().Where("riskcontrolmode = 1 and isdefault = 1").Get(&riskatiotype); err == nil && ok {
					rsp.RiskRatioType = new(Riskratiotype)
					*rsp.RiskRatioType = riskatiotype
				} else {
					if err != nil {
						err = errors.New("获取数据失败")
					}
				}
			} else {
				var riskatiotype Riskratiotype
				if ok, err = db.GetEngine().Where("CUSTOMERTYPE = ?", riskid).Get(&riskatiotype); err == nil && ok {
					rsp.RiskRatioType = new(Riskratiotype)
					*rsp.RiskRatioType = riskatiotype
				} else {
					if err != nil {
						err = errors.New("获取数据失败")
					}
				}
			}
		}
	}

	return
}

func GetWskhOpenAccountConfigs(configs string) (datas []Wskhopenaccountconfig, err error) {
	err = db.GetEngine().In("CONFIGID", strings.Split(configs, ",")).NotIn("CONFIGID", []int{26, 27}).Find(&datas)

	return
}

func GetI18nConfigs() (datas []I18nConfig, err error) {
	err = db.GetEngine().Where("ISVALID = 1").Find(&datas)

	return
}

func GetClientDocumnetConfigs() (datas []ClientDocumentConfig, err error) {
	err = db.GetEngine().Where("1 = 1").Find(&datas)

	return
}

func GetUserScore(userID int) (datas []QueryUserScoreRsp, err error) {
	engine := db.GetEngine()
	rspdatas := make([]QueryUserScoreRsp, 0)
	if err := engine.Table("USERSCORE T").
		Join("LEFT", "SCORETYPE ST", `T.SCORETYPEID = ST.SCORETYPEID`).
		Select("T.*, ST.SCORETYPENAME AS SCORETYPENAME").
		Where("T.USERID = ?", userID).Find(&rspdatas); err != nil {
		return nil, err
	}

	return rspdatas, nil
}

func GetUserScoreDetail(userID int) (datas []QueryUserScoreDetailRsp, err error) {
	engine := db.GetEngine()
	rspdatas := make([]QueryUserScoreDetailRsp, 0)
	if err := engine.Table("USERSCOREDETAIL T").
		Join("LEFT", "SCORETYPE ST", `T.SCORETYPEID = ST.SCORETYPEID`).
		Select("TO_CHAR(T.DETAILID) DETAILID, T.TRADEDATE, T.USERID, T.SCORETYPEID, T.SCORE, T.REMAINSCORE, "+
			"T.VALIDTYPE, CASE WHEN T.VALIDTYPE = 1 OR T.VALIDTYPE = 3 THEN T.EXPIREDATE ELSE '-' END AS EXPIREDATE, "+
			"TO_CHAR(T.CREATETIME, 'YYYY-MM-DD HH24:MI:SS') CREATEDTIME, ST.SCORETYPENAME AS SCORETYPENAME").
		Where("T.USERID = ?", userID).
		OrderBy("T.VALIDTYPE, T.EXPIREDATE, T.DETAILID DESC").
		Find(&rspdatas); err != nil {
		return nil, err
	}

	return rspdatas, nil
}

func GetHotGoodses() (rsp []ErmcpGoods, err error) {
	// 合约交易根据”RECKON_DAYGOODSCOUNT“表
	// 现货数字交易根据表”DIGITALTRADE_TRADEDETAIL“(7*24小时，无结算)
	rspdatas := make([]ErmcpGoods, 0)
	sql := `
		SELECT
			G.GOODSID, G.GOODSCODE, G.GOODSNAME, G.MARKETID, G.GOODUNITID, G.AGREEUNIT,
			G.CURRENCYID, G.GOODSCURRENCYID, G.DECIMALPLACE, G.QUOTEMINUNIT, G.OUTGOODSCODE, 
			G.PICTUREURL, G.THUMURLS, G.BANNERURLS, M.TRADEMODE, GE.GOODSNAMEEN,
			GE.GOODSNAMETW, GE.GOODSNAMETH, GE.GOODSNAMEVI
		FROM 
		(SELECT T.GOODSID, NVL(T.TRADEAMOUNT, 0) TRADEAMOUNT, NVL(T.TRADEQTY, 0) TRADEQTY
				FROM RECKON_DAYGOODSCOUNT T
				WHERE T.RECKONDATE IN (SELECT T.PRETRADEDATE FROM MARKETRUN T WHERE T.MARKETID = 0)
				UNION
				SELECT T.GOODSID, SUM(NVL(T.TRADEVALUE, 0)) TRADEAMOUNT, SUM(NVL(T.TRADEVOLUME, 0)) TRADEQTY
				FROM DIGITALTRADE_TRADEDETAIL T
				WHERE T.TRADEDATE IN  (SELECT TO_CHAR(TRUNC(TO_DATE(MAX(T.TRADEDATE), 'yyyyMMdd')) - 1,  'YYYYMMDD') AS PREVIOUS_DAY FROM DIGITALTRADE_TRADEDETAIL T)
				GROUP BY T.GOODSID) TT
		INNER JOIN GOODS G ON G.GOODSID = TT.GOODSID
		INNER JOIN GOODSEX GE ON GE.GOODSID = G.GOODSID
		INNER JOIN MARKET M ON M.MARKETID = G.MARKETID
		ORDER BY TT.TRADEAMOUNT DESC, G.GOODSCODE
	`

	if err := db.GetEngine().SQL(sql).Find(&rspdatas); err != nil {
		return nil, err
	}

	return rspdatas, nil
}