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:"-"  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:强制
}

// 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.Where("ENUMDICCODE = ?", enumDicCode)
	if enumItemName > 0 {
		session = session.And("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:展示
}

// 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 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
}

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.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
}