def To_String(self, bID = True):
#下属节点处理，区分节点
Data = "{"
if(self.IsNode):
#print(len(self.List))
nLen = len(self.List)
for i in range(0, nLen):
pField = self.List[i]
strKey = myData.iif(bID, str(pField.ID), pField.Name_En)
if(pField.IsNode):
#print(pField.Name)
#print("Object")
Data += "'" + strKey + "':" + pField.To_String(bID)
else:
Data += "'" + strKey + "':" + pField.Get_String_Value()
if(nLen - 1 > i):
Data += ","
else:
#非节点直接处理
strKey = myData.iif(bID, str(self.ID), self.Name_En)
Data += "'" + strKey + "':" + self.Get_String_Value()
Data += "}"
#ss = json.dumps(Data, sort_keys = False, indent = 4)
#print(ss)
return Data
def getTradeInfo(self, price, stopProfit=True, numSell=0):
#股票信息
self.setRisk.Static_Profit(price) #更新股票操作统计信息
prift = price / self.setRisk.stockAvg - 1 #涨幅
priftMax = self.setRisk.priceMax / self.setRisk.stockAvg - 1 #最大涨幅
self.stopProfit_Retreat = myData.iif(self.setRisk.stopProfit_Dynamic,
self.setRisk.stopProfit_Retreat,
1)
self.stopLoss_Retreat = myData.iif(self.setRisk.stopLoss_Dynamic,
self.setRisk.stopLoss_Retreat, 1)
self.stopProfit_Trade = myData.iif(self.setRisk.stopProfit_Dynamic,
self.setRisk.stopProfit_Trade, 1)
self.stopLoss_Trade = myData.iif(self.setRisk.stopLoss_Dynamic,
self.setRisk.stopLoss_Trade, 1)
numTrade = myData.iif(stopProfit, self.stopProfit_Trade,
self.setRisk.stopLoss_Trade)
if (numSell == 0):
numSell = numTrade * self.setRisk.stockNum #卖出数量
if (numTrade > self.setRisk.stockPosition): #低仓位修正
numSell = self.setRisk.stockPosition * self.setRisk.stockNum
numSell = int(Decimal(numSell) + Decimal(0.5))
return {
"prift": prift,
"priftMax": priftMax,
"numTrade": numTrade,
"numSell": numSell
}
def getPrice(self,
security,
start_date="",
end_date="",
frequency='daily',
fields=None,
skip_paused=True,
count=None):
# 同步参数
dateTime = myData_Trans.Tran_ToDatetime_str(None, "%Y-%m-%d")
start_date = myData.iif(start_date == "", dateTime + " 09:00:00",
start_date)
end_date = myData.iif(end_date == "", dateTime + " 13:00:00", end_date)
# 查询数据
host = "http://hq.sinajs.cn/list="
url = host + security
req = urllib.request.Request(url)
res_data = urllib.request.urlopen(req)
res = res_data.read().decode(encoding="gbk")
values = res.split('=')
stkid = values[0][11:]
info = values[1][1:len(values[1]) - 4]
vargs = info.split(',')
# 区分股票与期权
if (stkid.count('CON_OP') == 1):
value = float(vargs[2])
else:
value = float(vargs[3])
return value
def newData_ByInfo(self, dataInfo, checkTime=True):
#解析所有返回数据
if len(dataInfo['values']) == 1:
_values = dataInfo['values']
_setInfo = dataInfo['setInfo']
times = myData.iif(_setInfo.stockInfo.type == "opt", 10000, 1)
qd = self.newData()
qd.id = _setInfo.stockInfo.code_id
qd.idTag = _setInfo.setTag
qd.rawline = ""
qd.name = _setInfo.stockInfo.code_name
qd.openPrice = float(_values['open'][0] * times)
qd.preClose = qd.openPrice
qd.lastPrice = float(_values['close'][0] * times)
qd.highPrice = float(_values['high'][0] * times)
qd.lowPrice = float(_values['low'][0] * times)
qd.tradeValume = float(_values['volume'][0])
qd.tradeTurnover = float(_values['money'][0])
qd.buyPrice = myData.iif(qd.tradeTurnover == 0, qd.preClose,
qd.tradeTurnover / qd.tradeValume)
qd.sellPrice = qd.buyPrice
qd.buy1Volume = -1
qd.buy1Price = -1
qd.buy2Volume = -1
qd.buy2Price = -1
qd.buy3Volume = -1
qd.buy3Price = -1
qd.buy4Volume = -1
qd.buy4Price = -1
qd.buy5Volume = -1
qd.buy5Price = -1
qd.sell1Volume = -1
qd.sell1Price = -1
qd.sell2Volume = -1
qd.sell2Price = -1
qd.sell3Volume = -1
qd.sell3Price = -1
qd.sell4Volume = -1
qd.sell4Price = -1
qd.sell5Volume = -1
qd.sell5Price = -1
qd.date = dataInfo['time']
qd.time = qd.date.split(' ')[1]
qd.date = qd.date.split(' ')[0]
#时间检查(是否当天)
if (checkTime):
if (qd.checkTime() == False):
return None
#设置数据
qd.value = qd.lastPrice
return qd
return None
def getContent(self, bAll = False):
# 生成表结构
lstTable = []
lstField = []
lstField2 = []
lstTable.append(lstField)
lstTable.append(lstField2)
# 初始行列数据
if(self.simpleField):
for x in self.fields:
lstField.append(x.nameFiled)
lstField2.append(":---") # 表字段结构
# 循环填入所有数据
for i in range(0, self.rows):
lstValue = []
lstTable.append(lstValue)
for x in self.fields:
lstValue.append(x.values[i])
else:
for x in range(0, self.cols):
lstField.append("")
lstField2.append(myData.iif(self.indFields[x] == 1, ":-----", ":---"))
# 初始行列数据
for x in range(0, self.rows - 1):
lstTable.append([""] * self.cols)
# 循环填入所有数据
for x in self.fields:
indR = myData.iif(x.row > 0, x.row + 1, x.row)
lstTable[indR][x.col] = x.nameFiled
if(len(x.values) > 0):
lstTable[indR][x.col+1] = x.values[0]
for i in range(1, len(x.values)):
lstTable[indR + 1][x.col] = "^"
lstTable[indR + 1][x.col+1] = x.values[0]
# 组装字符串
strLines = ""
indR = -1
for row in lstTable:
indR += 1
if(indR > 0): strLines += "\r\n"
for i in range(0, self.cols):
strLines += "| "
if(not self.simpleField and self.indFields[i] == 1 and indR > 1 and row[i] != "^" and row[i] != ""):
strLines += "<b>"
strLines += row[i] + " "
strLines += "|"
return strLines.strip()
def OnHandleMsg(self, msg, plat = "", bCheck = False, nSleep = 0):
if(msg == None): return
strMsg = msg.get('msg')
if(strMsg == '~__~'):
myDebug.Print("消息管理器::", typePlatform + ">> ", "心跳::" + strMsg)
return
#异步延迟消息处理
if(nSleep > 0):
self.OnHandleMsg_Check(msg, plat)
msg["timeLimit"] = datetime.datetime.now() + datetime.timedelta(seconds=nSleep)
self.usrMsgs_Buffer.append(msg)
return
#消息内容校正
if(bCheck):
self.OnHandleMsg_Check(msg, plat)
#文字输出
typePlatform = myData.iif(plat == "", msg.get("usrPlat", myMsgPlat.wx), plat)
if(self.usePrint):
myDebug.Print("消息管理器::", typePlatform + ">> ",strMsg)
#声音输出
#if(self.useVoice):
# myVoice.Say_thrd(msg["text"])
#在线消息输出
if(typePlatform != ""):
pWeb = self.usrWebs.get(typePlatform, None) #提取对应平台的web对象
if(pWeb != None):
#格式化接口输出
wxPath = msg["usrName"] + "/" + strMsg + "/" + msg["msgType"]
pWeb.Do_API_get(wxPath, typePlatform + "API-py")
usrMQ = self.usrMQs.get(typePlatform, None)
if(usrMQ != None):
#特殊消息处理
toUser = msg.get('to_usrName', "")
if(toUser != ""):
toUser = myData.iif(toUser.lower() != "self", toUser, self.usrNameSelfs.get(typePlatform, toUser))
msg['usrID'] = ""
msg['usrName'] = toUser #调整toUser
msg['usrNameNick'] = ""
#转发消息
usrMQ.Send_Msg(usrMQ.nameQueue, str(msg))
if(self.usePrint):
myDebug.Print("消息管理器转发::", usrMQ.nameQueue + ">> ",strMsg)
def getOptInfo(self, optPrice=2500, dateTime="", month_Delta=0):
# 同步参数
if (dateTime == ""):
dateTime = myData_Trans.Tran_ToDatetime_str(None, "%Y-%m-%d")
dtFliter = myData_Trans.Tran_ToDatetime(dateTime, "%Y-%m-%d")
strFliter = "50ETF" + myData.iif(
optPrice > 0, "购",
"沽") + str(dtFliter.month + month_Delta) + "月" + str(abs(optPrice))
# 查询
optInfos = opt.run_query(
query(opt.OPT_DAILY_PREOPEN).filter(
opt.OPT_DAILY_PREOPEN.date == dateTime,
opt.OPT_DAILY_PREOPEN.name == strFliter).limit(10))
if (optInfos.shape[0] != 1): return None
# 查询最新的期权基本资料数据
code = optInfos['code'][0]
optInfo = query(
opt.OPT_CONTRACT_INFO).filter(opt.OPT_CONTRACT_INFO.code == code)
value = opt.run_query(optInfo)
if (len(value) != 1): return None
return {
'id': value['id'][0],
'code': value['code'][0],
'trading_code': value['trading_code'][0],
'name': value['name'][0]
}
def _Title(self, usrInfo={}, bRegist=False, bRegistOut=False):
if (self.isRunning):
if (bRegist or bRegistOut):
groupName = usrInfo.get('groupName', "")
strReturn = myData.iif(groupName == "", "",
"@" + usrInfo.get('usrName', "") + "：")
if (bRegistOut == False):
strReturn += self.doTitle + "功能" + "--已注册\n\t" + self._Title_User_Opened(
) + "(" + str(self.tStart) + ")"
else:
strReturn += self.doTitle + "功能" + "--已注销\n\t" + self._Title_User_Opened(
) + "(" + str(self.tStart) + ")"
else:
self.isRunning = False #标识非运行
self.isValid = True #有效性恢复
strReturn = self.doTitle + "功能" + "--已关闭\n\t" + self._Title_User_Closed(
) + "(" + str(self.tStart) + ")"
else:
self.Init() #初始基础信息
self.isRunning = True #标识运行
self.usrID = usrInfo.get('usrID', "") #功能所属用户ID(启动者)
self.usrName = usrInfo.get('usrName', "") #功能所属用户名称(启动者)
strReturn = self.doTitle + "功能" + "--已开启\n\t" + self._Title_User_Opened(
) + "(" + str(self.tStart) + ")"
myDebug.Print(strReturn + "\n")
return strReturn
def getCompanys(self,
param="",
isDel=False,
page=1,
per_page=10,
dataDB=None):
# 组装查询条件
strFilter = F"isDel=={str(isDel)}"
if (param != ""):
strFilter += F" && {param}"
# 查询数据
if (dataDB == None):
dataDB = gol._Get_Value('dbCompany')
dictData = dataDB.Query(strFilter, "", True)
lstData = list(dictData.values())
# 提取及返回
numData = len(lstData)
start = page * per_page - per_page
end = page * per_page
end = myData.iif(end < numData, end, numData)
values = []
if (numData > start):
for x in range(start, end):
values.append(lstData[x])
return len(lstData), values
def _getDefault_Param(self): #默认配置
if (self.pSets != None):
self.paramsSet = {}
self.paramsList = []
keys = self.pSets.setList.keys()
lstParam = []
for x in keys:
pSet = self.pSets._Find(x)
if (pSet != None and pSet.IsEnable()):
lstSets = self.paramsSet.get(pSet.stockInfo.source_set,
None)
if (lstSets == None):
self.paramsSet[pSet.stockInfo.source_set] = []
lstSets = self.paramsSet.get(pSet.stockInfo.source_set,
None)
lstSets.append(pSet)
#记录设置编号
if (pSet.stockInfo.source_set == self.type):
lstParam.append(
myData.iif(pSet.stockInfo.source_code == "",
pSet.setTag,
pSet.stockInfo.source_code))
self.paramsList = lstParam
strParams = myData_Trans.Tran_ToStr(lstParam).replace(".", '')
return strParams
def OnHandleMsg(self, msg):
if (msg == None): return None
#必须有处理消息存在
strMsg = msg.get('msg', "")
if (strMsg != ""):
#拆分'\n'取行最大
lines = strMsg.split('\n')
nLen = 0
for x in lines:
nLength = len(x)
if (nLength > nLen): nLen = nLength
# nMax = myData.iif(nLen > 15, 40, 32)
nMax = myData.iif(nLen > 15, 32, 32)
#尾部标签
msgTag = msg.get('msgTag', "")
strTag = " --zxcRobot(" + msgTag + ") " + myData_Trans.Tran_ToTime_str(
None, '%H:%M:%S')
strTag = strTag.replace("()", "")
strTag = (nMax - len(strTag)) * " " + strTag
msg["msg"] = strMsg + "\n" + strTag
#消息管理器处理消息
self.usrMMsg.OnHandleMsg(msg)
return True
return None
def toString(self):
return self.name + '(' + myData.iif(self.idTag == "", self.id, self.idTag) + ')' \
+ ', openPrice=' + str(self.openPrice) \
+ ', preClose=' + str(self.preClose) \
+ ', lastPrice=' + str(self.lastPrice) \
+ ', highPrice=' + str(self.highPrice) \
+ ', lowPrice=' + str(self.lowPrice) \
+ ', buyPrice=' + str(self.buyPrice) \
+ ', sellPrice=' + str(self.sellPrice) \
+ ', tradeValume=' + str(self.tradeValume) \
+ ', buy1Volume=' + str(self.buy1Volume) \
+ ', buy1Price=' + str(self.buy1Price) \
+ ', buy2Volume=' + str(self.buy2Volume) \
+ ', buy2Price=' + str(self.buy2Price) \
+ ', buy3Volume=' + str(self.buy3Volume) \
+ ', buy3Price=' + str(self.buy3Price) \
+ ', buy4Volume=' + str(self.buy4Volume) \
+ ', buy4Price=' + str(self.buy4Price) \
+ ', buy5Volume=' + str(self.buy5Volume) \
+ ', buy5Price=' + str(self.buy5Price) \
+ ', sell1Volume=' + str(self.sell1Volume) \
+ ', sell1Price=' + str(self.sell1Price) \
+ ', sell2Volume=' + str(self.sell2Volume) \
+ ', sell2Price=' + str(self.sell2Price) \
+ ', sell3Volume=' + str(self.sell3Volume) \
+ ', sell3Price=' + str(self.sell3Price) \
+ ', sell4Volume=' + str(self.sell4Volume) \
+ ', sell4Price=' + str(self.sell4Price) \
+ ', sell5Volume=' + str(self.sell5Volume) \
+ ', sell5Price=' + str(self.sell5Price) \
+ ', date=' + self.date \
+ ', time=' + self.time \
+ ', quotePlat=' + self.quotePlat \
+ ', quoteTimeType=' + self.quoteTimeType
def _Delete(self, id, tableName="", idField='ID'):
# 调用删除数据
idInfo = myData.iif(type(id) == str, f"'{ID}'", str(id))
rs = self.execute(
self._dbName,
f"DELETE FROM {tableName} WHERE {idField} = {idInfo};")
return not rs == None
def __init__(self,
tagTime,
data=Quote_Data(),
lastData_S=None,
interval_M=-1):
self.tag = tagTime #标识时间
self.interval_M = interval_M #分钟级间隔
self.dataS_Last = lastData_S #前一个统计对象
self.values = {} #值集（按时间key记录）
#更新统计信息
if (lastData_S != None):
self.dataS = Quote_Data_Static(tagTime, lastData_S.dataS) #当前统计值信息
else:
self.dataS = Quote_Data_Static(tagTime) #当前统计值信息
#其他初始
self.dataS.Init(data.value)
if (self.dataS_Last == None):
datas = data.toValueList()
self.dataS.base = data.priceBase #基价，前一收盘
self.dataS.start = data.priceOpen #开盘价
self.dataS.high = datas[2] #最高价
self.dataS.low = datas[3] #最低价
self.dataS.average = myData.iif(datas[6] == 0, 0,
datas[7] / datas[6])
self.setData(data)
def createIndex(self, tableName, indexType, indexName, fieldNames):
# 查询 表索引是否存在
nState = 0
if (self.isExist_Index(tableName, indexName) == True):
myDebug.Debug(f'表{tableName}索引{indexName}已存在.\n')
return nState
else:
myDebug.Debug(f"开始创建表索引{indexName}......")
try:
indexType = indexType.strip().lower()
if (indexType == 'unique'): indexType += " index"
if (indexType == 'primary'):
indexType += " key"
indexName = ""
rs = self.execute(
"",
f'ALTER TABLE {tableName} ADD {indexType} {indexName}({fieldNames});'
)
nState = myData.iif(rs == None, -1, 1)
except Exception as e:
myDebug.Debug(f'error:{e}')
nState = -1
myDebug.Debug(f'表{tableName}索引{indexName}创建完毕!\n')
return nState
def _Query(self,
fliter,
tableName="",
fields=[],
orderField='',
pageInd=1,
perSize=0):
# 组装查询返回字段
infoFields = ""
for x in fields:
infoFields += ',' + x
if (orderField != ""):
orderField = F"ORDER BY {orderField} "
orderLimit = ""
if (perSize > 0):
orderLimit = F"limit {(pageInd-1)*perSize}, {perSize}"
# 调用查询数据
# lstSymbol = ['==', '!=', '>=', '>', '<=', '<', '%like%']
fliter = fliter.replace("==", "=")
infoFields = myData.iif(len(infoFields) > 1, infoFields[1:], "*")
rs = self.query(
f"SELECT {infoFields} FROM {tableName} WHERE {fliter} {orderField} {orderLimit};"
)
return rs
def _Done(self, Text, isGroup=False, idGroup=""):
#命令权限提升()
#print(Text)
bResult, pPrj = self.usrRoot.Add_Cmd(Text, isGroup, idGroup)
strText = "功能(" + pPrj.prjName + ")权限提升" + myData.iif(
bResult, "成功！", "失败！")
return strText
def _Check_Connection(self):
#TCP是否关闭或正在关闭，则重连
isReConnect = False
#if(self.usrConn.is_closed or self.usrConn.is_closing):
if (self.usrConn.is_closed):
self.Init()
isReConnect = True
#重建频道
if (isReConnect or self.usrChannel.is_closed):
usrType = myData.iif(self.isSender, "生产者", "消费者")
myDebug.Print("消息队列MQ::",
usrType + ">> " + self.nameQueue + "已经掉线！")
#在连接上创建一个频道
#self.usrChannel = self.usrConn.channel()
#声明一个队列，生产者和消费者都要声明一个相同的队列，用来防止万一某一方挂了，另一方能正常运行
#self.usrChannel.queue_declare(queue=self.nameQueue)
try:
self.Init_Queue(self.nameQueue, self.isDurable, self.isAutoAck)
time.sleep(2)
myDebug.Print("消息队列MQ::",
usrType + ">> " + self.nameQueue + "已重连！")
except Exception as ex:
myDebug.Print("消息队列MQ::",
usrType + ">> " + self.nameQueue + "重连失败！")
myError.Error(ex)
pass
self.isInited = self.usrConn.is_open #标识是否在线
def callback_Consumer(self, ch, method, properties, body):
#回调，通知处理消息
if (self.callback_RecvMsg != None):
try:
strMsg = body.decode('utf-8')
if (strMsg == self.strHeartbeat):
ch.basic_ack(delivery_tag=method.delivery_tag
) #接收到消息后会给rabbitmq发送一个确认
#myDebug.Print("消息队列MQ::", self.nameQueue + ">> ", "接受心跳::" + strMsg)
return
#消息回调
self.callback_RecvMsg(strMsg)
ch.basic_ack(
delivery_tag=method.delivery_tag) #接收到消息后会给rabbitmq发送一个确认
except Exception as ex:
usrType = myData.iif(self.isSender, "生产者", "消费者")
myDebug.Print("消息队列MQ::",
usrType + ">> " + self.nameQueue + "连接中断！")
myError.Error(ex)
finally:
#if(self.isAutoAck == False):
# #不论当前消息是否成功,都表示消息确实处理完了 手动确认 否则没有ack不再发送新消息 保证确实被处理了再确认
# ch.basic_ack(delivery_tag = method.delivery_tag) #接收到消息后会给rabbitmq发送一个确认
pass
def getTradeRisk(self, usrNmae, stockID, avg5 = True, avg10 = False, avg20 = False, end_date=None):
# 提取设置
setDB = gol._Get_Value('zxcDB_StockTradeRisk')
dictSet = self.getSet(usrNmae, stockID, False, setDB)
if(dictSet == None): return None
#获取均值
nTimes = myData.iif(dictSet['标的名称'].count('50ETF') == 1, 10000, 1)
stockSource = gol._Get_Value('quoteSource_API_JqData', None)
avgs = [0, 0, -1, -1, -1, -1]
if(avg5):
avg5s = stockSource.getPrice_avg_day(stockID, 5, False, end_date)
avgs[0] = avg5s['high'] * nTimes
avgs[1] = avg5s['low'] * nTimes
if(avg10):
avg10s = stockSource.getPrice_avg_day(stockID, 10, False, end_date)
avgs[2] = avg10s['high'] * nTimes
avgs[3] = avg10s['low'] * nTimes
if(avg20):
avg20s = stockSource.getPrice_avg_day(stockID, 10, False, end_date)
avgs[4] = avg20s['high'] * nTimes
avgs[5] = avg20s['low'] * nTimes
# 初始风险监测对象
pSet = mySet_StockTradeRisk(dictSet)
if(nTimes == 10000): # 修正期权默认设置
pSet.stopProfit = 0.10 #止盈线，默认为6%
pSet.stopLoss = 0.06 #止损线，默认为-2%
pSet.stopProfit_Retreat = 0.03 #止盈回撤，默认为1%, 超过止盈线以上则为2倍
pSet.stopLoss_Retreat = 0.02 #止损回撤，默认为1%
pRisk = myMonitor_TradeRisk(avgs[0], avgs[1], avgs[2], avgs[3], avgs[4], avgs[5])
pRisk.initSet(pSet, setDB)
pRisk.saveSet()
return pRisk
def Init(self,
recorder,
usrID,
tradeParty,
tradeMoney,
tradeTarget,
usrBillType="",
tradeType="",
tradeTypeTarget="",
dateTime="",
remark="",
tradePrice=0,
tradeNum=0,
tradeID_Relation="",
tradeProfit=0):
self.usrID = usrID
self.usrBillType = usrBillType
self.tradeID_Relation = str(tradeID_Relation)
self.tradeParty = tradeParty
self.tradeNum = tradeNum
self.tradePrice = tradePrice
self.tradeMoney = tradeMoney
self.tradeProfit = tradeMoney
self.tradeTarget = tradeTarget
self.tradeType = tradeType
self.tradeTypeTarget = tradeTypeTarget
self.tradeTime = dateTime
self.remark = remark
self.recorder = myData.iif(recorder == "", "zxcRobot", recorder)
self.billInfo = self.OnCreat_BillInfo()
self.Init_ByDict(self.billInfo)
def Static_Profit(self, strokPrice, bUpdata = True):
#累计买入、卖出
sumStock_Buy = 0
sumMoney_Buy = 0
sumStock_Sell = 0
sumMoney_Sell_fee = 0
for x in self.logOperates:
if(x["股数"] < 0):
sumStock_Sell += x["股数"]
sumMoney_Sell_fee += x["股价"] * x["股数"] #计算含手续费
else:
sumStock_Buy += x["股数"]
sumMoney_Buy += x["股价"] * x["股数"] #计算含手续费
#统计计算
sumStock_Trade = sumStock_Buy + abs(sumStock_Sell)
sumMoney_Sell = sumMoney_Sell_fee * (1 - self.stockFee) #卖出总金额（不含手续费）
sumMoney = (sumStock_Buy + sumStock_Sell) * strokPrice - sumMoney_Sell #当前市值（含卖出）
sumStock = sumStock_Buy + sumStock_Sell
profitNow = sumMoney / sumMoney_Buy - 1 #当前浮盈-阶段
stockAvg_sell = 0
if(sumStock_Sell != 0):
stockAvg_sell = sumMoney_Sell_fee / sumStock_Sell #卖出均价
stockCost = (sumMoney_Buy + sumMoney_Sell) / myData.iif(sumStock <= 0, sumStock_Buy, sumStock)
#更新
if(bUpdata == True):
self.sumStock_Trade = sumStock_Trade #更新交易数量-买卖
self.priceCost = stockCost #更新成本价格
self.priceNow = strokPrice #更新当前价格
self.priceAvg_sell = stockAvg_sell #更新卖出均价
self.profitNow = profitNow #更新当前阶段浮盈
if(self.profitMax < self.profitMax_Stage):
self.profitMax = self.profitMax_Stage #更新最大浮盈
return profitNow, stockCost
def __init__(self,
tagName,
dirSwap,
stepSwaps=1,
delayedTime=0,
useAck=True,
nameSwap='zxcTest',
isSender=False,
dirSwap_out=""):
self.tagName = tagName
self.nameSwap = nameSwap
self.dirSwap = dirSwap
self.dirSwap_out = myData.iif(dirSwap_out == "", dirSwap, dirSwap_out)
self.stepSwaps = stepSwaps
self.isSender = isSender
self.useAck = useAck
self.dirSwap_back = dirSwap + "_back/" + tagName
self.delayedTime = delayedTime
self.dataOut = []
self.ackDict = {}
self.ackInfo = {
"isAcked": False,
"time": None,
"retrys": 0,
"path": ""
}
self.functionDict = {}
self.funChange = None
def getTitleMark(self, price, isHit, isNewLimit, isBreakLimit = True, isStopProfit = True, numSell = 0):
#提取股票交易建议信息
tradeInfo = self.getTradeInfo(price)
numTrade = tradeInfo['numTrade']
numSell = tradeInfo['numSell']
#组装提示要素
strPrice = str(Decimal(price).quantize(Decimal('0.00'))) + " 元" #价格
strSell = str(numSell) + "股" #股数
strRetreat = str(Decimal((self.stopProfit_Retreat * 100)).quantize(Decimal('0.0'))) + "%" #回撤
strTrade = str(Decimal((numTrade * 10)).quantize(Decimal('0.0'))) + "成" #仓位
strProfit = str(Decimal((self.setRisk.profitNow * 100)).quantize(Decimal('0.00'))) + "%" #当前收益
strProfitNow = str(Decimal((self.profitNow * 100)).quantize(Decimal('0.0'))) + "%" #当前浮盈
strMax = str(Decimal((self.setRisk.profitMax * 100)).quantize(Decimal('0.00'))) + "%" #最高浮盈
strMaxStage = str(Decimal((self.setRisk.profitMax_Stage * 100)).quantize(Decimal('0.00'))) + "%"#阶段浮盈-前高
#触发止盈止损
strReutrn = F"{self.setRisk.stockName}: {strPrice}"
if(isHit):
if(isNewLimit == False): #第一次触发
if(isStopProfit):
strReutrn += F", 浮盈超 {strProfitNow}, 触发止盈.\r\n操作策略: 启动动态止盈.\r\n策略收益: {strProfit}."
else:
strReutrn += F", 浮亏超 {strProfitNow}, 触发止损.\r\n操作策略: 启动动态止损.\r\n策略收益: {strProfit}."
else: #再一次触发
if(isStopProfit):
strTag = myData.iif(isBreakLimit, "突破新高", "阶段新高")
strReutrn += F", 浮盈超 {strProfitNow}, {strTag}.\r\n操作策略: 动态止盈线上移.\r\n策略收益: {strProfit}, 涨幅前高 {strMaxStage}, 最高 {strMax}."
else:
strTag = myData.iif(isBreakLimit, "突破新低", "阶段新低")
strReutrn += F", 浮亏超 {strProfitNow}, {strTag}.\r\n操作策略: 动态止损线上移.\r\n策略收益: {strProfit}, 涨幅前高 {strMaxStage}, 最高 {strMax}."
else:
if(isStopProfit):
if(self.setRisk.stopProfit_Dynamic == False):
strReutrn += F", 浮盈超 {strProfitNow}.\r\n操作策略: 建议止盈, 操作 全仓, 卖出 {strSell}.\r\n策略收益: {strProfit}, 涨幅前高 {strMaxStage}, 最高 {strMax}."
else:
strReutrn += F", 回撤逾 {strRetreat}.\r\n操作策略: 建议止盈, 操作 {strTrade}仓, 卖出 {strSell}.\r\n策略收益: {strProfit}, 当前浮盈: {strProfitNow}, 涨幅前高 {strMaxStage}, 最高 {strMax}."
else:
if(self.setRisk.stopLoss_Dynamic == False):
strReutrn += F", 浮亏超 {strProfitNow}.\r\n操作策略: 建议止损, 操作 全仓, 卖出 {strSell}.\r\n策略收益: {strProfit}, 涨幅前高 {strMaxStage}, 最高 {strMax}."
else:
strReutrn += F", 亏损逾 {strRetreat}.\r\n操作策略: 建议止损, 操作 {strTrade}仓, 卖出 {strSell}.\r\n策略收益: {strProfit}, 当前浮盈: {strProfitNow}, 涨幅前高 {strMaxStage}, 最高 {strMax}."
myDebug.Debug(strReutrn.replace("\r\n", ""))
#交易处置
self.handleTrade(price, -numSell, False)
return strReutrn
def updatID(self, nID=1):
self.headID = myData.iif(nID < 1, 1, nID)
# 修改子集
ind = 1
for x in self.Childs:
x.updatID(ind)
ind += 1
def upData_ID(self, nID = 1):
self.titleID = myData.iif(nID < 1, 1, nID)
# 修改子集
ind = 1
for x in self.Childs:
x.upData_ID(ind)
ind += 1
def _Init_DB(self, path):
#提取字段信息
dtDB = myIO_xlsx.DtTable()
dtDB.Load_csv(path, 1, 0, True, 0, ',', isUtf=True)
lstFields = [
"编号", "用户名", "操作类型", "标的代码", "标的名称", "标的所属市场", "标的所属市场板块", "标的价格",
"标的价格-期望", "标的仓位", "标的所属行业", "标的所属概念", "交易类型", "交易子类型", "交易数量",
"交易金额", "交易量仓位占比", "交易收益", "交易收益-总计", "交易时间", "是否删除", "记录人",
"记录时间", "备注"
]
if (dtDB.sheet == None): dtDB.dataField = lstFields
lstFields_ind = dtDB.Get_Index_Fields(lstFields)
self.lstFields = lstFields
self.pathData = path
#装载账单记录
self.usrDB = {}
self.indLst = []
for dtRow in dtDB.dataMat:
trade = myObj_Trade()
if (dtRow[lstFields_ind["记录时间"]] == ""): continue
trade.recordTime = myData_Trans.Tran_ToDatetime(
dtRow[lstFields_ind["记录时间"]])
trade.recorder = dtRow[lstFields_ind["记录人"]]
trade.usrID = dtRow[lstFields_ind["用户名"]]
trade.usrOrderType = dtRow[lstFields_ind["操作类型"]]
trade.targetID = dtRow[lstFields_ind["标的代码"]]
trade.targetName = dtRow[lstFields_ind["标的名称"]]
trade.targetMarket = dtRow[lstFields_ind["标的所属市场"]]
trade.targetMarketBoard = dtRow[lstFields_ind["标的所属市场板块"]]
trade.targetIndustries = dtRow[lstFields_ind["标的所属行业"]].split("、")
trade.targetConcepts = dtRow[lstFields_ind["标的所属概念"]].split("、")
trade.targetPrice = float(dtRow[lstFields_ind["标的价格"]])
trade.targetPrice_Ex = float(dtRow[lstFields_ind["标的价格-期望"]])
trade.targetPosition = float(dtRow[lstFields_ind["标的仓位"]])
trade.infoID = int(dtRow[lstFields_ind["编号"]])
trade.tradeType = dtRow[lstFields_ind["交易类型"]]
trade.tradeType_sub = dtRow[lstFields_ind["交易子类型"]]
trade.tradeNum = float(dtRow[lstFields_ind["交易数量"]])
trade.tradeMoney = float(dtRow[lstFields_ind["交易金额"]])
trade.tradePosition = float(dtRow[lstFields_ind["交易量仓位占比"]])
trade.tradeProfit = float(dtRow[lstFields_ind["交易收益"]])
trade.tradeProfit_total = float(dtRow[lstFields_ind["交易收益-总计"]])
trade.tradeTime = myData_Trans.Tran_ToDatetime(
dtRow[lstFields_ind["交易时间"]])
trade.isDel = myData.iif(dtRow[lstFields_ind["是否删除"]] == "TRUE",
True, False)
trade.remark = dtRow[lstFields_ind["备注"]]
self.usrDB[trade.infoID] = trade
self.indLst.append(trade.infoID) # 顺序记录索引
self.dtDB = dtDB
def upload_company(companyID=""):
form = myCompanyForm() #生成form实例，给render_template渲染使用
needRefresh = True
editSucess = False
if form.validate_on_submit(
): #调用form实例里面的validate_on_submit()功能，验证数据是否安全，如是返回True，默认返回False
if form.save.data: # 保存按钮被单击
# 组装row信息
pValues = []
if (True):
pValues.append("-1")
pValues.append(form.companyID.data)
pValues.append(form.companyName.data)
pValues.append(form.companyInStreet.data)
pValues.append(form.companyInVillage.data)
pValues.append(form.companyAdrr.data)
pValues.append(form.companyScale.data)
pValues.append(form.companyContacts.data)
pValues.append(form.companyPhone.data)
companyHasProcess = myData.iif(
form.companyHasProcess.data == "是", True, False)
pValues.append(companyHasProcess)
pValues.append(form.companyNumProcess.data)
pValues.append(form.companyRecycle.data)
pValues.append(form.companyVolumeTotal.data)
pValues.append(
myData_Trans.Tran_ToDatetime_str(
form.companyRedate.data))
pValues.append(form.companyRevolume.data)
pValues.append(form.companyTransferredvolume.data)
pValues.append(form.companyNoTransferredvolume.data)
pValues.append(form.imgName_1.data)
pValues.append(form.imgName_2.data)
pValues.append(form.imgName_3.data)
pValues.append(form.imgName_4.data)
pValues.append(form.imgName_5.data)
pValues.append(form.imgName_6.data)
# 添加并保存信息
rowInfo = myData_Trans.Tran_ToStr(pValues, ',')
dbCompany = gol._Get_Value('dbCompany')
if (dbCompany.Add_Row_BySimply(rowInfo, True, True) != ""):
editSucess = True
else:
# 保存时，验证失败，不需要刷新
if form.save.data:
needRefresh = False
return render_template('company_active carbon.html',
title='company upload',
form=form,
companyID=companyID,
needRefresh=needRefresh,
editSucess=editSucess)
def Log_ByDict(self, msg, msgID, msgType, usrInfo):
pMsgs = self._Find_Log_ByDict(usrInfo, True)
if(pMsgs != None):
if(msg == ""): return False
nameSelf = usrInfo.get('usrNameSelf', "")
usrName = myData.iif(nameSelf == "", usrInfo.get('usrName', ""), nameSelf)
usrPlat = usrInfo.get('usrPlat', "")
pMsg = myMsg(msg, msgID, msgType, usrName, usrPlat)
pMsgs._Add(pMsg, True)
return True
def Save(self,
strDir,
fileName,
row_start=0,
col_start=0,
cell_overwrite=True,
sheet_name="",
row_end=-1,
col_end=-1,
bSave_AsStr=True,
styleSets=[]):
#创建workbook和sheet对象
pWorkbook = xlwt.Workbook() #注意Workbook的开头W要大写
pName = myData.iif(sheet_name == "", "sheet1", sheet_name)
pSheet = pWorkbook.add_sheet(pName, cell_overwrite_ok=cell_overwrite)
#循环向sheet页中写入数据
nCols = self._Cloumns(col_end)
nRows = self._Rows(row_end)
if (nRows > 0):
nCols = myData.iif(col_end < 0, len(self.dataMat[0]), col_end)
# 写入字段
for j in range(col_start, nCols):
pSheet.write(row_start, j - col_start, self.dataField[j])
# 写入值
for i in range(row_start, nRows):
pValues = self.dataMat[i]
for j in range(col_start, nCols):
strVaulue = self.Trans_Value_str(pValues[j], bSave_AsStr)
pSheet.write(i - row_start + 1, j - col_start, strVaulue)
#保存风格
self.setStyles(pSheet, styleSets)
#保存该excel文件,有同名文件时直接覆盖
strPath = strDir + "/" + fileName + ".xls"
strPath.replace("\/", "/")
strPath.replace("//", "/")
pWorkbook.save(strPath)
return True
