From e43df6d9e6ab196ba7a34248362e814b308674a9 Mon Sep 17 00:00:00 2001 From: "vn.py" Date: Wed, 28 Aug 2019 22:35:12 +0800 Subject: [PATCH] [Add] DA market api --- .../ctp/generator/generate_api_functions.py | 2 + .../da/generator/da_future_header_function.h | 48 + vnpy/api/da/generator/da_future_header_on.h | 66 ++ .../generator/da_future_source_function.cpp | 340 ++++++ .../da/generator/da_future_source_module.cpp | 59 ++ vnpy/api/da/generator/da_future_source_on.cpp | 396 +++++++ .../da/generator/da_future_source_task.cpp | 992 ++++++++++++++++++ vnpy/api/da/generator/da_future_struct.py | 8 +- .../da/generator/da_market_header_function.h | 6 + vnpy/api/da/generator/da_market_header_on.h | 16 + .../generator/da_market_source_function.cpp | 40 + .../da/generator/da_market_source_module.cpp | 13 + vnpy/api/da/generator/da_market_source_on.cpp | 96 ++ .../da/generator/da_market_source_task.cpp | 153 +++ .../da/generator/da_stock_header_function.h | 38 + vnpy/api/da/generator/da_stock_header_on.h | 56 + .../da/generator/da_stock_source_function.cpp | 285 +++++ .../da/generator/da_stock_source_module.cpp | 49 + vnpy/api/da/generator/da_stock_source_on.cpp | 336 ++++++ .../api/da/generator/da_stock_source_task.cpp | 826 +++++++++++++++ vnpy/api/da/generator/da_stock_struct.py | 6 +- .../da/generator/generate_api_functions.py | 129 +-- vnpy/api/da/generator/generate_struct.py | 2 +- vnpy/api/da/include/da/DAFutureApi.h | 19 +- vnpy/api/da/include/da/DAMarketApi.h | 16 +- vnpy/api/da/libs/_DAApi_x64.lib | Bin 7110 -> 0 bytes vnpy/api/da/vnda/vnda.h | 88 ++ vnpy/api/da/vnda/vnda.sln | 51 + vnpy/api/da/vnda/vndafuture/dllmain.cpp | Bin 0 -> 848 bytes vnpy/api/da/vnda/vndafuture/stdafx.cpp | Bin 0 -> 44 bytes vnpy/api/da/vnda/vndafuture/stdafx.h | Bin 0 -> 480 bytes vnpy/api/da/vnda/vndafuture/targetver.h | Bin 0 -> 368 bytes vnpy/api/da/vnda/vndafuture/vndafuture.cpp | Bin 0 -> 142 bytes .../api/da/vnda/vndafuture/vndafuture.vcxproj | 169 +++ .../vndafuture/vndafuture.vcxproj.filters | 45 + .../vnda/vndafuture/vndafuture.vcxproj.user | 4 + vnpy/api/da/vnda/vndamarket/dllmain.cpp | Bin 0 -> 848 bytes vnpy/api/da/vnda/vndamarket/stdafx.cpp | Bin 0 -> 44 bytes vnpy/api/da/vnda/vndamarket/stdafx.h | Bin 0 -> 480 bytes vnpy/api/da/vnda/vndamarket/targetver.h | Bin 0 -> 368 bytes vnpy/api/da/vnda/vndamarket/vndamarket.cpp | Bin 0 -> 24416 bytes vnpy/api/da/vnda/vndamarket/vndamarket.h | 91 ++ .../api/da/vnda/vndamarket/vndamarket.vcxproj | 178 ++++ .../vndamarket/vndamarket.vcxproj.filters | 51 + .../vnda/vndamarket/vndamarket.vcxproj.user | 4 + vnpy/api/da/vnda/vndastock/dllmain.cpp | Bin 0 -> 848 bytes vnpy/api/da/vnda/vndastock/stdafx.cpp | Bin 0 -> 44 bytes vnpy/api/da/vnda/vndastock/stdafx.h | Bin 0 -> 480 bytes vnpy/api/da/vnda/vndastock/targetver.h | Bin 0 -> 368 bytes vnpy/api/da/vnda/vndastock/vndastock.cpp | Bin 0 -> 140 bytes vnpy/api/da/vnda/vndastock/vndastock.vcxproj | 169 +++ .../vnda/vndastock/vndastock.vcxproj.filters | 45 + .../da/vnda/vndastock/vndastock.vcxproj.user | 4 + vnpy/api/da/vndamarket.lib | Bin 0 -> 1784 bytes vnpy/api/da/vndamarket.pyd | Bin 0 -> 680448 bytes 55 files changed, 4769 insertions(+), 127 deletions(-) create mode 100644 vnpy/api/da/generator/da_future_header_function.h create mode 100644 vnpy/api/da/generator/da_future_header_on.h create mode 100644 vnpy/api/da/generator/da_future_source_function.cpp create mode 100644 vnpy/api/da/generator/da_future_source_module.cpp create mode 100644 vnpy/api/da/generator/da_future_source_on.cpp create mode 100644 vnpy/api/da/generator/da_future_source_task.cpp create mode 100644 vnpy/api/da/generator/da_market_header_function.h create mode 100644 vnpy/api/da/generator/da_market_header_on.h create mode 100644 vnpy/api/da/generator/da_market_source_function.cpp create mode 100644 vnpy/api/da/generator/da_market_source_module.cpp create mode 100644 vnpy/api/da/generator/da_market_source_on.cpp create mode 100644 vnpy/api/da/generator/da_market_source_task.cpp create mode 100644 vnpy/api/da/generator/da_stock_header_function.h create mode 100644 vnpy/api/da/generator/da_stock_header_on.h create mode 100644 vnpy/api/da/generator/da_stock_source_function.cpp create mode 100644 vnpy/api/da/generator/da_stock_source_module.cpp create mode 100644 vnpy/api/da/generator/da_stock_source_on.cpp create mode 100644 vnpy/api/da/generator/da_stock_source_task.cpp delete mode 100644 vnpy/api/da/libs/_DAApi_x64.lib create mode 100644 vnpy/api/da/vnda/vnda.h create mode 100644 vnpy/api/da/vnda/vnda.sln create mode 100644 vnpy/api/da/vnda/vndafuture/dllmain.cpp create mode 100644 vnpy/api/da/vnda/vndafuture/stdafx.cpp create mode 100644 vnpy/api/da/vnda/vndafuture/stdafx.h create mode 100644 vnpy/api/da/vnda/vndafuture/targetver.h create mode 100644 vnpy/api/da/vnda/vndafuture/vndafuture.cpp create mode 100644 vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj create mode 100644 vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.filters create mode 100644 vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.user create mode 100644 vnpy/api/da/vnda/vndamarket/dllmain.cpp create mode 100644 vnpy/api/da/vnda/vndamarket/stdafx.cpp create mode 100644 vnpy/api/da/vnda/vndamarket/stdafx.h create mode 100644 vnpy/api/da/vnda/vndamarket/targetver.h create mode 100644 vnpy/api/da/vnda/vndamarket/vndamarket.cpp create mode 100644 vnpy/api/da/vnda/vndamarket/vndamarket.h create mode 100644 vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj create mode 100644 vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.filters create mode 100644 vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.user create mode 100644 vnpy/api/da/vnda/vndastock/dllmain.cpp create mode 100644 vnpy/api/da/vnda/vndastock/stdafx.cpp create mode 100644 vnpy/api/da/vnda/vndastock/stdafx.h create mode 100644 vnpy/api/da/vnda/vndastock/targetver.h create mode 100644 vnpy/api/da/vnda/vndastock/vndastock.cpp create mode 100644 vnpy/api/da/vnda/vndastock/vndastock.vcxproj create mode 100644 vnpy/api/da/vnda/vndastock/vndastock.vcxproj.filters create mode 100644 vnpy/api/da/vnda/vndastock/vndastock.vcxproj.user create mode 100644 vnpy/api/da/vndamarket.lib create mode 100644 vnpy/api/da/vndamarket.pyd diff --git a/vnpy/api/ctp/generator/generate_api_functions.py b/vnpy/api/ctp/generator/generate_api_functions.py index d9dbe612..17fa7e26 100644 --- a/vnpy/api/ctp/generator/generate_api_functions.py +++ b/vnpy/api/ctp/generator/generate_api_functions.py @@ -122,6 +122,8 @@ class ApiGenerator: args_list.append("int reqid") elif type_ == "bool": args_list.append("bool last") + elif type_ == "char*": + args_list.append("string data") elif type_ == "CThostFtdcRspInfoField": args_list.append("const dict &error") else: diff --git a/vnpy/api/da/generator/da_future_header_function.h b/vnpy/api/da/generator/da_future_header_function.h new file mode 100644 index 00000000..f7da8bc4 --- /dev/null +++ b/vnpy/api/da/generator/da_future_header_function.h @@ -0,0 +1,48 @@ +int reqUserLogin(const dict &req, int reqid); + +int reqUserLogout(const dict &req, int reqid); + +int reqSafeVerify(const dict &req, int reqid); + +int reqVerifyCode(const dict &req, int reqid); + +int reqSetVerifyQA(const dict &req, int reqid); + +int reqGetQuestion(const dict &req, int reqid); + +int reqOrderInsert(const dict &req, int reqid); + +int reqOrderModify(const dict &req, int reqid); + +int reqOrderCancel(const dict &req, int reqid); + +int reqPasswordUpdate(const dict &req, int reqid); + +int reqQryOrder(const dict &req, int reqid); + +int reqQryTrade(const dict &req, int reqid); + +int reqQryCapital(const dict &req, int reqid); + +int reqQryVersion(const dict &req, int reqid); + +int reqQryCurrency(const dict &req, int reqid); + +int reqQryExchange(const dict &req, int reqid); + +int reqQryPosition(const dict &req, int reqid); + +int reqQryStrategy(const dict &req, int reqid); + +int reqQryCommodity(const dict &req, int reqid); + +int reqQryInstrument(const dict &req, int reqid); + +int reqQryExchangeTime(const dict &req, int reqid); + +int reqQryCommodityTime(const dict &req, int reqid); + +int reqQryTotalPosition(const dict &req, int reqid); + +int reqQryStrategyDetail(const dict &req, int reqid); + diff --git a/vnpy/api/da/generator/da_future_header_on.h b/vnpy/api/da/generator/da_future_header_on.h new file mode 100644 index 00000000..ca7f64c3 --- /dev/null +++ b/vnpy/api/da/generator/da_future_header_on.h @@ -0,0 +1,66 @@ +virtual void onFrontConnected() {}; + +virtual void onFrontDisconnected(int reqid) {}; + +virtual void onHeartBeatWarning(int reqid) {}; + +virtual void onRspNeedVerify(bool last, bool last) {}; + +virtual void onRspUserLogin(const dict &data, int reqid, bool last) {}; + +virtual void onRspUserLogout(const dict &data, int reqid, bool last) {}; + +virtual void onRspVerifyCode(const dict &data, int reqid, bool last) {}; + +virtual void onRspSafeVerify(const dict &data, int reqid, bool last) {}; + +virtual void onRspSetVerifyQA(const dict &data, int reqid, bool last) {}; + +virtual void onRspAccount(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQuestion(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspOrderInsert(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspOrderModify(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspOrderCancel(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspPasswordUpdate(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRtnTrade(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRtnOrder(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRtnCapital(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRtnPosition(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryOrder(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryTrade(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryCapital(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryVersion(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryPosition(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryCurrency(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryExchange(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryStrategy(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryCommodity(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryInstrument(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryExchangeTime(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryCommodityTime(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryTotalPosition(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryStrategyDetail(const dict &data, const dict &data, int reqid, bool last) {}; + diff --git a/vnpy/api/da/generator/da_future_source_function.cpp b/vnpy/api/da/generator/da_future_source_function.cpp new file mode 100644 index 00000000..58d39a63 --- /dev/null +++ b/vnpy/api/da/generator/da_future_source_function.cpp @@ -0,0 +1,340 @@ +int FutureApi::reqUserLogin(const dict &req, int reqid) +{ + CFutureReqUserLoginField myreq = CFutureReqUserLoginField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "UserType", myreq.UserType); + getString(req, "MacAddress", myreq.MacAddress); + getString(req, "ComputerName", myreq.ComputerName); + getString(req, "SoftwareName", myreq.SoftwareName); + getString(req, "SoftwareVersion", myreq.SoftwareVersion); + getString(req, "AuthorCode", myreq.AuthorCode); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqUserLogin(&myreq, reqid); + return i; +}; + +int FutureApi::reqUserLogout(const dict &req, int reqid) +{ + CFutureReqUserLogoutField myreq = CFutureReqUserLogoutField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqUserLogout(&myreq, reqid); + return i; +}; + +int FutureApi::reqSafeVerify(const dict &req, int reqid) +{ + CFutureReqSafeVerifyField myreq = CFutureReqSafeVerifyField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "Type", myreq.Type); + getString(req, "Question", myreq.Question); + getString(req, "Answer", myreq.Answer); + getString(req, "MobileNumber", myreq.MobileNumber); + getString(req, "VerifyCode", myreq.VerifyCode); + getString(req, "SaveMac", myreq.SaveMac); + getString(req, "MacAddress", myreq.MacAddress); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqSafeVerify(&myreq, reqid); + return i; +}; + +int FutureApi::reqVerifyCode(const dict &req, int reqid) +{ + CFutureReqVerifyCodeField myreq = CFutureReqVerifyCodeField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "Type", myreq.Type); + getString(req, "Question", myreq.Question); + getString(req, "Answer", myreq.Answer); + getString(req, "MobileNumber", myreq.MobileNumber); + getString(req, "VerifyCode", myreq.VerifyCode); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqVerifyCode(&myreq, reqid); + return i; +}; + +int FutureApi::reqSetVerifyQA(const dict &req, int reqid) +{ + CFutureReqSetVerifyQAField myreq = CFutureReqSetVerifyQAField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "Type", myreq.Type); + getString(req, "Question", myreq.Question); + getString(req, "Answer", myreq.Answer); + getString(req, "MobileNumber", myreq.MobileNumber); + getString(req, "VerifyCode", myreq.VerifyCode); + getString(req, "SaveMac", myreq.SaveMac); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqSetVerifyQA(&myreq, reqid); + return i; +}; + +int FutureApi::reqGetQuestion(const dict &req, int reqid) +{ + CFutureReqGetQuestionField myreq = CFutureReqGetQuestionField(); + memset(&myreq, 0, sizeof(myreq)); + getInt(req, "Unused", &myreq.Unused); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqGetQuestion(&myreq, reqid); + return i; +}; + +int FutureApi::reqOrderInsert(const dict &req, int reqid) +{ + CFutureReqOrderInsertField myreq = CFutureReqOrderInsertField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserType", myreq.UserType); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "LocalNo", myreq.LocalNo); + getString(req, "TradePwd", myreq.TradePwd); + getString(req, "IsRiskOrder", myreq.IsRiskOrder); + getString(req, "ExchangeCode", myreq.ExchangeCode); + getString(req, "TreatyCode", myreq.TreatyCode); + getString(req, "BuySale", myreq.BuySale); + getString(req, "AddReduce", myreq.AddReduce); + getString(req, "OrderNumber", myreq.OrderNumber); + getString(req, "OrderPrice", myreq.OrderPrice); + getString(req, "TradeType", myreq.TradeType); + getString(req, "PriceType", myreq.PriceType); + getString(req, "HtsType", myreq.HtsType); + getString(req, "ForceID", myreq.ForceID); + getString(req, "TriggerPrice", myreq.TriggerPrice); + getString(req, "ValidDate", myreq.ValidDate); + getString(req, "StrategyId", myreq.StrategyId); + getString(req, "MaxShow", myreq.MaxShow); + getString(req, "MinQty", myreq.MinQty); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqOrderInsert(&myreq, reqid); + return i; +}; + +int FutureApi::reqOrderModify(const dict &req, int reqid) +{ + CFutureReqOrderModifyField myreq = CFutureReqOrderModifyField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "SystemNo", myreq.SystemNo); + getString(req, "UserId", myreq.UserId); + getString(req, "UserType", myreq.UserType); + getString(req, "LocalNo", myreq.LocalNo); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "TradePwd", myreq.TradePwd); + getString(req, "OrderNo", myreq.OrderNo); + getString(req, "ExchangeCode", myreq.ExchangeCode); + getString(req, "TreatyCode", myreq.TreatyCode); + getString(req, "BuySale", myreq.BuySale); + getString(req, "OrderNumber", myreq.OrderNumber); + getString(req, "OrderPrice", myreq.OrderPrice); + getString(req, "FilledNumber", myreq.FilledNumber); + getString(req, "ModifyNumber", myreq.ModifyNumber); + getString(req, "ModifyPrice", myreq.ModifyPrice); + getString(req, "TradeType", myreq.TradeType); + getString(req, "PriceType", myreq.PriceType); + getString(req, "IsRiskOrder", myreq.IsRiskOrder); + getString(req, "TriggerPrice", myreq.TriggerPrice); + getString(req, "ModifyTriggerPrice", myreq.ModifyTriggerPrice); + getString(req, "ValidDate", myreq.ValidDate); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqOrderModify(&myreq, reqid); + return i; +}; + +int FutureApi::reqOrderCancel(const dict &req, int reqid) +{ + CFutureReqOrderCancelField myreq = CFutureReqOrderCancelField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserType", myreq.UserType); + getString(req, "LocalNo", myreq.LocalNo); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "TradePwd", myreq.TradePwd); + getString(req, "IsSimulation", myreq.IsSimulation); + getString(req, "SystemNo", myreq.SystemNo); + getString(req, "OrderNo", myreq.OrderNo); + getString(req, "ExchangeCode", myreq.ExchangeCode); + getString(req, "TreatyCode", myreq.TreatyCode); + getString(req, "BuySale", myreq.BuySale); + getString(req, "OrderNumber", myreq.OrderNumber); + getString(req, "OrderPrice", myreq.OrderPrice); + getString(req, "FilledNumber", myreq.FilledNumber); + getString(req, "TradeType", myreq.TradeType); + getString(req, "PriceType", myreq.PriceType); + getString(req, "HtsType", myreq.HtsType); + getString(req, "IsRiskOrder", myreq.IsRiskOrder); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqOrderCancel(&myreq, reqid); + return i; +}; + +int FutureApi::reqPasswordUpdate(const dict &req, int reqid) +{ + CFutureReqPasswordUpdateField myreq = CFutureReqPasswordUpdateField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "OldPassword", myreq.OldPassword); + getString(req, "NewPassword", myreq.NewPassword); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqPasswordUpdate(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryOrder(const dict &req, int reqid) +{ + CFutureQryOrderField myreq = CFutureQryOrderField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserType", myreq.UserType); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "TradePwd", myreq.TradePwd); + getString(req, "IsSimulation", myreq.IsSimulation); + getString(req, "OrderNo", myreq.OrderNo); + getString(req, "OrderDateTime", myreq.OrderDateTime); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryOrder(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryTrade(const dict &req, int reqid) +{ + CFutureQryTradeField myreq = CFutureQryTradeField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryTrade(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryCapital(const dict &req, int reqid) +{ + CFutureQryCapitalField myreq = CFutureQryCapitalField(); + memset(&myreq, 0, sizeof(myreq)); + getChar(req, "Unused", &myreq.Unused); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryCapital(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryVersion(const dict &req, int reqid) +{ + CFutureQryVersionField myreq = CFutureQryVersionField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryVersion(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryCurrency(const dict &req, int reqid) +{ + CFutureQryCurrencyField myreq = CFutureQryCurrencyField(); + memset(&myreq, 0, sizeof(myreq)); + getChar(req, "Unused", &myreq.Unused); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryCurrency(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryExchange(const dict &req, int reqid) +{ + CFutureQryExchangeField myreq = CFutureQryExchangeField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "ProductGroupID", myreq.ProductGroupID); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryExchange(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryPosition(const dict &req, int reqid) +{ + CFutureQryPositionField myreq = CFutureQryPositionField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryPosition(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryStrategy(const dict &req, int reqid) +{ + CFutureQryStrategyField myreq = CFutureQryStrategyField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "ExchangeNo", myreq.ExchangeNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryStrategy(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryCommodity(const dict &req, int reqid) +{ + CFutureQryCommodityField myreq = CFutureQryCommodityField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UpdateDate", myreq.UpdateDate); + getString(req, "ExchangeNo", myreq.ExchangeNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryCommodity(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryInstrument(const dict &req, int reqid) +{ + CFutureQryInstrumentField myreq = CFutureQryInstrumentField(); + memset(&myreq, 0, sizeof(myreq)); + getInt(req, "PageIndex", &myreq.PageIndex); + getString(req, "ExchangeNo", myreq.ExchangeNo); + getString(req, "CommodityNo", myreq.CommodityNo); + getString(req, "CommodityType", myreq.CommodityType); + getString(req, "ContractNo", myreq.ContractNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryInstrument(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryExchangeTime(const dict &req, int reqid) +{ + CFutureQryExchangeTimeField myreq = CFutureQryExchangeTimeField(); + memset(&myreq, 0, sizeof(myreq)); + getChar(req, "Unused", &myreq.Unused); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryExchangeTime(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryCommodityTime(const dict &req, int reqid) +{ + CFutureQryCommodityTimeField myreq = CFutureQryCommodityTimeField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "ExchangeNo", myreq.ExchangeNo); + getString(req, "CommodityNo", myreq.CommodityNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryCommodityTime(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryTotalPosition(const dict &req, int reqid) +{ + CFutureQryTotalPositionField myreq = CFutureQryTotalPositionField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryTotalPosition(&myreq, reqid); + return i; +}; + +int FutureApi::reqQryStrategyDetail(const dict &req, int reqid) +{ + CFutureQryStrategyDetailField myreq = CFutureQryStrategyDetailField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "StartegyCommodityNo", myreq.StartegyCommodityNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryStrategyDetail(&myreq, reqid); + return i; +}; + diff --git a/vnpy/api/da/generator/da_future_source_module.cpp b/vnpy/api/da/generator/da_future_source_module.cpp new file mode 100644 index 00000000..fea5fa0a --- /dev/null +++ b/vnpy/api/da/generator/da_future_source_module.cpp @@ -0,0 +1,59 @@ +.def("reqUserLogin", &FutureApi::reqUserLogin) +.def("reqUserLogout", &FutureApi::reqUserLogout) +.def("reqSafeVerify", &FutureApi::reqSafeVerify) +.def("reqVerifyCode", &FutureApi::reqVerifyCode) +.def("reqSetVerifyQA", &FutureApi::reqSetVerifyQA) +.def("reqGetQuestion", &FutureApi::reqGetQuestion) +.def("reqOrderInsert", &FutureApi::reqOrderInsert) +.def("reqOrderModify", &FutureApi::reqOrderModify) +.def("reqOrderCancel", &FutureApi::reqOrderCancel) +.def("reqPasswordUpdate", &FutureApi::reqPasswordUpdate) +.def("reqQryOrder", &FutureApi::reqQryOrder) +.def("reqQryTrade", &FutureApi::reqQryTrade) +.def("reqQryCapital", &FutureApi::reqQryCapital) +.def("reqQryVersion", &FutureApi::reqQryVersion) +.def("reqQryCurrency", &FutureApi::reqQryCurrency) +.def("reqQryExchange", &FutureApi::reqQryExchange) +.def("reqQryPosition", &FutureApi::reqQryPosition) +.def("reqQryStrategy", &FutureApi::reqQryStrategy) +.def("reqQryCommodity", &FutureApi::reqQryCommodity) +.def("reqQryInstrument", &FutureApi::reqQryInstrument) +.def("reqQryExchangeTime", &FutureApi::reqQryExchangeTime) +.def("reqQryCommodityTime", &FutureApi::reqQryCommodityTime) +.def("reqQryTotalPosition", &FutureApi::reqQryTotalPosition) +.def("reqQryStrategyDetail", &FutureApi::reqQryStrategyDetail) + +.def("onFrontConnected", &FutureApi::onFrontConnected) +.def("onFrontDisconnected", &FutureApi::onFrontDisconnected) +.def("onHeartBeatWarning", &FutureApi::onHeartBeatWarning) +.def("onRspNeedVerify", &FutureApi::onRspNeedVerify) +.def("onRspUserLogin", &FutureApi::onRspUserLogin) +.def("onRspUserLogout", &FutureApi::onRspUserLogout) +.def("onRspVerifyCode", &FutureApi::onRspVerifyCode) +.def("onRspSafeVerify", &FutureApi::onRspSafeVerify) +.def("onRspSetVerifyQA", &FutureApi::onRspSetVerifyQA) +.def("onRspAccount", &FutureApi::onRspAccount) +.def("onRspQuestion", &FutureApi::onRspQuestion) +.def("onRspOrderInsert", &FutureApi::onRspOrderInsert) +.def("onRspOrderModify", &FutureApi::onRspOrderModify) +.def("onRspOrderCancel", &FutureApi::onRspOrderCancel) +.def("onRspPasswordUpdate", &FutureApi::onRspPasswordUpdate) +.def("onRtnTrade", &FutureApi::onRtnTrade) +.def("onRtnOrder", &FutureApi::onRtnOrder) +.def("onRtnCapital", &FutureApi::onRtnCapital) +.def("onRtnPosition", &FutureApi::onRtnPosition) +.def("onRspQryOrder", &FutureApi::onRspQryOrder) +.def("onRspQryTrade", &FutureApi::onRspQryTrade) +.def("onRspQryCapital", &FutureApi::onRspQryCapital) +.def("onRspQryVersion", &FutureApi::onRspQryVersion) +.def("onRspQryPosition", &FutureApi::onRspQryPosition) +.def("onRspQryCurrency", &FutureApi::onRspQryCurrency) +.def("onRspQryExchange", &FutureApi::onRspQryExchange) +.def("onRspQryStrategy", &FutureApi::onRspQryStrategy) +.def("onRspQryCommodity", &FutureApi::onRspQryCommodity) +.def("onRspQryInstrument", &FutureApi::onRspQryInstrument) +.def("onRspQryExchangeTime", &FutureApi::onRspQryExchangeTime) +.def("onRspQryCommodityTime", &FutureApi::onRspQryCommodityTime) +.def("onRspQryTotalPosition", &FutureApi::onRspQryTotalPosition) +.def("onRspQryStrategyDetail", &FutureApi::onRspQryStrategyDetail) +; diff --git a/vnpy/api/da/generator/da_future_source_on.cpp b/vnpy/api/da/generator/da_future_source_on.cpp new file mode 100644 index 00000000..fe02fbcf --- /dev/null +++ b/vnpy/api/da/generator/da_future_source_on.cpp @@ -0,0 +1,396 @@ +void onFrontConnected() override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onFrontConnected); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onFrontDisconnected(int reqid) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onFrontDisconnected, reqid); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onHeartBeatWarning(int reqid) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onHeartBeatWarning, reqid); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspNeedVerify(bool last, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspNeedVerify, last, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspUserLogin(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspUserLogin, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspUserLogout(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspUserLogout, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspVerifyCode(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspVerifyCode, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspSafeVerify(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspSafeVerify, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspSetVerifyQA(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspSetVerifyQA, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspAccount(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspAccount, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQuestion(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQuestion, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspOrderInsert(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspOrderInsert, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspOrderModify(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspOrderModify, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspOrderCancel(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspOrderCancel, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspPasswordUpdate(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspPasswordUpdate, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRtnTrade(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRtnTrade, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRtnOrder(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRtnOrder, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRtnCapital(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRtnCapital, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRtnPosition(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRtnPosition, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryOrder(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryOrder, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryTrade(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryTrade, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryCapital(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryCapital, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryVersion(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryVersion, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryPosition(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryPosition, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryCurrency(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryCurrency, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryExchange(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryExchange, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryStrategy(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryStrategy, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryCommodity(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryCommodity, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryInstrument(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryInstrument, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryExchangeTime(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryExchangeTime, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryCommodityTime(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryCommodityTime, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryTotalPosition(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryTotalPosition, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryStrategyDetail(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, FutureApi, onRspQryStrategyDetail, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + diff --git a/vnpy/api/da/generator/da_future_source_task.cpp b/vnpy/api/da/generator/da_future_source_task.cpp new file mode 100644 index 00000000..19e3d6b0 --- /dev/null +++ b/vnpy/api/da/generator/da_future_source_task.cpp @@ -0,0 +1,992 @@ +void FutureApi::OnFrontConnected() +{ + gil_scoped_acquire acquire; + this->onFrontConnected(); +}; + +void FutureApi::OnFrontDisconnected(int iReason) +{ + gil_scoped_acquire acquire; + this->onFrontDisconnected(iReason); +}; + +void FutureApi::OnHeartBeatWarning(int iTimeLapse) +{ + gil_scoped_acquire acquire; + this->onHeartBeatWarning(iTimeLapse); +}; + +void FutureApi::OnRspNeedVerify(bool bFirstLogin, bool bHasSetQA) +{ + gil_scoped_acquire acquire; + this->onRspNeedVerify(bFirstLogin, bHasSetQA); +}; + +void FutureApi::OnRspUserLogin(CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspUserLogin(data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspUserLogout(CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspUserLogout(data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspVerifyCode(CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspVerifyCode(data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspSafeVerify(CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspSafeVerify(data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspSetVerifyQA(CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspSetVerifyQA(data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspAccount(CFutureRspAccountField *pRspAccount, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspAccount) + { + data["UserId"] = toUtf(pRspAccount->UserId); + data["UserName"] = toUtf(pRspAccount->UserName); + data["UserType"] = toUtf(pRspAccount->UserType); + data["LoginPwd"] = toUtf(pRspAccount->LoginPwd); + data["AccountNo"] = toUtf(pRspAccount->AccountNo); + data["TradePwd"] = toUtf(pRspAccount->TradePwd); + data["IsSimulation"] = toUtf(pRspAccount->IsSimulation); + data["FrontendIp"] = toUtf(pRspAccount->FrontendIp); + data["FrontendPort"] = toUtf(pRspAccount->FrontendPort); + data["CurrencyNo"] = toUtf(pRspAccount->CurrencyNo); + data["UserState"] = toUtf(pRspAccount->UserState); + data["SelAll"] = toUtf(pRspAccount->SelAll); + data["Strategy"] = toUtf(pRspAccount->Strategy); + data["Inner"] = toUtf(pRspAccount->Inner); + data["YingSun"] = toUtf(pRspAccount->YingSun); + data["ChaoDan"] = toUtf(pRspAccount->ChaoDan); + data["Option"] = toUtf(pRspAccount->Option); + data["CmeMarket"] = toUtf(pRspAccount->CmeMarket); + data["CmeCOMEXMarket"] = toUtf(pRspAccount->CmeCOMEXMarket); + data["CmeNYMEXMarket"] = toUtf(pRspAccount->CmeNYMEXMarket); + data["CmeCBTMarket"] = toUtf(pRspAccount->CmeCBTMarket); + data["IceUSMarket"] = toUtf(pRspAccount->IceUSMarket); + data["IceECMarket"] = toUtf(pRspAccount->IceECMarket); + data["IceEFMarket"] = toUtf(pRspAccount->IceEFMarket); + data["CanTradeStockHK"] = toUtf(pRspAccount->CanTradeStockHK); + data["CanTradeStockAM"] = toUtf(pRspAccount->CanTradeStockAM); + data["MultiLogin"] = toUtf(pRspAccount->MultiLogin); + data["SellStockHK"] = toUtf(pRspAccount->SellStockHK); + data["SellStockAM"] = toUtf(pRspAccount->SellStockAM); + data["CanTradeStockKRX"] = toUtf(pRspAccount->CanTradeStockKRX); + data["HkexMarket"] = toUtf(pRspAccount->HkexMarket); + data["IdNumber"] = toUtf(pRspAccount->IdNumber); + data["HkexMarketFee"] = toUtf(pRspAccount->HkexMarketFee); + data["IsProfessional"] = toUtf(pRspAccount->IsProfessional); + data["IsOverSea"] = toUtf(pRspAccount->IsOverSea); + data["IsFirstLogin"] = toUtf(pRspAccount->IsFirstLogin); + data["UserMobile"] = toUtf(pRspAccount->UserMobile); + data["HasSetQA"] = toUtf(pRspAccount->HasSetQA); + data["CanTradeStockSGXQ"] = toUtf(pRspAccount->CanTradeStockSGXQ); + data["ExistMac"] = toUtf(pRspAccount->ExistMac); + data["RatioINE"] = toUtf(pRspAccount->RatioINE); + data["EurexMarket"] = toUtf(pRspAccount->EurexMarket); + data["HkexIsOverMaxTerminal"] = toUtf(pRspAccount->HkexIsOverMaxTerminal); + data["HkexOverMoney"] = toUtf(pRspAccount->HkexOverMoney); + data["CanTradeStockAU"] = toUtf(pRspAccount->CanTradeStockAU); + data["NyFlag"] = toUtf(pRspAccount->NyFlag); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspAccount(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQuestion(CFutureRspQuestionField *pRspVersion, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspVersion) + { + data["QuestionType"] = toUtf(pRspVersion->QuestionType); + data["QuestionId"] = toUtf(pRspVersion->QuestionId); + data["QuestionCN"] = toUtf(pRspVersion->QuestionCN); + data["QuestionEN"] = toUtf(pRspVersion->QuestionEN); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQuestion(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspOrderInsert(CFutureRspOrderInsertField *pRspOrderInsert, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspOrderInsert) + { + data["UserId"] = toUtf(pRspOrderInsert->UserId); + data["AccountNo"] = toUtf(pRspOrderInsert->AccountNo); + data["SystemNo"] = toUtf(pRspOrderInsert->SystemNo); + data["LocalNo"] = toUtf(pRspOrderInsert->LocalNo); + data["OrderNo"] = toUtf(pRspOrderInsert->OrderNo); + data["OrigOrderNo"] = toUtf(pRspOrderInsert->OrigOrderNo); + data["OrderMethod"] = toUtf(pRspOrderInsert->OrderMethod); + data["AcceptType"] = toUtf(pRspOrderInsert->AcceptType); + data["ExchangeCode"] = toUtf(pRspOrderInsert->ExchangeCode); + data["TreatyCode"] = toUtf(pRspOrderInsert->TreatyCode); + data["BuySale"] = toUtf(pRspOrderInsert->BuySale); + data["OrderNumber"] = toUtf(pRspOrderInsert->OrderNumber); + data["OrderPrice"] = toUtf(pRspOrderInsert->OrderPrice); + data["FilledNumber"] = toUtf(pRspOrderInsert->FilledNumber); + data["FilledPrice"] = toUtf(pRspOrderInsert->FilledPrice); + data["TradeType"] = toUtf(pRspOrderInsert->TradeType); + data["PriceType"] = toUtf(pRspOrderInsert->PriceType); + data["HtsType"] = toUtf(pRspOrderInsert->HtsType); + data["OrderDate"] = toUtf(pRspOrderInsert->OrderDate); + data["OrderTime"] = toUtf(pRspOrderInsert->OrderTime); + data["ErrorCode"] = toUtf(pRspOrderInsert->ErrorCode); + data["OrderState"] = toUtf(pRspOrderInsert->OrderState); + data["IsRiskOrder"] = toUtf(pRspOrderInsert->IsRiskOrder); + data["CancelUserId"] = toUtf(pRspOrderInsert->CancelUserId); + data["TriggerPrice"] = toUtf(pRspOrderInsert->TriggerPrice); + data["ValidDate"] = toUtf(pRspOrderInsert->ValidDate); + data["AddReduce"] = toUtf(pRspOrderInsert->AddReduce); + data["StrategyId"] = toUtf(pRspOrderInsert->StrategyId); + data["MaxShow"] = toUtf(pRspOrderInsert->MaxShow); + data["MinQty"] = toUtf(pRspOrderInsert->MinQty); + data["ExchangeTime"] = toUtf(pRspOrderInsert->ExchangeTime); + data["CancelTime"] = toUtf(pRspOrderInsert->CancelTime); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspOrderInsert(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspOrderModify(CFutureRspOrderModifyField *pRspOrderModify, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspOrderModify) + { + data["UserId"] = toUtf(pRspOrderModify->UserId); + data["AccountNo"] = toUtf(pRspOrderModify->AccountNo); + data["SystemNo"] = toUtf(pRspOrderModify->SystemNo); + data["LocalNo"] = toUtf(pRspOrderModify->LocalNo); + data["OrderNo"] = toUtf(pRspOrderModify->OrderNo); + data["OrigOrderNo"] = toUtf(pRspOrderModify->OrigOrderNo); + data["OrderMethod"] = toUtf(pRspOrderModify->OrderMethod); + data["AcceptType"] = toUtf(pRspOrderModify->AcceptType); + data["ExchangeCode"] = toUtf(pRspOrderModify->ExchangeCode); + data["TreatyCode"] = toUtf(pRspOrderModify->TreatyCode); + data["BuySale"] = toUtf(pRspOrderModify->BuySale); + data["OrderNumber"] = toUtf(pRspOrderModify->OrderNumber); + data["OrderPrice"] = toUtf(pRspOrderModify->OrderPrice); + data["FilledNumber"] = toUtf(pRspOrderModify->FilledNumber); + data["FilledPrice"] = toUtf(pRspOrderModify->FilledPrice); + data["TradeType"] = toUtf(pRspOrderModify->TradeType); + data["PriceType"] = toUtf(pRspOrderModify->PriceType); + data["HtsType"] = toUtf(pRspOrderModify->HtsType); + data["OrderDate"] = toUtf(pRspOrderModify->OrderDate); + data["OrderTime"] = toUtf(pRspOrderModify->OrderTime); + data["ErrorCode"] = toUtf(pRspOrderModify->ErrorCode); + data["OrderState"] = toUtf(pRspOrderModify->OrderState); + data["IsRiskOrder"] = toUtf(pRspOrderModify->IsRiskOrder); + data["CancelUserId"] = toUtf(pRspOrderModify->CancelUserId); + data["TriggerPrice"] = toUtf(pRspOrderModify->TriggerPrice); + data["ValidDate"] = toUtf(pRspOrderModify->ValidDate); + data["AddReduce"] = toUtf(pRspOrderModify->AddReduce); + data["StrategyId"] = toUtf(pRspOrderModify->StrategyId); + data["MaxShow"] = toUtf(pRspOrderModify->MaxShow); + data["MinQty"] = toUtf(pRspOrderModify->MinQty); + data["ExchangeTime"] = toUtf(pRspOrderModify->ExchangeTime); + data["CancelTime"] = toUtf(pRspOrderModify->CancelTime); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspOrderModify(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspOrderCancel(CFutureRspOrderCancelField *pRspOrderCancel, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspOrderCancel) + { + data["UserId"] = toUtf(pRspOrderCancel->UserId); + data["AccountNo"] = toUtf(pRspOrderCancel->AccountNo); + data["SystemNo"] = toUtf(pRspOrderCancel->SystemNo); + data["LocalNo"] = toUtf(pRspOrderCancel->LocalNo); + data["OrderNo"] = toUtf(pRspOrderCancel->OrderNo); + data["CancelNo"] = toUtf(pRspOrderCancel->CancelNo); + data["ExchangeCode"] = toUtf(pRspOrderCancel->ExchangeCode); + data["TreatyCode"] = toUtf(pRspOrderCancel->TreatyCode); + data["BuySale"] = toUtf(pRspOrderCancel->BuySale); + data["OrderNumber"] = toUtf(pRspOrderCancel->OrderNumber); + data["OrderPrice"] = toUtf(pRspOrderCancel->OrderPrice); + data["FilledNumber"] = toUtf(pRspOrderCancel->FilledNumber); + data["CancelNumber"] = toUtf(pRspOrderCancel->CancelNumber); + data["TradeType"] = toUtf(pRspOrderCancel->TradeType); + data["PriceType"] = toUtf(pRspOrderCancel->PriceType); + data["HtsType"] = toUtf(pRspOrderCancel->HtsType); + data["CancelDate"] = toUtf(pRspOrderCancel->CancelDate); + data["CancelTime"] = toUtf(pRspOrderCancel->CancelTime); + data["ErrorCode"] = toUtf(pRspOrderCancel->ErrorCode); + data["IsRiskOrder"] = toUtf(pRspOrderCancel->IsRiskOrder); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspOrderCancel(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspPasswordUpdate(CFutureRspPasswordUpdateField *pRspPasswordUpdate, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspPasswordUpdate) + { + data["UserId"] = toUtf(pRspPasswordUpdate->UserId); + data["OldPassword"] = toUtf(pRspPasswordUpdate->OldPassword); + data["NewPassword"] = toUtf(pRspPasswordUpdate->NewPassword); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspPasswordUpdate(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRtnTrade(CFutureRtnTradeField *pRtnTrade, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRtnTrade) + { + data["UserId"] = toUtf(pRtnTrade->UserId); + data["AccountNo"] = toUtf(pRtnTrade->AccountNo); + data["FilledNo"] = toUtf(pRtnTrade->FilledNo); + data["OrderNo"] = toUtf(pRtnTrade->OrderNo); + data["SystemNo"] = toUtf(pRtnTrade->SystemNo); + data["LocalNo"] = toUtf(pRtnTrade->LocalNo); + data["ExchangeCode"] = toUtf(pRtnTrade->ExchangeCode); + data["TreatyCode"] = toUtf(pRtnTrade->TreatyCode); + data["BuySale"] = toUtf(pRtnTrade->BuySale); + data["FilledNumber"] = toUtf(pRtnTrade->FilledNumber); + data["FilledPrice"] = toUtf(pRtnTrade->FilledPrice); + data["FilledDate"] = toUtf(pRtnTrade->FilledDate); + data["FilledTime"] = toUtf(pRtnTrade->FilledTime); + data["Commsion"] = toUtf(pRtnTrade->Commsion); + data["OrderNumber"] = toUtf(pRtnTrade->OrderNumber); + data["OrderPrice"] = toUtf(pRtnTrade->OrderPrice); + data["DeliveryDate"] = toUtf(pRtnTrade->DeliveryDate); + data["FilledType"] = toUtf(pRtnTrade->FilledType); + data["OrderType"] = toUtf(pRtnTrade->OrderType); + data["ValidDate"] = toUtf(pRtnTrade->ValidDate); + data["AddReduce"] = toUtf(pRtnTrade->AddReduce); + data["ErrorDescription"] = toUtf(pRtnTrade->ErrorDescription); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRtnTrade(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRtnOrder(CFutureRtnOrderField *pRtnOrder, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRtnOrder) + { + data["LocalOrderNo"] = toUtf(pRtnOrder->LocalOrderNo); + data["ExchangeNo"] = toUtf(pRtnOrder->ExchangeNo); + data["TreatyCode"] = toUtf(pRtnOrder->TreatyCode); + data["OrderNo"] = toUtf(pRtnOrder->OrderNo); + data["OrderNumber"] = pRtnOrder->OrderNumber; + data["FilledNumber"] = pRtnOrder->FilledNumber; + data["FilledAdvPrice"] = pRtnOrder->FilledAdvPrice; + data["BuyHoldNumber"] = pRtnOrder->BuyHoldNumber; + data["BuyHoldOpenPrice"] = pRtnOrder->BuyHoldOpenPrice; + data["BuyHoldPrice"] = pRtnOrder->BuyHoldPrice; + data["SaleHoldNumber"] = pRtnOrder->SaleHoldNumber; + data["SaleHoldOpenPrice"] = pRtnOrder->SaleHoldOpenPrice; + data["SaleHoldPrice"] = pRtnOrder->SaleHoldPrice; + data["IsCanceled"] = toUtf(pRtnOrder->IsCanceled); + data["FilledTotalFee"] = pRtnOrder->FilledTotalFee; + data["Status"] = pRtnOrder->Status; + data["AccountNo"] = toUtf(pRtnOrder->AccountNo); + data["HoldType"] = toUtf(pRtnOrder->HoldType); + data["HoldMarginBuy"] = pRtnOrder->HoldMarginBuy; + data["HoldMarginSale"] = pRtnOrder->HoldMarginSale; + data["CurrPrice"] = pRtnOrder->CurrPrice; + data["FloatProfit"] = pRtnOrder->FloatProfit; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRtnOrder(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRtnCapital(CFutureRtnCapitalField *pRtnCapital, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRtnCapital) + { + data["ClientNo"] = toUtf(pRtnCapital->ClientNo); + data["AccountNo"] = toUtf(pRtnCapital->AccountNo); + data["CurrencyNo"] = toUtf(pRtnCapital->CurrencyNo); + data["Available"] = pRtnCapital->Available; + data["YAvailable"] = pRtnCapital->YAvailable; + data["CanCashOut"] = pRtnCapital->CanCashOut; + data["Money"] = pRtnCapital->Money; + data["ExpiredProfit"] = pRtnCapital->ExpiredProfit; + data["FrozenDeposit"] = pRtnCapital->FrozenDeposit; + data["Fee"] = pRtnCapital->Fee; + data["Deposit"] = pRtnCapital->Deposit; + data["KeepDeposit"] = pRtnCapital->KeepDeposit; + data["Status"] = pRtnCapital->Status; + data["InMoney"] = pRtnCapital->InMoney; + data["OutMoney"] = pRtnCapital->OutMoney; + data["UnexpiredProfit"] = pRtnCapital->UnexpiredProfit; + data["TodayTotal"] = pRtnCapital->TodayTotal; + data["UnaccountProfit"] = pRtnCapital->UnaccountProfit; + data["Royalty"] = pRtnCapital->Royalty; + data["ExchangeNo"] = toUtf(pRtnCapital->ExchangeNo); + data["TreatyCode"] = toUtf(pRtnCapital->TreatyCode); + data["OrderNo"] = toUtf(pRtnCapital->OrderNo); + data["OrderNumber"] = pRtnCapital->OrderNumber; + data["FilledNumber"] = pRtnCapital->FilledNumber; + data["FilledAdvPrice"] = pRtnCapital->FilledAdvPrice; + data["BuyHoldNumber"] = pRtnCapital->BuyHoldNumber; + data["BuyHoldOpenPrice"] = pRtnCapital->BuyHoldOpenPrice; + data["BuyHoldPrice"] = pRtnCapital->BuyHoldPrice; + data["SaleHoldNumber"] = pRtnCapital->SaleHoldNumber; + data["SaleHoldOpenPrice"] = pRtnCapital->SaleHoldOpenPrice; + data["SaleHoldPrice"] = pRtnCapital->SaleHoldPrice; + data["IsCanceled"] = toUtf(pRtnCapital->IsCanceled); + data["FilledTotalFee"] = pRtnCapital->FilledTotalFee; + data["Credit"] = pRtnCapital->Credit; + data["MarginLimit"] = pRtnCapital->MarginLimit; + data["BorrowValue"] = pRtnCapital->BorrowValue; + data["MortgageMoney"] = pRtnCapital->MortgageMoney; + data["T1"] = pRtnCapital->T1; + data["T2"] = pRtnCapital->T2; + data["T3"] = pRtnCapital->T3; + data["TN"] = pRtnCapital->TN; + data["TradeLimit"] = pRtnCapital->TradeLimit; + data["FCrossMax"] = pRtnCapital->FCrossMax; + data["SellFreezenMoney"] = pRtnCapital->SellFreezenMoney; + data["SellInterest"] = pRtnCapital->SellInterest; + data["SellNeedAddMargin"] = pRtnCapital->SellNeedAddMargin; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRtnCapital(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRtnPosition(CFutureRtnPositionField *pRtnPosition, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRtnPosition) + { + data["LocalOrderNo"] = toUtf(pRtnPosition->LocalOrderNo); + data["ExchangeNo"] = toUtf(pRtnPosition->ExchangeNo); + data["TreatyCode"] = toUtf(pRtnPosition->TreatyCode); + data["OrderNo"] = toUtf(pRtnPosition->OrderNo); + data["OrderNumber"] = pRtnPosition->OrderNumber; + data["FilledNumber"] = pRtnPosition->FilledNumber; + data["FilledAdvPrice"] = pRtnPosition->FilledAdvPrice; + data["BuyHoldNumber"] = pRtnPosition->BuyHoldNumber; + data["BuyHoldOpenPrice"] = pRtnPosition->BuyHoldOpenPrice; + data["BuyHoldPrice"] = pRtnPosition->BuyHoldPrice; + data["SaleHoldNumber"] = pRtnPosition->SaleHoldNumber; + data["SaleHoldOpenPrice"] = pRtnPosition->SaleHoldOpenPrice; + data["SaleHoldPrice"] = pRtnPosition->SaleHoldPrice; + data["IsCanceled"] = toUtf(pRtnPosition->IsCanceled); + data["FilledTotalFee"] = pRtnPosition->FilledTotalFee; + data["Status"] = pRtnPosition->Status; + data["AccountNo"] = toUtf(pRtnPosition->AccountNo); + data["HoldType"] = toUtf(pRtnPosition->HoldType); + data["HoldMarginBuy"] = pRtnPosition->HoldMarginBuy; + data["HoldMarginSale"] = pRtnPosition->HoldMarginSale; + data["CurrPrice"] = pRtnPosition->CurrPrice; + data["FloatProfit"] = pRtnPosition->FloatProfit; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRtnPosition(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryOrder(CFutureRspOrderField *pRspOrder, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspOrder) + { + data["UserId"] = toUtf(pRspOrder->UserId); + data["AccountNo"] = toUtf(pRspOrder->AccountNo); + data["SystemNo"] = toUtf(pRspOrder->SystemNo); + data["LocalNo"] = toUtf(pRspOrder->LocalNo); + data["OrderNo"] = toUtf(pRspOrder->OrderNo); + data["OrigOrderNo"] = toUtf(pRspOrder->OrigOrderNo); + data["OrderMethod"] = toUtf(pRspOrder->OrderMethod); + data["AcceptType"] = toUtf(pRspOrder->AcceptType); + data["ExchangeCode"] = toUtf(pRspOrder->ExchangeCode); + data["TreatyCode"] = toUtf(pRspOrder->TreatyCode); + data["BuySale"] = toUtf(pRspOrder->BuySale); + data["OrderNumber"] = toUtf(pRspOrder->OrderNumber); + data["OrderPrice"] = toUtf(pRspOrder->OrderPrice); + data["FilledNumber"] = toUtf(pRspOrder->FilledNumber); + data["FilledPrice"] = toUtf(pRspOrder->FilledPrice); + data["TradeType"] = toUtf(pRspOrder->TradeType); + data["PriceType"] = toUtf(pRspOrder->PriceType); + data["HtsType"] = toUtf(pRspOrder->HtsType); + data["OrderDate"] = toUtf(pRspOrder->OrderDate); + data["OrderTime"] = toUtf(pRspOrder->OrderTime); + data["ErrorCode"] = toUtf(pRspOrder->ErrorCode); + data["OrderState"] = toUtf(pRspOrder->OrderState); + data["IsRiskOrder"] = toUtf(pRspOrder->IsRiskOrder); + data["CancelUserId"] = toUtf(pRspOrder->CancelUserId); + data["TriggerPrice"] = toUtf(pRspOrder->TriggerPrice); + data["ValidDate"] = toUtf(pRspOrder->ValidDate); + data["AddReduce"] = toUtf(pRspOrder->AddReduce); + data["StrategyId"] = toUtf(pRspOrder->StrategyId); + data["MaxShow"] = toUtf(pRspOrder->MaxShow); + data["MinQty"] = toUtf(pRspOrder->MinQty); + data["ExchangeTime"] = toUtf(pRspOrder->ExchangeTime); + data["CancelTime"] = toUtf(pRspOrder->CancelTime); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryOrder(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryTrade(CFutureRspTradeField *pRspTrade, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspTrade) + { + data["UserId"] = toUtf(pRspTrade->UserId); + data["AccountNo"] = toUtf(pRspTrade->AccountNo); + data["FilledNo"] = toUtf(pRspTrade->FilledNo); + data["OrderNo"] = toUtf(pRspTrade->OrderNo); + data["SystemNo"] = toUtf(pRspTrade->SystemNo); + data["LocalNo"] = toUtf(pRspTrade->LocalNo); + data["ExchangeCode"] = toUtf(pRspTrade->ExchangeCode); + data["TreatyCode"] = toUtf(pRspTrade->TreatyCode); + data["BuySale"] = toUtf(pRspTrade->BuySale); + data["FilledNumber"] = toUtf(pRspTrade->FilledNumber); + data["FilledPrice"] = toUtf(pRspTrade->FilledPrice); + data["FilledDate"] = toUtf(pRspTrade->FilledDate); + data["FilledTime"] = toUtf(pRspTrade->FilledTime); + data["Commsion"] = toUtf(pRspTrade->Commsion); + data["OrderNumber"] = toUtf(pRspTrade->OrderNumber); + data["OrderPrice"] = toUtf(pRspTrade->OrderPrice); + data["DeliveryDate"] = toUtf(pRspTrade->DeliveryDate); + data["FilledType"] = toUtf(pRspTrade->FilledType); + data["OrderType"] = toUtf(pRspTrade->OrderType); + data["ValidDate"] = toUtf(pRspTrade->ValidDate); + data["AddReduce"] = toUtf(pRspTrade->AddReduce); + data["ErrorDescription"] = toUtf(pRspTrade->ErrorDescription); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryTrade(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryCapital(CFutureRspCapitalField *pRspCapital, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspCapital) + { + data["UserId"] = toUtf(pRspCapital->UserId); + data["InMoney"] = toUtf(pRspCapital->InMoney); + data["OutMoney"] = toUtf(pRspCapital->OutMoney); + data["TodayCanUse"] = toUtf(pRspCapital->TodayCanUse); + data["TodayAmount"] = toUtf(pRspCapital->TodayAmount); + data["TodayBalance"] = toUtf(pRspCapital->TodayBalance); + data["FreezenMoney"] = toUtf(pRspCapital->FreezenMoney); + data["Commission"] = toUtf(pRspCapital->Commission); + data["Margin"] = toUtf(pRspCapital->Margin); + data["OldCanUse"] = toUtf(pRspCapital->OldCanUse); + data["OldAmount"] = toUtf(pRspCapital->OldAmount); + data["OldBalance"] = toUtf(pRspCapital->OldBalance); + data["FloatingProfit"] = toUtf(pRspCapital->FloatingProfit); + data["CurrencyNo"] = toUtf(pRspCapital->CurrencyNo); + data["CurrencyRate"] = pRspCapital->CurrencyRate; + data["UnexpiredProfit"] = pRspCapital->UnexpiredProfit; + data["UnaccountProfit"] = pRspCapital->UnaccountProfit; + data["KeepDeposit"] = pRspCapital->KeepDeposit; + data["Royalty"] = pRspCapital->Royalty; + data["Credit"] = pRspCapital->Credit; + data["AddCapital"] = pRspCapital->AddCapital; + data["IniEquity"] = pRspCapital->IniEquity; + data["AccountNo"] = toUtf(pRspCapital->AccountNo); + data["MortgageMoney"] = pRspCapital->MortgageMoney; + data["MarginLimit"] = pRspCapital->MarginLimit; + data["BorrowValue"] = pRspCapital->BorrowValue; + data["T1"] = pRspCapital->T1; + data["T2"] = pRspCapital->T2; + data["T3"] = pRspCapital->T3; + data["TN"] = pRspCapital->TN; + data["TradeLimit"] = pRspCapital->TradeLimit; + data["CanCashOut"] = pRspCapital->CanCashOut; + data["AccruedCrInt"] = pRspCapital->AccruedCrInt; + data["AccruedDrInt"] = pRspCapital->AccruedDrInt; + data["CrossMax"] = pRspCapital->CrossMax; + data["SellFreezenMoney"] = pRspCapital->SellFreezenMoney; + data["SellInterest"] = pRspCapital->SellInterest; + data["SellNeedAddMargin"] = pRspCapital->SellNeedAddMargin; + data["NetProfit"] = toUtf(pRspCapital->NetProfit); + data["ProfitRate"] = toUtf(pRspCapital->ProfitRate); + data["RiskRate"] = toUtf(pRspCapital->RiskRate); + data["ErrorDescription"] = toUtf(pRspCapital->ErrorDescription); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryCapital(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryVersion(CFutureRspVersionField *pRspVersion, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspVersion) + { + data["Version"] = toUtf(pRspVersion->Version); + data["MustUpdate"] = toUtf(pRspVersion->MustUpdate); + data["MustVersion"] = toUtf(pRspVersion->MustVersion); + data["VersionContent_CN"] = toUtf(pRspVersion->VersionContent_CN); + data["VersionContent_US"] = toUtf(pRspVersion->VersionContent_US); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryVersion(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryPosition(CFutureRspPositionField *pRspPosition, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspPosition) + { + data["MatchDate"] = toUtf(pRspPosition->MatchDate); + data["MatchNo"] = toUtf(pRspPosition->MatchNo); + data["ClientNo"] = toUtf(pRspPosition->ClientNo); + data["ExchangeNo"] = toUtf(pRspPosition->ExchangeNo); + data["CommodityNo"] = toUtf(pRspPosition->CommodityNo); + data["ContractNo"] = toUtf(pRspPosition->ContractNo); + data["Direct"] = toUtf(pRspPosition->Direct); + data["HoldVol"] = pRspPosition->HoldVol; + data["HoldPrice"] = pRspPosition->HoldPrice; + data["CurrencyNo"] = toUtf(pRspPosition->CurrencyNo); + data["ForciblyPrice"] = pRspPosition->ForciblyPrice; + data["Account"] = toUtf(pRspPosition->Account); + data["HoldType"] = toUtf(pRspPosition->HoldType); + data["DeliveryDate"] = toUtf(pRspPosition->DeliveryDate); + data["ExchangeName"] = toUtf(pRspPosition->ExchangeName); + data["CurrencyName"] = toUtf(pRspPosition->CurrencyName); + data["ContCode"] = toUtf(pRspPosition->ContCode); + data["HoldMargin"] = pRspPosition->HoldMargin; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryPosition(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryCurrency(CFutureRspCurrencyField *pRspCurrency, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspCurrency) + { + data["CurrencyNo"] = toUtf(pRspCurrency->CurrencyNo); + data["IsBase"] = pRspCurrency->IsBase; + data["ChangeRate"] = pRspCurrency->ChangeRate; + data["CurrencyName"] = toUtf(pRspCurrency->CurrencyName); + data["CurrencyNameEN"] = toUtf(pRspCurrency->CurrencyNameEN); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryCurrency(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryExchange(CFutureRspExchangeField *pRspExchange, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspExchange) + { + data["ExchangeNo"] = toUtf(pRspExchange->ExchangeNo); + data["ExchangeName"] = toUtf(pRspExchange->ExchangeName); + data["SettleType"] = toUtf(pRspExchange->SettleType); + data["NameEN"] = toUtf(pRspExchange->NameEN); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryExchange(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryStrategy(CFutureRspStrategyField *pRspStrategy, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspStrategy) + { + data["UserId"] = toUtf(pRspStrategy->UserId); + data["KeyId"] = toUtf(pRspStrategy->KeyId); + data["Name"] = toUtf(pRspStrategy->Name); + data["Code"] = toUtf(pRspStrategy->Code); + data["PriceType"] = pRspStrategy->PriceType; + data["PriceTypeDetailType"] = pRspStrategy->PriceTypeDetailType; + data["PriceFormula"] = toUtf(pRspStrategy->PriceFormula); + data["TriggerMethod"] = pRspStrategy->TriggerMethod; + data["InnerProtect"] = pRspStrategy->InnerProtect; + data["PassiveFailCloseMainLeg"] = pRspStrategy->PassiveFailCloseMainLeg; + data["SlipPoint"] = pRspStrategy->SlipPoint; + data["RecoverPriceMethod"] = pRspStrategy->RecoverPriceMethod; + data["RecoverPriceSeconds"] = pRspStrategy->RecoverPriceSeconds; + data["SetType"] = toUtf(pRspStrategy->SetType); + data["MinChangePrice"] = pRspStrategy->MinChangePrice; + data["MaxNum"] = pRspStrategy->MaxNum; + data["SuportQuantity"] = pRspStrategy->SuportQuantity; + data["SafeDeep"] = pRspStrategy->SafeDeep; + data["MainRange"] = pRspStrategy->MainRange; + data["ManualZhuiDanBeyondNum"] = toUtf(pRspStrategy->ManualZhuiDanBeyondNum); + data["ManualPingZhuDongBeyondNum"] = toUtf(pRspStrategy->ManualPingZhuDongBeyondNum); + data["AutoGuaDanSeconds"] = pRspStrategy->AutoGuaDanSeconds; + data["AutoZhuiBeiDongDots"] = pRspStrategy->AutoZhuiBeiDongDots; + data["AutoPingZhuDongDots"] = pRspStrategy->AutoPingZhuDongDots; + data["AutoZhiSunDot"] = pRspStrategy->AutoZhiSunDot; + data["AutoZhiSunZhuiBeiDongDots"] = pRspStrategy->AutoZhiSunZhuiBeiDongDots; + data["AutoZhiSunPingZhuDongDots"] = pRspStrategy->AutoZhiSunPingZhuDongDots; + data["DotLen"] = pRspStrategy->DotLen; + data["TradeTime"] = toUtf(pRspStrategy->TradeTime); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryStrategy(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryCommodity(CFutureRspCommodityField *pRspCommodity, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspCommodity) + { + data["CommodityNo"] = toUtf(pRspCommodity->CommodityNo); + data["ExchangeNo"] = toUtf(pRspCommodity->ExchangeNo); + data["CommodityType"] = toUtf(pRspCommodity->CommodityType); + data["Name"] = toUtf(pRspCommodity->Name); + data["Enabled"] = toUtf(pRspCommodity->Enabled); + data["RegDate"] = toUtf(pRspCommodity->RegDate); + data["CurrencyNo"] = toUtf(pRspCommodity->CurrencyNo); + data["ProductDot"] = pRspCommodity->ProductDot; + data["LowerTick"] = pRspCommodity->LowerTick; + data["UpperTick"] = pRspCommodity->UpperTick; + data["DotNum"] = pRspCommodity->DotNum; + data["StrikeCommodityId"] = pRspCommodity->StrikeCommodityId; + data["OptionStyle"] = toUtf(pRspCommodity->OptionStyle); + data["ExchangeNo2"] = toUtf(pRspCommodity->ExchangeNo2); + data["IsSFuture"] = toUtf(pRspCommodity->IsSFuture); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryCommodity(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryInstrument(CFutureRspInstrumentField *pRspInstrument, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInstrument) + { + data["CommodityCode"] = toUtf(pRspInstrument->CommodityCode); + data["ExchangeNo"] = toUtf(pRspInstrument->ExchangeNo); + data["ContractNo"] = toUtf(pRspInstrument->ContractNo); + data["ContractFName"] = toUtf(pRspInstrument->ContractFName); + data["CommodityNo"] = toUtf(pRspInstrument->CommodityNo); + data["CommodityFName"] = toUtf(pRspInstrument->CommodityFName); + data["CommodityType"] = toUtf(pRspInstrument->CommodityType); + data["CommodityFCurrencyNo"] = toUtf(pRspInstrument->CommodityFCurrencyNo); + data["CurrencyFName"] = toUtf(pRspInstrument->CurrencyFName); + data["ProductDot"] = pRspInstrument->ProductDot; + data["UpperTick"] = pRspInstrument->UpperTick; + data["ExchangeName"] = toUtf(pRspInstrument->ExchangeName); + data["LastSettlePrice"] = pRspInstrument->LastSettlePrice; + data["TradeMonth"] = toUtf(pRspInstrument->TradeMonth); + data["DotNum"] = pRspInstrument->DotNum; + data["LowerTick"] = pRspInstrument->LowerTick; + data["DotNumCarry"] = pRspInstrument->DotNumCarry; + data["UpperTickCarry"] = pRspInstrument->UpperTickCarry; + data["FirstNoticeDay"] = toUtf(pRspInstrument->FirstNoticeDay); + data["FreezenPercent"] = pRspInstrument->FreezenPercent; + data["FreezenMoney"] = pRspInstrument->FreezenMoney; + data["FeeMoney"] = pRspInstrument->FeeMoney; + data["FeePercent"] = pRspInstrument->FeePercent; + data["PriceStrike"] = pRspInstrument->PriceStrike; + data["ProductDotStrike"] = pRspInstrument->ProductDotStrike; + data["UpperTickStrike"] = pRspInstrument->UpperTickStrike; + data["LastTradeDay"] = toUtf(pRspInstrument->LastTradeDay); + data["LastUpdateDay"] = toUtf(pRspInstrument->LastUpdateDay); + data["CriticalPrice"] = pRspInstrument->CriticalPrice; + data["CriticalMinChangedPrice"] = pRspInstrument->CriticalMinChangedPrice; + data["ExchangeSub"] = toUtf(pRspInstrument->ExchangeSub); + data["OptionType"] = toUtf(pRspInstrument->OptionType); + data["OptionMonth"] = toUtf(pRspInstrument->OptionMonth); + data["OptionStrikePrice"] = toUtf(pRspInstrument->OptionStrikePrice); + data["OptionCommodityNo"] = toUtf(pRspInstrument->OptionCommodityNo); + data["OptionContractNo"] = toUtf(pRspInstrument->OptionContractNo); + data["ContractFNameEN"] = toUtf(pRspInstrument->ContractFNameEN); + data["CommodityFNameEN"] = toUtf(pRspInstrument->CommodityFNameEN); + data["OptionStyle"] = toUtf(pRspInstrument->OptionStyle); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryInstrument(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryExchangeTime(CFutureRspExchangeTimeField *pRspExchangeTime, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspExchangeTime) + { + data["Year"] = toUtf(pRspExchangeTime->Year); + data["SummerBegin"] = toUtf(pRspExchangeTime->SummerBegin); + data["WinterBegin"] = toUtf(pRspExchangeTime->WinterBegin); + data["ExchangeNo"] = toUtf(pRspExchangeTime->ExchangeNo); + data["Name"] = toUtf(pRspExchangeTime->Name); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryExchangeTime(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryCommodityTime(CFutureRspCommodityTimeField *pRspCommodityTime, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspCommodityTime) + { + data["CrossTrade"] = toUtf(pRspCommodityTime->CrossTrade); + data["Stage"] = toUtf(pRspCommodityTime->Stage); + data["Summer"] = toUtf(pRspCommodityTime->Summer); + data["Opendate"] = toUtf(pRspCommodityTime->Opendate); + data["Closingdate"] = toUtf(pRspCommodityTime->Closingdate); + data["CommodityNo"] = toUtf(pRspCommodityTime->CommodityNo); + data["ComName"] = toUtf(pRspCommodityTime->ComName); + data["ExchangeNo"] = toUtf(pRspCommodityTime->ExchangeNo); + data["ExName"] = toUtf(pRspCommodityTime->ExName); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryCommodityTime(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryTotalPosition(CFutureRspTotalPositionField *pRspTotalPosition, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspTotalPosition) + { + data["LocalOrderNo"] = toUtf(pRspTotalPosition->LocalOrderNo); + data["ExchangeNo"] = toUtf(pRspTotalPosition->ExchangeNo); + data["TreatyCode"] = toUtf(pRspTotalPosition->TreatyCode); + data["OrderNo"] = toUtf(pRspTotalPosition->OrderNo); + data["OrderNumber"] = pRspTotalPosition->OrderNumber; + data["FilledNumber"] = pRspTotalPosition->FilledNumber; + data["FilledAdvPrice"] = pRspTotalPosition->FilledAdvPrice; + data["BuyHoldNumber"] = pRspTotalPosition->BuyHoldNumber; + data["BuyHoldOpenPrice"] = pRspTotalPosition->BuyHoldOpenPrice; + data["BuyHoldPrice"] = pRspTotalPosition->BuyHoldPrice; + data["SaleHoldNumber"] = pRspTotalPosition->SaleHoldNumber; + data["SaleHoldOpenPrice"] = pRspTotalPosition->SaleHoldOpenPrice; + data["SaleHoldPrice"] = pRspTotalPosition->SaleHoldPrice; + data["IsCanceled"] = toUtf(pRspTotalPosition->IsCanceled); + data["FilledTotalFee"] = pRspTotalPosition->FilledTotalFee; + data["Status"] = pRspTotalPosition->Status; + data["AccountNo"] = toUtf(pRspTotalPosition->AccountNo); + data["HoldType"] = toUtf(pRspTotalPosition->HoldType); + data["HoldMarginBuy"] = pRspTotalPosition->HoldMarginBuy; + data["HoldMarginSale"] = pRspTotalPosition->HoldMarginSale; + data["CurrPrice"] = pRspTotalPosition->CurrPrice; + data["FloatProfit"] = pRspTotalPosition->FloatProfit; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryTotalPosition(data, data, iRequestID, bIsLast); +}; + +void FutureApi::OnRspQryStrategyDetail(CFutureRspStrategyDetailField *pRspStrategyDetail, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspStrategyDetail) + { + data["StartegyCommodityNo"] = toUtf(pRspStrategyDetail->StartegyCommodityNo); + data["StartegyContractNo"] = toUtf(pRspStrategyDetail->StartegyContractNo); + data["Price"] = toUtf(pRspStrategyDetail->Price); + data["LegNum"] = pRspStrategyDetail->LegNum; + data["LastTradeDate"] = toUtf(pRspStrategyDetail->LastTradeDate); + data["SeqId"] = pRspStrategyDetail->SeqId; + data["CommodityNo"] = toUtf(pRspStrategyDetail->CommodityNo); + data["ContractNo"] = toUtf(pRspStrategyDetail->ContractNo); + data["Direct"] = toUtf(pRspStrategyDetail->Direct); + data["Quantity"] = pRspStrategyDetail->Quantity; + data["Model"] = toUtf(pRspStrategyDetail->Model); + data["ModifyDate"] = toUtf(pRspStrategyDetail->ModifyDate); + data["OrderMethod"] = toUtf(pRspStrategyDetail->OrderMethod); + data["PriceTolerance"] = pRspStrategyDetail->PriceTolerance; + data["PriceParam"] = pRspStrategyDetail->PriceParam; + data["SuportQuantity"] = pRspStrategyDetail->SuportQuantity; + data["MinMove"] = pRspStrategyDetail->MinMove; + data["TimerOrder"] = pRspStrategyDetail->TimerOrder; + data["TimerOrderBeyondNum"] = toUtf(pRspStrategyDetail->TimerOrderBeyondNum); + data["TimerOrderPrice"] = pRspStrategyDetail->TimerOrderPrice; + data["TimerOrderPriceBeyondNum"] = toUtf(pRspStrategyDetail->TimerOrderPriceBeyondNum); + data["TimerOrderPriceTriggerNum"] = toUtf(pRspStrategyDetail->TimerOrderPriceTriggerNum); + data["ZhiSunOrder"] = pRspStrategyDetail->ZhiSunOrder; + data["ZhiSunOrderBeyondNum"] = toUtf(pRspStrategyDetail->ZhiSunOrderBeyondNum); + data["TimerPingCang"] = pRspStrategyDetail->TimerPingCang; + data["TimerPingCangBeyondNum"] = toUtf(pRspStrategyDetail->TimerPingCangBeyondNum); + data["SafeDeep"] = pRspStrategyDetail->SafeDeep; + data["MainRange"] = pRspStrategyDetail->MainRange; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryStrategyDetail(data, data, iRequestID, bIsLast); +}; + diff --git a/vnpy/api/da/generator/da_future_struct.py b/vnpy/api/da/generator/da_future_struct.py index 67c95f21..5095bf52 100644 --- a/vnpy/api/da/generator/da_future_struct.py +++ b/vnpy/api/da/generator/da_future_struct.py @@ -155,7 +155,7 @@ CFutureReqOrderModifyField = { "ErrorDescription": "string", } -CFutureRspOrderInsertField = CFutureRspOrderModifyField +CFutureRspOrderModifyField = CFutureRspOrderInsertField CFutureReqOrderCancelField = { "UserId": "string", @@ -599,9 +599,9 @@ CFutureRtnCapitalField = { "SellNeedAddMargin": "double", } -CFutureRtnOrderField = CFutureRtnPositionField +CFutureRtnPositionField = CFutureRtnOrderField -CFutureRspTradeField = CFutureRtnTradeField +CFutureRtnTradeField = CFutureRspTradeField CFutureReqGetQuestionField = { "Unused": "int", @@ -656,7 +656,7 @@ CFutureQryTotalPositionField = { "ErrorDescription": "string", } -CFutureRtnOrderField = CFutureRspTotalPositionField +CFutureRspTotalPositionField = CFutureRtnOrderField CFutureQryStrategyField = { "ExchangeNo": "string", diff --git a/vnpy/api/da/generator/da_market_header_function.h b/vnpy/api/da/generator/da_market_header_function.h new file mode 100644 index 00000000..d81b3dca --- /dev/null +++ b/vnpy/api/da/generator/da_market_header_function.h @@ -0,0 +1,6 @@ +int reqUserLogin(const dict &req, int reqid); + +int reqBrokerData(const dict &req, int reqid); + +int reqMarketData(const dict &req, int reqid); + diff --git a/vnpy/api/da/generator/da_market_header_on.h b/vnpy/api/da/generator/da_market_header_on.h new file mode 100644 index 00000000..199960bd --- /dev/null +++ b/vnpy/api/da/generator/da_market_header_on.h @@ -0,0 +1,16 @@ +virtual void onFrontConnected() {}; + +virtual void onFrontDisconnected(int reqid) {}; + +virtual void onHeartBeatWarning(int reqid) {}; + +virtual void onRspRawData(const dict &data) {}; + +virtual void onRspUserLogin(const dict &error, int reqid, bool last) {}; + +virtual void onRspTradeDate(const dict &data, const dict &error, int reqid, bool last) {}; + +virtual void onRspBrokerData(const dict &data, const dict &error, int reqid, bool last) {}; + +virtual void onRspMarketData(const dict &data, const dict &error, int reqid, bool last) {}; + diff --git a/vnpy/api/da/generator/da_market_source_function.cpp b/vnpy/api/da/generator/da_market_source_function.cpp new file mode 100644 index 00000000..f9276fdb --- /dev/null +++ b/vnpy/api/da/generator/da_market_source_function.cpp @@ -0,0 +1,40 @@ +int MarketApi::reqUserLogin(const dict &req, int reqid) +{ + CMarketReqUserLoginField myreq = CMarketReqUserLoginField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "UserType", myreq.UserType); + getString(req, "MacAddress", myreq.MacAddress); + getString(req, "ComputerName", myreq.ComputerName); + getString(req, "SoftwareName", myreq.SoftwareName); + getString(req, "SoftwareVersion", myreq.SoftwareVersion); + getString(req, "AuthorCode", myreq.AuthorCode); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqUserLogin(&myreq, reqid); + return i; +}; + +int MarketApi::reqBrokerData(const dict &req, int reqid) +{ + CMarketReqBrokerDataField myreq = CMarketReqBrokerDataField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "ContCode", myreq.ContCode); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqBrokerData(&myreq, reqid); + return i; +}; + +int MarketApi::reqMarketData(const dict &req, int reqid) +{ + CMarketReqMarketDataField myreq = CMarketReqMarketDataField(); + memset(&myreq, 0, sizeof(myreq)); + getChar(req, "MarketType", &myreq.MarketType); + getChar(req, "SubscMode", &myreq.SubscMode); + getInt(req, "MarketCount", &myreq.MarketCount); + getString(req, "MarketTrcode[MAX_SUB_COUNT]", myreq.MarketTrcode[MAX_SUB_COUNT]); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqMarketData(&myreq, reqid); + return i; +}; + diff --git a/vnpy/api/da/generator/da_market_source_module.cpp b/vnpy/api/da/generator/da_market_source_module.cpp new file mode 100644 index 00000000..078cd2ad --- /dev/null +++ b/vnpy/api/da/generator/da_market_source_module.cpp @@ -0,0 +1,13 @@ +.def("reqUserLogin", &MarketApi::reqUserLogin) +.def("reqBrokerData", &MarketApi::reqBrokerData) +.def("reqMarketData", &MarketApi::reqMarketData) + +.def("onFrontConnected", &MarketApi::onFrontConnected) +.def("onFrontDisconnected", &MarketApi::onFrontDisconnected) +.def("onHeartBeatWarning", &MarketApi::onHeartBeatWarning) +.def("onRspRawData", &MarketApi::onRspRawData) +.def("onRspUserLogin", &MarketApi::onRspUserLogin) +.def("onRspTradeDate", &MarketApi::onRspTradeDate) +.def("onRspBrokerData", &MarketApi::onRspBrokerData) +.def("onRspMarketData", &MarketApi::onRspMarketData) +; diff --git a/vnpy/api/da/generator/da_market_source_on.cpp b/vnpy/api/da/generator/da_market_source_on.cpp new file mode 100644 index 00000000..e21c0ada --- /dev/null +++ b/vnpy/api/da/generator/da_market_source_on.cpp @@ -0,0 +1,96 @@ +void onFrontConnected() override +{ + try + { + PYBIND11_OVERLOAD(void, MarketApi, onFrontConnected); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onFrontDisconnected(int reqid) override +{ + try + { + PYBIND11_OVERLOAD(void, MarketApi, onFrontDisconnected, reqid); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onHeartBeatWarning(int reqid) override +{ + try + { + PYBIND11_OVERLOAD(void, MarketApi, onHeartBeatWarning, reqid); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspRawData(const dict &data) override +{ + try + { + PYBIND11_OVERLOAD(void, MarketApi, onRspRawData, data); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspUserLogin(const dict &error, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, MarketApi, onRspUserLogin, error, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspTradeDate(const dict &data, const dict &error, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, MarketApi, onRspTradeDate, data, error, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspBrokerData(const dict &data, const dict &error, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, MarketApi, onRspBrokerData, data, error, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspMarketData(const dict &data, const dict &error, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, MarketApi, onRspMarketData, data, error, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + diff --git a/vnpy/api/da/generator/da_market_source_task.cpp b/vnpy/api/da/generator/da_market_source_task.cpp new file mode 100644 index 00000000..6a8b8e1a --- /dev/null +++ b/vnpy/api/da/generator/da_market_source_task.cpp @@ -0,0 +1,153 @@ +void MarketApi::OnFrontConnected() +{ + gil_scoped_acquire acquire; + this->onFrontConnected(); +}; + +void MarketApi::OnFrontDisconnected(int iReason) +{ + gil_scoped_acquire acquire; + this->onFrontDisconnected(iReason); +}; + +void MarketApi::OnHeartBeatWarning(int iTimeLapse) +{ + gil_scoped_acquire acquire; + this->onHeartBeatWarning(iTimeLapse); +}; + +void MarketApi::OnRspRawData(const char* rawData) +{ + gil_scoped_acquire acquire; + this->onRspRawData(string(rawData)); +}; + +void MarketApi::OnRspUserLogin(CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict error; + if (pRspInfo) + { + error["ErrorID"] = pRspInfo->ErrorID; + error["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspUserLogin(error, iRequestID, bIsLast); +}; + +void MarketApi::OnRspTradeDate(CMarketRspTradeDateField *pRspTradeDate, CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspTradeDate) + { + data["TradeDate"] = toUtf(pRspTradeDate->TradeDate); + data["TradeProduct"] = toUtf(pRspTradeDate->TradeProduct); + } + dict error; + if (pRspInfo) + { + error["ErrorID"] = pRspInfo->ErrorID; + error["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspTradeDate(data, error, iRequestID, bIsLast); +}; + +void MarketApi::OnRspBrokerData(CMarketRspBrokerDataField *pRspBrokerData, CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspBrokerData) + { + data["BrokerData"] = toUtf(pRspBrokerData->BrokerData); + } + dict error; + if (pRspInfo) + { + error["ErrorID"] = pRspInfo->ErrorID; + error["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspBrokerData(data, error, iRequestID, bIsLast); +}; + +void MarketApi::OnRspMarketData(CMarketRspMarketDataField *pRspMarketData, CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspMarketData) + { + data["ExchangeCode"] = toUtf(pRspMarketData->ExchangeCode); + data["TreatyCode"] = toUtf(pRspMarketData->TreatyCode); + data["BuyPrice"] = toUtf(pRspMarketData->BuyPrice); + data["BuyNumber"] = toUtf(pRspMarketData->BuyNumber); + data["SalePrice"] = toUtf(pRspMarketData->SalePrice); + data["SaleNumber"] = toUtf(pRspMarketData->SaleNumber); + data["CurrPrice"] = toUtf(pRspMarketData->CurrPrice); + data["CurrNumber"] = toUtf(pRspMarketData->CurrNumber); + data["High"] = toUtf(pRspMarketData->High); + data["Low"] = toUtf(pRspMarketData->Low); + data["Open"] = toUtf(pRspMarketData->Open); + data["IntradaySettlePrice"] = toUtf(pRspMarketData->IntradaySettlePrice); + data["Close"] = toUtf(pRspMarketData->Close); + data["Time"] = toUtf(pRspMarketData->Time); + data["FilledNum"] = toUtf(pRspMarketData->FilledNum); + data["HoldNum"] = toUtf(pRspMarketData->HoldNum); + data["BuyPrice2"] = toUtf(pRspMarketData->BuyPrice2); + data["BuyPrice3"] = toUtf(pRspMarketData->BuyPrice3); + data["BuyPrice4"] = toUtf(pRspMarketData->BuyPrice4); + data["BuyPrice5"] = toUtf(pRspMarketData->BuyPrice5); + data["BuyNumber2"] = toUtf(pRspMarketData->BuyNumber2); + data["BuyNumber3"] = toUtf(pRspMarketData->BuyNumber3); + data["BuyNumber4"] = toUtf(pRspMarketData->BuyNumber4); + data["BuyNumber5"] = toUtf(pRspMarketData->BuyNumber5); + data["SalePrice2"] = toUtf(pRspMarketData->SalePrice2); + data["SalePrice3"] = toUtf(pRspMarketData->SalePrice3); + data["SalePrice4"] = toUtf(pRspMarketData->SalePrice4); + data["SalePrice5"] = toUtf(pRspMarketData->SalePrice5); + data["SaleNumber2"] = toUtf(pRspMarketData->SaleNumber2); + data["SaleNumber3"] = toUtf(pRspMarketData->SaleNumber3); + data["SaleNumber4"] = toUtf(pRspMarketData->SaleNumber4); + data["SaleNumber5"] = toUtf(pRspMarketData->SaleNumber5); + data["HideBuyPrice"] = toUtf(pRspMarketData->HideBuyPrice); + data["HideBuyNumber"] = toUtf(pRspMarketData->HideBuyNumber); + data["HideSalePrice"] = toUtf(pRspMarketData->HideSalePrice); + data["HideSaleNumber"] = toUtf(pRspMarketData->HideSaleNumber); + data["LimitDownPrice"] = toUtf(pRspMarketData->LimitDownPrice); + data["LimitUpPrice"] = toUtf(pRspMarketData->LimitUpPrice); + data["TradeDay"] = toUtf(pRspMarketData->TradeDay); + data["BuyPrice6"] = toUtf(pRspMarketData->BuyPrice6); + data["BuyPrice7"] = toUtf(pRspMarketData->BuyPrice7); + data["BuyPrice8"] = toUtf(pRspMarketData->BuyPrice8); + data["BuyPrice9"] = toUtf(pRspMarketData->BuyPrice9); + data["BuyPrice10"] = toUtf(pRspMarketData->BuyPrice10); + data["BuyNumber6"] = toUtf(pRspMarketData->BuyNumber6); + data["BuyNumber7"] = toUtf(pRspMarketData->BuyNumber7); + data["BuyNumber8"] = toUtf(pRspMarketData->BuyNumber8); + data["BuyNumber9"] = toUtf(pRspMarketData->BuyNumber9); + data["BuyNumber10"] = toUtf(pRspMarketData->BuyNumber10); + data["SalePrice6"] = toUtf(pRspMarketData->SalePrice6); + data["SalePrice7"] = toUtf(pRspMarketData->SalePrice7); + data["SalePrice8"] = toUtf(pRspMarketData->SalePrice8); + data["SalePrice9"] = toUtf(pRspMarketData->SalePrice9); + data["SalePrice10"] = toUtf(pRspMarketData->SalePrice10); + data["SaleNumber6"] = toUtf(pRspMarketData->SaleNumber6); + data["SaleNumber7"] = toUtf(pRspMarketData->SaleNumber7); + data["SaleNumber8"] = toUtf(pRspMarketData->SaleNumber8); + data["SaleNumber9"] = toUtf(pRspMarketData->SaleNumber9); + data["SaleNumber10"] = toUtf(pRspMarketData->SaleNumber10); + data["TradeFlag"] = toUtf(pRspMarketData->TradeFlag); + data["DataTimestamp"] = toUtf(pRspMarketData->DataTimestamp); + data["DataSourceId"] = toUtf(pRspMarketData->DataSourceId); + data["CanSellVol"] = toUtf(pRspMarketData->CanSellVol); + data["QuoteType"] = toUtf(pRspMarketData->QuoteType); + data["AggressorSide"] = toUtf(pRspMarketData->AggressorSide); + data["PreSettlementPrice"] = toUtf(pRspMarketData->PreSettlementPrice); + } + dict error; + if (pRspInfo) + { + error["ErrorID"] = pRspInfo->ErrorID; + error["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspMarketData(data, error, iRequestID, bIsLast); +}; + diff --git a/vnpy/api/da/generator/da_stock_header_function.h b/vnpy/api/da/generator/da_stock_header_function.h new file mode 100644 index 00000000..45024941 --- /dev/null +++ b/vnpy/api/da/generator/da_stock_header_function.h @@ -0,0 +1,38 @@ +int reqUserLogin(const dict &req, int reqid); + +int reqUserLogout(const dict &req, int reqid); + +int reqSafeVerify(const dict &req, int reqid); + +int reqVerifyCode(const dict &req, int reqid); + +int reqSetVerifyQA(const dict &req, int reqid); + +int reqGetQuestion(const dict &req, int reqid); + +int reqOrderInsert(const dict &req, int reqid); + +int reqOrderModify(const dict &req, int reqid); + +int reqOrderCancel(const dict &req, int reqid); + +int reqPasswordUpdate(const dict &req, int reqid); + +int reqQryTick(const dict &req, int reqid); + +int reqQryOrder(const dict &req, int reqid); + +int reqQryTrade(const dict &req, int reqid); + +int reqQryCapital(const dict &req, int reqid); + +int reqQryVersion(const dict &req, int reqid); + +int reqQryPosition(const dict &req, int reqid); + +int reqQryCurrency(const dict &req, int reqid); + +int reqQryExchange(const dict &req, int reqid); + +int reqQryInstrument(const dict &req, int reqid); + diff --git a/vnpy/api/da/generator/da_stock_header_on.h b/vnpy/api/da/generator/da_stock_header_on.h new file mode 100644 index 00000000..15046b34 --- /dev/null +++ b/vnpy/api/da/generator/da_stock_header_on.h @@ -0,0 +1,56 @@ +virtual void onFrontConnected() {}; + +virtual void onFrontDisconnected(int reqid) {}; + +virtual void onHeartBeatWarning(int reqid) {}; + +virtual void onRspNeedVerify(bool last, bool last) {}; + +virtual void onRspUserLogin(const dict &data, int reqid, bool last) {}; + +virtual void onRspUserLogout(const dict &data, int reqid, bool last) {}; + +virtual void onRspVerifyCode(const dict &data, int reqid, bool last) {}; + +virtual void onRspSafeVerify(const dict &data, int reqid, bool last) {}; + +virtual void onRspSetVerifyQA(const dict &data, int reqid, bool last) {}; + +virtual void onRspAccount(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQuestion(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspOrderInsert(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspOrderModify(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspOrderCancel(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspPasswordUpdate(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRtnTrade(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRtnOrder(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRtnCapital(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRtnPosition(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryTick(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryOrder(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryTrade(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryCapital(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryVersion(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryPosition(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryCurrency(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryExchange(const dict &data, const dict &data, int reqid, bool last) {}; + +virtual void onRspQryInstrument(const dict &data, const dict &data, int reqid, bool last) {}; + diff --git a/vnpy/api/da/generator/da_stock_source_function.cpp b/vnpy/api/da/generator/da_stock_source_function.cpp new file mode 100644 index 00000000..2827b88d --- /dev/null +++ b/vnpy/api/da/generator/da_stock_source_function.cpp @@ -0,0 +1,285 @@ +int StockApi::reqUserLogin(const dict &req, int reqid) +{ + CStockReqUserLoginField myreq = CStockReqUserLoginField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "UserType", myreq.UserType); + getString(req, "MacAddress", myreq.MacAddress); + getString(req, "ComputerName", myreq.ComputerName); + getString(req, "SoftwareName", myreq.SoftwareName); + getString(req, "SoftwareVersion", myreq.SoftwareVersion); + getString(req, "AuthorCode", myreq.AuthorCode); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqUserLogin(&myreq, reqid); + return i; +}; + +int StockApi::reqUserLogout(const dict &req, int reqid) +{ + CStockReqUserLogoutField myreq = CStockReqUserLogoutField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqUserLogout(&myreq, reqid); + return i; +}; + +int StockApi::reqSafeVerify(const dict &req, int reqid) +{ + CStockReqSafeVerifyField myreq = CStockReqSafeVerifyField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "Type", myreq.Type); + getString(req, "Question", myreq.Question); + getString(req, "Answer", myreq.Answer); + getString(req, "MobileNumber", myreq.MobileNumber); + getString(req, "VerifyCode", myreq.VerifyCode); + getString(req, "SaveMac", myreq.SaveMac); + getString(req, "MacAddress", myreq.MacAddress); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqSafeVerify(&myreq, reqid); + return i; +}; + +int StockApi::reqVerifyCode(const dict &req, int reqid) +{ + CStockReqVerifyCodeField myreq = CStockReqVerifyCodeField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "Type", myreq.Type); + getString(req, "Question", myreq.Question); + getString(req, "Answer", myreq.Answer); + getString(req, "MobileNumber", myreq.MobileNumber); + getString(req, "VerifyCode", myreq.VerifyCode); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqVerifyCode(&myreq, reqid); + return i; +}; + +int StockApi::reqSetVerifyQA(const dict &req, int reqid) +{ + CStockReqSetVerifyQAField myreq = CStockReqSetVerifyQAField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "Type", myreq.Type); + getString(req, "Question", myreq.Question); + getString(req, "Answer", myreq.Answer); + getString(req, "MobileNumber", myreq.MobileNumber); + getString(req, "VerifyCode", myreq.VerifyCode); + getString(req, "SaveMac", myreq.SaveMac); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqSetVerifyQA(&myreq, reqid); + return i; +}; + +int StockApi::reqGetQuestion(const dict &req, int reqid) +{ + CStockReqGetQuestionField myreq = CStockReqGetQuestionField(); + memset(&myreq, 0, sizeof(myreq)); + getInt(req, "Unused", &myreq.Unused); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqGetQuestion(&myreq, reqid); + return i; +}; + +int StockApi::reqOrderInsert(const dict &req, int reqid) +{ + CStockReqOrderInsertField myreq = CStockReqOrderInsertField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserType", myreq.UserType); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "LocalNo", myreq.LocalNo); + getString(req, "TradePwd", myreq.TradePwd); + getString(req, "IsRiskOrder", myreq.IsRiskOrder); + getString(req, "ExchangeCode", myreq.ExchangeCode); + getString(req, "TreatyCode", myreq.TreatyCode); + getString(req, "BuySale", myreq.BuySale); + getString(req, "AddReduce", myreq.AddReduce); + getString(req, "OrderNumber", myreq.OrderNumber); + getString(req, "OrderPrice", myreq.OrderPrice); + getString(req, "TradeType", myreq.TradeType); + getString(req, "PriceType", myreq.PriceType); + getString(req, "HtsType", myreq.HtsType); + getString(req, "ForceID", myreq.ForceID); + getString(req, "TriggerPrice", myreq.TriggerPrice); + getString(req, "ValidDate", myreq.ValidDate); + getString(req, "StrategyId", myreq.StrategyId); + getString(req, "MaxShow", myreq.MaxShow); + getString(req, "MinQty", myreq.MinQty); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqOrderInsert(&myreq, reqid); + return i; +}; + +int StockApi::reqOrderModify(const dict &req, int reqid) +{ + CStockReqOrderModifyField myreq = CStockReqOrderModifyField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "SystemNo", myreq.SystemNo); + getString(req, "UserId", myreq.UserId); + getString(req, "UserType", myreq.UserType); + getString(req, "LocalNo", myreq.LocalNo); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "TradePwd", myreq.TradePwd); + getString(req, "OrderNo", myreq.OrderNo); + getString(req, "ExchangeCode", myreq.ExchangeCode); + getString(req, "TreatyCode", myreq.TreatyCode); + getString(req, "BuySale", myreq.BuySale); + getString(req, "OrderNumber", myreq.OrderNumber); + getString(req, "OrderPrice", myreq.OrderPrice); + getString(req, "FilledNumber", myreq.FilledNumber); + getString(req, "ModifyNumber", myreq.ModifyNumber); + getString(req, "ModifyPrice", myreq.ModifyPrice); + getString(req, "TradeType", myreq.TradeType); + getString(req, "PriceType", myreq.PriceType); + getString(req, "IsRiskOrder", myreq.IsRiskOrder); + getString(req, "TriggerPrice", myreq.TriggerPrice); + getString(req, "ModifyTriggerPrice", myreq.ModifyTriggerPrice); + getString(req, "ValidDate", myreq.ValidDate); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqOrderModify(&myreq, reqid); + return i; +}; + +int StockApi::reqOrderCancel(const dict &req, int reqid) +{ + CStockReqOrderCancelField myreq = CStockReqOrderCancelField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserType", myreq.UserType); + getString(req, "LocalNo", myreq.LocalNo); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "TradePwd", myreq.TradePwd); + getString(req, "IsSimulation", myreq.IsSimulation); + getString(req, "SystemNo", myreq.SystemNo); + getString(req, "OrderNo", myreq.OrderNo); + getString(req, "ExchangeCode", myreq.ExchangeCode); + getString(req, "TreatyCode", myreq.TreatyCode); + getString(req, "BuySale", myreq.BuySale); + getString(req, "OrderNumber", myreq.OrderNumber); + getString(req, "OrderPrice", myreq.OrderPrice); + getString(req, "FilledNumber", myreq.FilledNumber); + getString(req, "TradeType", myreq.TradeType); + getString(req, "PriceType", myreq.PriceType); + getString(req, "HtsType", myreq.HtsType); + getString(req, "IsRiskOrder", myreq.IsRiskOrder); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqOrderCancel(&myreq, reqid); + return i; +}; + +int StockApi::reqPasswordUpdate(const dict &req, int reqid) +{ + CStockReqPasswordUpdateField myreq = CStockReqPasswordUpdateField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "OldPassword", myreq.OldPassword); + getString(req, "NewPassword", myreq.NewPassword); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqPasswordUpdate(&myreq, reqid); + return i; +}; + +int StockApi::reqQryTick(const dict &req, int reqid) +{ + CStockQryTickField myreq = CStockQryTickField(); + memset(&myreq, 0, sizeof(myreq)); + getChar(req, "Unused", &myreq.Unused); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryTick(&myreq, reqid); + return i; +}; + +int StockApi::reqQryOrder(const dict &req, int reqid) +{ + CStockQryOrderField myreq = CStockQryOrderField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserType", myreq.UserType); + getString(req, "AccountNo", myreq.AccountNo); + getString(req, "TradePwd", myreq.TradePwd); + getString(req, "IsSimulation", myreq.IsSimulation); + getString(req, "OrderNo", myreq.OrderNo); + getString(req, "OrderDateTime", myreq.OrderDateTime); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryOrder(&myreq, reqid); + return i; +}; + +int StockApi::reqQryTrade(const dict &req, int reqid) +{ + CStockQryTradeField myreq = CStockQryTradeField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryTrade(&myreq, reqid); + return i; +}; + +int StockApi::reqQryCapital(const dict &req, int reqid) +{ + CStockQryCapitalField myreq = CStockQryCapitalField(); + memset(&myreq, 0, sizeof(myreq)); + getChar(req, "Unused", &myreq.Unused); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryCapital(&myreq, reqid); + return i; +}; + +int StockApi::reqQryVersion(const dict &req, int reqid) +{ + CStockQryVersionField myreq = CStockQryVersionField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "UserId", myreq.UserId); + getString(req, "UserPwd", myreq.UserPwd); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryVersion(&myreq, reqid); + return i; +}; + +int StockApi::reqQryPosition(const dict &req, int reqid) +{ + CStockQryPositionField myreq = CStockQryPositionField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryPosition(&myreq, reqid); + return i; +}; + +int StockApi::reqQryCurrency(const dict &req, int reqid) +{ + CStockQryCurrencyField myreq = CStockQryCurrencyField(); + memset(&myreq, 0, sizeof(myreq)); + getChar(req, "Unused", &myreq.Unused); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryCurrency(&myreq, reqid); + return i; +}; + +int StockApi::reqQryExchange(const dict &req, int reqid) +{ + CStockQryExchangeField myreq = CStockQryExchangeField(); + memset(&myreq, 0, sizeof(myreq)); + getString(req, "ProductGroupID", myreq.ProductGroupID); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryExchange(&myreq, reqid); + return i; +}; + +int StockApi::reqQryInstrument(const dict &req, int reqid) +{ + CStockQryInstrumentField myreq = CStockQryInstrumentField(); + memset(&myreq, 0, sizeof(myreq)); + getInt(req, "PageIndex", &myreq.PageIndex); + getString(req, "ExchangeNo", myreq.ExchangeNo); + getString(req, "ErrorDescription", myreq.ErrorDescription); + int i = this->api->ReqQryInstrument(&myreq, reqid); + return i; +}; + diff --git a/vnpy/api/da/generator/da_stock_source_module.cpp b/vnpy/api/da/generator/da_stock_source_module.cpp new file mode 100644 index 00000000..76355a34 --- /dev/null +++ b/vnpy/api/da/generator/da_stock_source_module.cpp @@ -0,0 +1,49 @@ +.def("reqUserLogin", &StockApi::reqUserLogin) +.def("reqUserLogout", &StockApi::reqUserLogout) +.def("reqSafeVerify", &StockApi::reqSafeVerify) +.def("reqVerifyCode", &StockApi::reqVerifyCode) +.def("reqSetVerifyQA", &StockApi::reqSetVerifyQA) +.def("reqGetQuestion", &StockApi::reqGetQuestion) +.def("reqOrderInsert", &StockApi::reqOrderInsert) +.def("reqOrderModify", &StockApi::reqOrderModify) +.def("reqOrderCancel", &StockApi::reqOrderCancel) +.def("reqPasswordUpdate", &StockApi::reqPasswordUpdate) +.def("reqQryTick", &StockApi::reqQryTick) +.def("reqQryOrder", &StockApi::reqQryOrder) +.def("reqQryTrade", &StockApi::reqQryTrade) +.def("reqQryCapital", &StockApi::reqQryCapital) +.def("reqQryVersion", &StockApi::reqQryVersion) +.def("reqQryPosition", &StockApi::reqQryPosition) +.def("reqQryCurrency", &StockApi::reqQryCurrency) +.def("reqQryExchange", &StockApi::reqQryExchange) +.def("reqQryInstrument", &StockApi::reqQryInstrument) + +.def("onFrontConnected", &StockApi::onFrontConnected) +.def("onFrontDisconnected", &StockApi::onFrontDisconnected) +.def("onHeartBeatWarning", &StockApi::onHeartBeatWarning) +.def("onRspNeedVerify", &StockApi::onRspNeedVerify) +.def("onRspUserLogin", &StockApi::onRspUserLogin) +.def("onRspUserLogout", &StockApi::onRspUserLogout) +.def("onRspVerifyCode", &StockApi::onRspVerifyCode) +.def("onRspSafeVerify", &StockApi::onRspSafeVerify) +.def("onRspSetVerifyQA", &StockApi::onRspSetVerifyQA) +.def("onRspAccount", &StockApi::onRspAccount) +.def("onRspQuestion", &StockApi::onRspQuestion) +.def("onRspOrderInsert", &StockApi::onRspOrderInsert) +.def("onRspOrderModify", &StockApi::onRspOrderModify) +.def("onRspOrderCancel", &StockApi::onRspOrderCancel) +.def("onRspPasswordUpdate", &StockApi::onRspPasswordUpdate) +.def("onRtnTrade", &StockApi::onRtnTrade) +.def("onRtnOrder", &StockApi::onRtnOrder) +.def("onRtnCapital", &StockApi::onRtnCapital) +.def("onRtnPosition", &StockApi::onRtnPosition) +.def("onRspQryTick", &StockApi::onRspQryTick) +.def("onRspQryOrder", &StockApi::onRspQryOrder) +.def("onRspQryTrade", &StockApi::onRspQryTrade) +.def("onRspQryCapital", &StockApi::onRspQryCapital) +.def("onRspQryVersion", &StockApi::onRspQryVersion) +.def("onRspQryPosition", &StockApi::onRspQryPosition) +.def("onRspQryCurrency", &StockApi::onRspQryCurrency) +.def("onRspQryExchange", &StockApi::onRspQryExchange) +.def("onRspQryInstrument", &StockApi::onRspQryInstrument) +; diff --git a/vnpy/api/da/generator/da_stock_source_on.cpp b/vnpy/api/da/generator/da_stock_source_on.cpp new file mode 100644 index 00000000..64844bb5 --- /dev/null +++ b/vnpy/api/da/generator/da_stock_source_on.cpp @@ -0,0 +1,336 @@ +void onFrontConnected() override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onFrontConnected); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onFrontDisconnected(int reqid) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onFrontDisconnected, reqid); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onHeartBeatWarning(int reqid) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onHeartBeatWarning, reqid); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspNeedVerify(bool last, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspNeedVerify, last, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspUserLogin(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspUserLogin, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspUserLogout(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspUserLogout, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspVerifyCode(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspVerifyCode, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspSafeVerify(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspSafeVerify, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspSetVerifyQA(const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspSetVerifyQA, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspAccount(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspAccount, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQuestion(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQuestion, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspOrderInsert(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspOrderInsert, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspOrderModify(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspOrderModify, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspOrderCancel(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspOrderCancel, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspPasswordUpdate(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspPasswordUpdate, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRtnTrade(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRtnTrade, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRtnOrder(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRtnOrder, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRtnCapital(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRtnCapital, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRtnPosition(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRtnPosition, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryTick(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryTick, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryOrder(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryOrder, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryTrade(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryTrade, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryCapital(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryCapital, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryVersion(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryVersion, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryPosition(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryPosition, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryCurrency(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryCurrency, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryExchange(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryExchange, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + +void onRspQryInstrument(const dict &data, const dict &data, int reqid, bool last) override +{ + try + { + PYBIND11_OVERLOAD(void, StockApi, onRspQryInstrument, data, data, reqid, last); + } + catch (const error_already_set &e) + { + cout << e.what() << endl; + } +}; + diff --git a/vnpy/api/da/generator/da_stock_source_task.cpp b/vnpy/api/da/generator/da_stock_source_task.cpp new file mode 100644 index 00000000..52adcac1 --- /dev/null +++ b/vnpy/api/da/generator/da_stock_source_task.cpp @@ -0,0 +1,826 @@ +void StockApi::OnFrontConnected() +{ + gil_scoped_acquire acquire; + this->onFrontConnected(); +}; + +void StockApi::OnFrontDisconnected(int iReason) +{ + gil_scoped_acquire acquire; + this->onFrontDisconnected(iReason); +}; + +void StockApi::OnHeartBeatWarning(int iTimeLapse) +{ + gil_scoped_acquire acquire; + this->onHeartBeatWarning(iTimeLapse); +}; + +void StockApi::OnRspNeedVerify(bool bFirstLogin, bool bHasSetQA) +{ + gil_scoped_acquire acquire; + this->onRspNeedVerify(bFirstLogin, bHasSetQA); +}; + +void StockApi::OnRspUserLogin(CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspUserLogin(data, iRequestID, bIsLast); +}; + +void StockApi::OnRspUserLogout(CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspUserLogout(data, iRequestID, bIsLast); +}; + +void StockApi::OnRspVerifyCode(CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspVerifyCode(data, iRequestID, bIsLast); +}; + +void StockApi::OnRspSafeVerify(CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspSafeVerify(data, iRequestID, bIsLast); +}; + +void StockApi::OnRspSetVerifyQA(CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspSetVerifyQA(data, iRequestID, bIsLast); +}; + +void StockApi::OnRspAccount(CStockRspAccountField *pRspAccount, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspAccount) + { + data["UserId"] = toUtf(pRspAccount->UserId); + data["UserName"] = toUtf(pRspAccount->UserName); + data["UserType"] = toUtf(pRspAccount->UserType); + data["LoginPwd"] = toUtf(pRspAccount->LoginPwd); + data["AccountNo"] = toUtf(pRspAccount->AccountNo); + data["TradePwd"] = toUtf(pRspAccount->TradePwd); + data["IsSimulation"] = toUtf(pRspAccount->IsSimulation); + data["FrontendIp"] = toUtf(pRspAccount->FrontendIp); + data["FrontendPort"] = toUtf(pRspAccount->FrontendPort); + data["CurrencyNo"] = toUtf(pRspAccount->CurrencyNo); + data["UserState"] = toUtf(pRspAccount->UserState); + data["SelAll"] = toUtf(pRspAccount->SelAll); + data["Strategy"] = toUtf(pRspAccount->Strategy); + data["Inner"] = toUtf(pRspAccount->Inner); + data["YingSun"] = toUtf(pRspAccount->YingSun); + data["ChaoDan"] = toUtf(pRspAccount->ChaoDan); + data["Option"] = toUtf(pRspAccount->Option); + data["CmeMarket"] = toUtf(pRspAccount->CmeMarket); + data["CmeCOMEXMarket"] = toUtf(pRspAccount->CmeCOMEXMarket); + data["CmeNYMEXMarket"] = toUtf(pRspAccount->CmeNYMEXMarket); + data["CmeCBTMarket"] = toUtf(pRspAccount->CmeCBTMarket); + data["IceUSMarket"] = toUtf(pRspAccount->IceUSMarket); + data["IceECMarket"] = toUtf(pRspAccount->IceECMarket); + data["IceEFMarket"] = toUtf(pRspAccount->IceEFMarket); + data["CanTradeStockHK"] = toUtf(pRspAccount->CanTradeStockHK); + data["CanTradeStockAM"] = toUtf(pRspAccount->CanTradeStockAM); + data["MultiLogin"] = toUtf(pRspAccount->MultiLogin); + data["SellStockHK"] = toUtf(pRspAccount->SellStockHK); + data["SellStockAM"] = toUtf(pRspAccount->SellStockAM); + data["CanTradeStockKRX"] = toUtf(pRspAccount->CanTradeStockKRX); + data["HkexMarket"] = toUtf(pRspAccount->HkexMarket); + data["IdNumber"] = toUtf(pRspAccount->IdNumber); + data["HkexMarketFee"] = toUtf(pRspAccount->HkexMarketFee); + data["IsProfessional"] = toUtf(pRspAccount->IsProfessional); + data["IsOverSea"] = toUtf(pRspAccount->IsOverSea); + data["IsFirstLogin"] = toUtf(pRspAccount->IsFirstLogin); + data["UserMobile"] = toUtf(pRspAccount->UserMobile); + data["HasSetQA"] = toUtf(pRspAccount->HasSetQA); + data["CanTradeStockSGXQ"] = toUtf(pRspAccount->CanTradeStockSGXQ); + data["ExistMac"] = toUtf(pRspAccount->ExistMac); + data["RatioINE"] = toUtf(pRspAccount->RatioINE); + data["EurexMarket"] = toUtf(pRspAccount->EurexMarket); + data["HkexIsOverMaxTerminal"] = toUtf(pRspAccount->HkexIsOverMaxTerminal); + data["HkexOverMoney"] = toUtf(pRspAccount->HkexOverMoney); + data["CanTradeStockAU"] = toUtf(pRspAccount->CanTradeStockAU); + data["NyFlag"] = toUtf(pRspAccount->NyFlag); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspAccount(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQuestion(CStockRspQuestionField *pRspQuestion, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspQuestion) + { + data["QuestionType"] = toUtf(pRspQuestion->QuestionType); + data["QuestionId"] = toUtf(pRspQuestion->QuestionId); + data["QuestionCN"] = toUtf(pRspQuestion->QuestionCN); + data["QuestionEN"] = toUtf(pRspQuestion->QuestionEN); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQuestion(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspOrderInsert(CStockRspOrderInsertField *pRspOrderInsert, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspOrderInsert) + { + data["UserId"] = toUtf(pRspOrderInsert->UserId); + data["AccountNo"] = toUtf(pRspOrderInsert->AccountNo); + data["SystemNo"] = toUtf(pRspOrderInsert->SystemNo); + data["LocalNo"] = toUtf(pRspOrderInsert->LocalNo); + data["OrderNo"] = toUtf(pRspOrderInsert->OrderNo); + data["OrigOrderNo"] = toUtf(pRspOrderInsert->OrigOrderNo); + data["OrderMethod"] = toUtf(pRspOrderInsert->OrderMethod); + data["AcceptType"] = toUtf(pRspOrderInsert->AcceptType); + data["ExchangeCode"] = toUtf(pRspOrderInsert->ExchangeCode); + data["TreatyCode"] = toUtf(pRspOrderInsert->TreatyCode); + data["BuySale"] = toUtf(pRspOrderInsert->BuySale); + data["OrderNumber"] = toUtf(pRspOrderInsert->OrderNumber); + data["OrderPrice"] = toUtf(pRspOrderInsert->OrderPrice); + data["FilledNumber"] = toUtf(pRspOrderInsert->FilledNumber); + data["FilledPrice"] = toUtf(pRspOrderInsert->FilledPrice); + data["TradeType"] = toUtf(pRspOrderInsert->TradeType); + data["PriceType"] = toUtf(pRspOrderInsert->PriceType); + data["HtsType"] = toUtf(pRspOrderInsert->HtsType); + data["OrderDate"] = toUtf(pRspOrderInsert->OrderDate); + data["OrderTime"] = toUtf(pRspOrderInsert->OrderTime); + data["ErrorCode"] = toUtf(pRspOrderInsert->ErrorCode); + data["OrderState"] = toUtf(pRspOrderInsert->OrderState); + data["IsRiskOrder"] = toUtf(pRspOrderInsert->IsRiskOrder); + data["CancelUserId"] = toUtf(pRspOrderInsert->CancelUserId); + data["TriggerPrice"] = toUtf(pRspOrderInsert->TriggerPrice); + data["ValidDate"] = toUtf(pRspOrderInsert->ValidDate); + data["AddReduce"] = toUtf(pRspOrderInsert->AddReduce); + data["StrategyId"] = toUtf(pRspOrderInsert->StrategyId); + data["MaxShow"] = toUtf(pRspOrderInsert->MaxShow); + data["MinQty"] = toUtf(pRspOrderInsert->MinQty); + data["ExchangeTime"] = toUtf(pRspOrderInsert->ExchangeTime); + data["CancelTime"] = toUtf(pRspOrderInsert->CancelTime); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspOrderInsert(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspOrderModify(CStockRspOrderModifyField *pRspOrderModify, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspOrderModify) + { + data["UserId"] = toUtf(pRspOrderModify->UserId); + data["AccountNo"] = toUtf(pRspOrderModify->AccountNo); + data["SystemNo"] = toUtf(pRspOrderModify->SystemNo); + data["LocalNo"] = toUtf(pRspOrderModify->LocalNo); + data["OrderNo"] = toUtf(pRspOrderModify->OrderNo); + data["OrigOrderNo"] = toUtf(pRspOrderModify->OrigOrderNo); + data["OrderMethod"] = toUtf(pRspOrderModify->OrderMethod); + data["AcceptType"] = toUtf(pRspOrderModify->AcceptType); + data["ExchangeCode"] = toUtf(pRspOrderModify->ExchangeCode); + data["TreatyCode"] = toUtf(pRspOrderModify->TreatyCode); + data["BuySale"] = toUtf(pRspOrderModify->BuySale); + data["OrderNumber"] = toUtf(pRspOrderModify->OrderNumber); + data["OrderPrice"] = toUtf(pRspOrderModify->OrderPrice); + data["FilledNumber"] = toUtf(pRspOrderModify->FilledNumber); + data["FilledPrice"] = toUtf(pRspOrderModify->FilledPrice); + data["TradeType"] = toUtf(pRspOrderModify->TradeType); + data["PriceType"] = toUtf(pRspOrderModify->PriceType); + data["HtsType"] = toUtf(pRspOrderModify->HtsType); + data["OrderDate"] = toUtf(pRspOrderModify->OrderDate); + data["OrderTime"] = toUtf(pRspOrderModify->OrderTime); + data["ErrorCode"] = toUtf(pRspOrderModify->ErrorCode); + data["OrderState"] = toUtf(pRspOrderModify->OrderState); + data["IsRiskOrder"] = toUtf(pRspOrderModify->IsRiskOrder); + data["CancelUserId"] = toUtf(pRspOrderModify->CancelUserId); + data["TriggerPrice"] = toUtf(pRspOrderModify->TriggerPrice); + data["ValidDate"] = toUtf(pRspOrderModify->ValidDate); + data["AddReduce"] = toUtf(pRspOrderModify->AddReduce); + data["StrategyId"] = toUtf(pRspOrderModify->StrategyId); + data["MaxShow"] = toUtf(pRspOrderModify->MaxShow); + data["MinQty"] = toUtf(pRspOrderModify->MinQty); + data["ExchangeTime"] = toUtf(pRspOrderModify->ExchangeTime); + data["CancelTime"] = toUtf(pRspOrderModify->CancelTime); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspOrderModify(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspOrderCancel(CStockRspOrderCancelField *pRspOrderCancel, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspOrderCancel) + { + data["UserId"] = toUtf(pRspOrderCancel->UserId); + data["AccountNo"] = toUtf(pRspOrderCancel->AccountNo); + data["SystemNo"] = toUtf(pRspOrderCancel->SystemNo); + data["LocalNo"] = toUtf(pRspOrderCancel->LocalNo); + data["OrderNo"] = toUtf(pRspOrderCancel->OrderNo); + data["CancelNo"] = toUtf(pRspOrderCancel->CancelNo); + data["ExchangeCode"] = toUtf(pRspOrderCancel->ExchangeCode); + data["TreatyCode"] = toUtf(pRspOrderCancel->TreatyCode); + data["BuySale"] = toUtf(pRspOrderCancel->BuySale); + data["OrderNumber"] = toUtf(pRspOrderCancel->OrderNumber); + data["OrderPrice"] = toUtf(pRspOrderCancel->OrderPrice); + data["FilledNumber"] = toUtf(pRspOrderCancel->FilledNumber); + data["CancelNumber"] = toUtf(pRspOrderCancel->CancelNumber); + data["TradeType"] = toUtf(pRspOrderCancel->TradeType); + data["PriceType"] = toUtf(pRspOrderCancel->PriceType); + data["HtsType"] = toUtf(pRspOrderCancel->HtsType); + data["CancelDate"] = toUtf(pRspOrderCancel->CancelDate); + data["CancelTime"] = toUtf(pRspOrderCancel->CancelTime); + data["ErrorCode"] = toUtf(pRspOrderCancel->ErrorCode); + data["IsRiskOrder"] = toUtf(pRspOrderCancel->IsRiskOrder); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspOrderCancel(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspPasswordUpdate(CStockRspPasswordUpdateField *pRspPasswordUpdate, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspPasswordUpdate) + { + data["UserId"] = toUtf(pRspPasswordUpdate->UserId); + data["OldPassword"] = toUtf(pRspPasswordUpdate->OldPassword); + data["NewPassword"] = toUtf(pRspPasswordUpdate->NewPassword); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspPasswordUpdate(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRtnTrade(CStockRtnTradeField *pRtnTrade, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRtnTrade) + { + data["UserId"] = toUtf(pRtnTrade->UserId); + data["AccountNo"] = toUtf(pRtnTrade->AccountNo); + data["FilledNo"] = toUtf(pRtnTrade->FilledNo); + data["OrderNo"] = toUtf(pRtnTrade->OrderNo); + data["SystemNo"] = toUtf(pRtnTrade->SystemNo); + data["LocalNo"] = toUtf(pRtnTrade->LocalNo); + data["ExchangeCode"] = toUtf(pRtnTrade->ExchangeCode); + data["TreatyCode"] = toUtf(pRtnTrade->TreatyCode); + data["BuySale"] = toUtf(pRtnTrade->BuySale); + data["FilledNumber"] = toUtf(pRtnTrade->FilledNumber); + data["FilledPrice"] = toUtf(pRtnTrade->FilledPrice); + data["FilledDate"] = toUtf(pRtnTrade->FilledDate); + data["FilledTime"] = toUtf(pRtnTrade->FilledTime); + data["Commsion"] = toUtf(pRtnTrade->Commsion); + data["OrderNumber"] = toUtf(pRtnTrade->OrderNumber); + data["OrderPrice"] = toUtf(pRtnTrade->OrderPrice); + data["DeliveryDate"] = toUtf(pRtnTrade->DeliveryDate); + data["FilledType"] = toUtf(pRtnTrade->FilledType); + data["OrderType"] = toUtf(pRtnTrade->OrderType); + data["ValidDate"] = toUtf(pRtnTrade->ValidDate); + data["AddReduce"] = toUtf(pRtnTrade->AddReduce); + data["ErrorDescription"] = toUtf(pRtnTrade->ErrorDescription); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRtnTrade(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRtnOrder(CStockRtnOrderField *pRtnOrder, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRtnOrder) + { + data["LocalOrderNo"] = toUtf(pRtnOrder->LocalOrderNo); + data["ExchangeNo"] = toUtf(pRtnOrder->ExchangeNo); + data["TreatyCode"] = toUtf(pRtnOrder->TreatyCode); + data["OrderNo"] = toUtf(pRtnOrder->OrderNo); + data["OrderNumber"] = pRtnOrder->OrderNumber; + data["FilledNumber"] = pRtnOrder->FilledNumber; + data["FilledAdvPrice"] = pRtnOrder->FilledAdvPrice; + data["BuyHoldNumber"] = pRtnOrder->BuyHoldNumber; + data["BuyHoldOpenPrice"] = pRtnOrder->BuyHoldOpenPrice; + data["BuyHoldPrice"] = pRtnOrder->BuyHoldPrice; + data["SaleHoldNumber"] = pRtnOrder->SaleHoldNumber; + data["SaleHoldOpenPrice"] = pRtnOrder->SaleHoldOpenPrice; + data["SaleHoldPrice"] = pRtnOrder->SaleHoldPrice; + data["IsCanceled"] = toUtf(pRtnOrder->IsCanceled); + data["FilledTotalFee"] = pRtnOrder->FilledTotalFee; + data["Status"] = pRtnOrder->Status; + data["AccountNo"] = toUtf(pRtnOrder->AccountNo); + data["HoldType"] = toUtf(pRtnOrder->HoldType); + data["HoldMarginBuy"] = pRtnOrder->HoldMarginBuy; + data["HoldMarginSale"] = pRtnOrder->HoldMarginSale; + data["CurrPrice"] = pRtnOrder->CurrPrice; + data["FloatProfit"] = pRtnOrder->FloatProfit; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRtnOrder(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRtnCapital(CStockRtnCapitalField *pRtnCapital, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRtnCapital) + { + data["ClientNo"] = toUtf(pRtnCapital->ClientNo); + data["AccountNo"] = toUtf(pRtnCapital->AccountNo); + data["CurrencyNo"] = toUtf(pRtnCapital->CurrencyNo); + data["Available"] = pRtnCapital->Available; + data["YAvailable"] = pRtnCapital->YAvailable; + data["CanCashOut"] = pRtnCapital->CanCashOut; + data["Money"] = pRtnCapital->Money; + data["ExpiredProfit"] = pRtnCapital->ExpiredProfit; + data["FrozenDeposit"] = pRtnCapital->FrozenDeposit; + data["Fee"] = pRtnCapital->Fee; + data["Deposit"] = pRtnCapital->Deposit; + data["KeepDeposit"] = pRtnCapital->KeepDeposit; + data["Status"] = pRtnCapital->Status; + data["InMoney"] = pRtnCapital->InMoney; + data["OutMoney"] = pRtnCapital->OutMoney; + data["UnexpiredProfit"] = pRtnCapital->UnexpiredProfit; + data["TodayTotal"] = pRtnCapital->TodayTotal; + data["UnaccountProfit"] = pRtnCapital->UnaccountProfit; + data["Royalty"] = pRtnCapital->Royalty; + data["ExchangeNo"] = toUtf(pRtnCapital->ExchangeNo); + data["TreatyCode"] = toUtf(pRtnCapital->TreatyCode); + data["OrderNo"] = toUtf(pRtnCapital->OrderNo); + data["OrderNumber"] = pRtnCapital->OrderNumber; + data["FilledNumber"] = pRtnCapital->FilledNumber; + data["FilledAdvPrice"] = pRtnCapital->FilledAdvPrice; + data["BuyHoldNumber"] = pRtnCapital->BuyHoldNumber; + data["BuyHoldOpenPrice"] = pRtnCapital->BuyHoldOpenPrice; + data["BuyHoldPrice"] = pRtnCapital->BuyHoldPrice; + data["SaleHoldNumber"] = pRtnCapital->SaleHoldNumber; + data["SaleHoldOpenPrice"] = pRtnCapital->SaleHoldOpenPrice; + data["SaleHoldPrice"] = pRtnCapital->SaleHoldPrice; + data["IsCanceled"] = toUtf(pRtnCapital->IsCanceled); + data["FilledTotalFee"] = pRtnCapital->FilledTotalFee; + data["Credit"] = pRtnCapital->Credit; + data["MarginLimit"] = pRtnCapital->MarginLimit; + data["BorrowValue"] = pRtnCapital->BorrowValue; + data["MortgageMoney"] = pRtnCapital->MortgageMoney; + data["T1"] = pRtnCapital->T1; + data["T2"] = pRtnCapital->T2; + data["T3"] = pRtnCapital->T3; + data["TN"] = pRtnCapital->TN; + data["TradeLimit"] = pRtnCapital->TradeLimit; + data["FCrossMax"] = pRtnCapital->FCrossMax; + data["SellFreezenMoney"] = pRtnCapital->SellFreezenMoney; + data["SellInterest"] = pRtnCapital->SellInterest; + data["SellNeedAddMargin"] = pRtnCapital->SellNeedAddMargin; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRtnCapital(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRtnPosition(CStockRtnPositionField *pRtnPosition, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRtnPosition) + { + data["ClientNo"] = toUtf(pRtnPosition->ClientNo); + data["ExchangeNo"] = toUtf(pRtnPosition->ExchangeNo); + data["CommodityNo"] = toUtf(pRtnPosition->CommodityNo); + data["Direct"] = toUtf(pRtnPosition->Direct); + data["HoldPrice"] = pRtnPosition->HoldPrice; + data["CanTradeVol"] = pRtnPosition->CanTradeVol; + data["TodayBuyVol"] = pRtnPosition->TodayBuyVol; + data["FrozenVol"] = pRtnPosition->FrozenVol; + data["TotalBuyMoney"] = pRtnPosition->TotalBuyMoney; + data["TotalSellMoney"] = pRtnPosition->TotalSellMoney; + data["TotalBuyVol"] = pRtnPosition->TotalBuyVol; + data["TotalSellVol"] = pRtnPosition->TotalSellVol; + data["OpenDate"] = toUtf(pRtnPosition->OpenDate); + data["FlatProfit"] = pRtnPosition->FlatProfit; + data["HkexT1"] = pRtnPosition->HkexT1; + data["HkexT2"] = pRtnPosition->HkexT2; + data["HkexT3"] = pRtnPosition->HkexT3; + data["UnsettleVol"] = pRtnPosition->UnsettleVol; + data["SettledVol"] = pRtnPosition->SettledVol; + data["HoldVol"] = pRtnPosition->HoldVol; + data["TodaySaleVol"] = pRtnPosition->TodaySaleVol; + data["SellFrozenMoney"] = pRtnPosition->SellFrozenMoney; + data["OpenPrice"] = pRtnPosition->OpenPrice; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRtnPosition(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryTick(CStockRspTickField *pRspTick, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspTick) + { + data["UpperTickCode"] = toUtf(pRspTick->UpperTickCode); + data["PriceFrom"] = toUtf(pRspTick->PriceFrom); + data["UpperTick"] = toUtf(pRspTick->UpperTick); + data["ProductDot"] = toUtf(pRspTick->ProductDot); + data["DotNum"] = toUtf(pRspTick->DotNum); + data["LowerTick"] = toUtf(pRspTick->LowerTick); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryTick(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryOrder(CStockRspOrderField *pRspOrder, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspOrder) + { + data["UserId"] = toUtf(pRspOrder->UserId); + data["AccountNo"] = toUtf(pRspOrder->AccountNo); + data["SystemNo"] = toUtf(pRspOrder->SystemNo); + data["LocalNo"] = toUtf(pRspOrder->LocalNo); + data["OrderNo"] = toUtf(pRspOrder->OrderNo); + data["OrigOrderNo"] = toUtf(pRspOrder->OrigOrderNo); + data["OrderMethod"] = toUtf(pRspOrder->OrderMethod); + data["AcceptType"] = toUtf(pRspOrder->AcceptType); + data["ExchangeCode"] = toUtf(pRspOrder->ExchangeCode); + data["TreatyCode"] = toUtf(pRspOrder->TreatyCode); + data["BuySale"] = toUtf(pRspOrder->BuySale); + data["OrderNumber"] = toUtf(pRspOrder->OrderNumber); + data["OrderPrice"] = toUtf(pRspOrder->OrderPrice); + data["FilledNumber"] = toUtf(pRspOrder->FilledNumber); + data["FilledPrice"] = toUtf(pRspOrder->FilledPrice); + data["TradeType"] = toUtf(pRspOrder->TradeType); + data["PriceType"] = toUtf(pRspOrder->PriceType); + data["HtsType"] = toUtf(pRspOrder->HtsType); + data["OrderDate"] = toUtf(pRspOrder->OrderDate); + data["OrderTime"] = toUtf(pRspOrder->OrderTime); + data["ErrorCode"] = toUtf(pRspOrder->ErrorCode); + data["OrderState"] = toUtf(pRspOrder->OrderState); + data["IsRiskOrder"] = toUtf(pRspOrder->IsRiskOrder); + data["CancelUserId"] = toUtf(pRspOrder->CancelUserId); + data["TriggerPrice"] = toUtf(pRspOrder->TriggerPrice); + data["ValidDate"] = toUtf(pRspOrder->ValidDate); + data["AddReduce"] = toUtf(pRspOrder->AddReduce); + data["StrategyId"] = toUtf(pRspOrder->StrategyId); + data["MaxShow"] = toUtf(pRspOrder->MaxShow); + data["MinQty"] = toUtf(pRspOrder->MinQty); + data["ExchangeTime"] = toUtf(pRspOrder->ExchangeTime); + data["CancelTime"] = toUtf(pRspOrder->CancelTime); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryOrder(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryTrade(CStockRspTradeField *pRspTrade, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspTrade) + { + data["UserId"] = toUtf(pRspTrade->UserId); + data["AccountNo"] = toUtf(pRspTrade->AccountNo); + data["FilledNo"] = toUtf(pRspTrade->FilledNo); + data["OrderNo"] = toUtf(pRspTrade->OrderNo); + data["SystemNo"] = toUtf(pRspTrade->SystemNo); + data["LocalNo"] = toUtf(pRspTrade->LocalNo); + data["ExchangeCode"] = toUtf(pRspTrade->ExchangeCode); + data["TreatyCode"] = toUtf(pRspTrade->TreatyCode); + data["BuySale"] = toUtf(pRspTrade->BuySale); + data["FilledNumber"] = toUtf(pRspTrade->FilledNumber); + data["FilledPrice"] = toUtf(pRspTrade->FilledPrice); + data["FilledDate"] = toUtf(pRspTrade->FilledDate); + data["FilledTime"] = toUtf(pRspTrade->FilledTime); + data["Commsion"] = toUtf(pRspTrade->Commsion); + data["OrderNumber"] = toUtf(pRspTrade->OrderNumber); + data["OrderPrice"] = toUtf(pRspTrade->OrderPrice); + data["DeliveryDate"] = toUtf(pRspTrade->DeliveryDate); + data["FilledType"] = toUtf(pRspTrade->FilledType); + data["OrderType"] = toUtf(pRspTrade->OrderType); + data["ValidDate"] = toUtf(pRspTrade->ValidDate); + data["AddReduce"] = toUtf(pRspTrade->AddReduce); + data["ErrorDescription"] = toUtf(pRspTrade->ErrorDescription); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryTrade(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryCapital(CStockRspCapitalField *pRspCapital, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspCapital) + { + data["UserId"] = toUtf(pRspCapital->UserId); + data["InMoney"] = toUtf(pRspCapital->InMoney); + data["OutMoney"] = toUtf(pRspCapital->OutMoney); + data["TodayCanUse"] = toUtf(pRspCapital->TodayCanUse); + data["TodayAmount"] = toUtf(pRspCapital->TodayAmount); + data["TodayBalance"] = toUtf(pRspCapital->TodayBalance); + data["FreezenMoney"] = toUtf(pRspCapital->FreezenMoney); + data["Commission"] = toUtf(pRspCapital->Commission); + data["Margin"] = toUtf(pRspCapital->Margin); + data["OldCanUse"] = toUtf(pRspCapital->OldCanUse); + data["OldAmount"] = toUtf(pRspCapital->OldAmount); + data["OldBalance"] = toUtf(pRspCapital->OldBalance); + data["FloatingProfit"] = toUtf(pRspCapital->FloatingProfit); + data["CurrencyNo"] = toUtf(pRspCapital->CurrencyNo); + data["CurrencyRate"] = pRspCapital->CurrencyRate; + data["UnexpiredProfit"] = pRspCapital->UnexpiredProfit; + data["UnaccountProfit"] = pRspCapital->UnaccountProfit; + data["KeepDeposit"] = pRspCapital->KeepDeposit; + data["Royalty"] = pRspCapital->Royalty; + data["Credit"] = pRspCapital->Credit; + data["AddCapital"] = pRspCapital->AddCapital; + data["IniEquity"] = pRspCapital->IniEquity; + data["AccountNo"] = toUtf(pRspCapital->AccountNo); + data["MortgageMoney"] = pRspCapital->MortgageMoney; + data["MarginLimit"] = pRspCapital->MarginLimit; + data["BorrowValue"] = pRspCapital->BorrowValue; + data["T1"] = pRspCapital->T1; + data["T2"] = pRspCapital->T2; + data["T3"] = pRspCapital->T3; + data["TN"] = pRspCapital->TN; + data["TradeLimit"] = pRspCapital->TradeLimit; + data["CanCashOut"] = pRspCapital->CanCashOut; + data["AccruedCrInt"] = pRspCapital->AccruedCrInt; + data["AccruedDrInt"] = pRspCapital->AccruedDrInt; + data["CrossMax"] = pRspCapital->CrossMax; + data["SellFreezenMoney"] = pRspCapital->SellFreezenMoney; + data["SellInterest"] = pRspCapital->SellInterest; + data["SellNeedAddMargin"] = pRspCapital->SellNeedAddMargin; + data["NetProfit"] = toUtf(pRspCapital->NetProfit); + data["ProfitRate"] = toUtf(pRspCapital->ProfitRate); + data["RiskRate"] = toUtf(pRspCapital->RiskRate); + data["ErrorDescription"] = toUtf(pRspCapital->ErrorDescription); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryCapital(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryVersion(CStockRspVersionField *pRspVersion, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspVersion) + { + data["Version"] = toUtf(pRspVersion->Version); + data["MustUpdate"] = toUtf(pRspVersion->MustUpdate); + data["MustVersion"] = toUtf(pRspVersion->MustVersion); + data["VersionContent_CN"] = toUtf(pRspVersion->VersionContent_CN); + data["VersionContent_US"] = toUtf(pRspVersion->VersionContent_US); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryVersion(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryPosition(CStockRspPositionField *pRspPosition, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspPosition) + { + data["ClientNo"] = toUtf(pRspPosition->ClientNo); + data["ExchangeNo"] = toUtf(pRspPosition->ExchangeNo); + data["CommodityNo"] = toUtf(pRspPosition->CommodityNo); + data["Direct"] = toUtf(pRspPosition->Direct); + data["HoldPrice"] = pRspPosition->HoldPrice; + data["CanTradeVol"] = pRspPosition->CanTradeVol; + data["TodayBuyVol"] = pRspPosition->TodayBuyVol; + data["FrozenVol"] = pRspPosition->FrozenVol; + data["TotalBuyMoney"] = pRspPosition->TotalBuyMoney; + data["TotalSellMoney"] = pRspPosition->TotalSellMoney; + data["TotalBuyVol"] = pRspPosition->TotalBuyVol; + data["TotalSellVol"] = pRspPosition->TotalSellVol; + data["OpenDate"] = toUtf(pRspPosition->OpenDate); + data["FlatProfit"] = pRspPosition->FlatProfit; + data["HkexT1"] = pRspPosition->HkexT1; + data["HkexT2"] = pRspPosition->HkexT2; + data["HkexT3"] = pRspPosition->HkexT3; + data["UnsettleVol"] = pRspPosition->UnsettleVol; + data["SettledVol"] = pRspPosition->SettledVol; + data["HoldVol"] = pRspPosition->HoldVol; + data["TodaySaleVol"] = pRspPosition->TodaySaleVol; + data["SellFrozenMoney"] = pRspPosition->SellFrozenMoney; + data["OpenPrice"] = pRspPosition->OpenPrice; + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryPosition(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryCurrency(CStockRspCurrencyField *pRspCurrency, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspCurrency) + { + data["CurrencyNo"] = toUtf(pRspCurrency->CurrencyNo); + data["IsBase"] = pRspCurrency->IsBase; + data["ChangeRate"] = pRspCurrency->ChangeRate; + data["CurrencyName"] = toUtf(pRspCurrency->CurrencyName); + data["CurrencyNameEN"] = toUtf(pRspCurrency->CurrencyNameEN); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryCurrency(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryExchange(CStockRspExchangeField *pRspExchange, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspExchange) + { + data["ExchangeNo"] = toUtf(pRspExchange->ExchangeNo); + data["ExchangeName"] = toUtf(pRspExchange->ExchangeName); + data["SettleType"] = toUtf(pRspExchange->SettleType); + data["NameEN"] = toUtf(pRspExchange->NameEN); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryExchange(data, data, iRequestID, bIsLast); +}; + +void StockApi::OnRspQryInstrument(CStockRspInstrumentField *pRspInstrument, CStockRspInfoField *pRspInfo, int iRequestID, bool bIsLast) +{ + gil_scoped_acquire acquire; + dict data; + if (pRspInstrument) + { + data["ExchangeNo"] = toUtf(pRspInstrument->ExchangeNo); + data["ExchangeName"] = toUtf(pRspInstrument->ExchangeName); + data["CommodityNo"] = toUtf(pRspInstrument->CommodityNo); + data["CommodityName"] = toUtf(pRspInstrument->CommodityName); + data["CommodityType"] = toUtf(pRspInstrument->CommodityType); + data["CurrencyNo"] = toUtf(pRspInstrument->CurrencyNo); + data["CurrencyName"] = toUtf(pRspInstrument->CurrencyName); + data["ProductDot"] = pRspInstrument->ProductDot; + data["UpperTick"] = pRspInstrument->UpperTick; + data["SettlePrice"] = pRspInstrument->SettlePrice; + data["TradeMonth"] = toUtf(pRspInstrument->TradeMonth); + data["DotNum"] = pRspInstrument->DotNum; + data["LowerTick"] = pRspInstrument->LowerTick; + data["DotNumCarry"] = pRspInstrument->DotNumCarry; + data["UpperTickCarry"] = pRspInstrument->UpperTickCarry; + data["FirstNoticeDay"] = toUtf(pRspInstrument->FirstNoticeDay); + data["FreezenPercent"] = pRspInstrument->FreezenPercent; + data["FreezenMoney"] = pRspInstrument->FreezenMoney; + data["FeeMoney"] = pRspInstrument->FeeMoney; + data["FeePercent"] = pRspInstrument->FeePercent; + data["PriceStrike"] = pRspInstrument->PriceStrike; + data["ProductDotStrike"] = pRspInstrument->ProductDotStrike; + data["UpperTickStrike"] = pRspInstrument->UpperTickStrike; + data["LastTradeDay"] = toUtf(pRspInstrument->LastTradeDay); + data["LastUpdateDay"] = toUtf(pRspInstrument->LastUpdateDay); + data["CriticalPrice"] = pRspInstrument->CriticalPrice; + data["CriticalMinChangedPrice"] = pRspInstrument->CriticalMinChangedPrice; + data["ExchangeSub"] = toUtf(pRspInstrument->ExchangeSub); + data["OptionType"] = toUtf(pRspInstrument->OptionType); + data["OptionMonth"] = toUtf(pRspInstrument->OptionMonth); + data["OptionStrikePrice"] = toUtf(pRspInstrument->OptionStrikePrice); + data["OptionCommodityNo"] = toUtf(pRspInstrument->OptionCommodityNo); + data["OptionContractNo"] = toUtf(pRspInstrument->OptionContractNo); + data["MortgagePercent"] = toUtf(pRspInstrument->MortgagePercent); + data["UpperTickCode"] = toUtf(pRspInstrument->UpperTickCode); + data["LotSize"] = toUtf(pRspInstrument->LotSize); + data["FlatTime"] = toUtf(pRspInstrument->FlatTime); + data["CommodityFNameEN"] = toUtf(pRspInstrument->CommodityFNameEN); + data["CanSell"] = toUtf(pRspInstrument->CanSell); + data["SellRate"] = pRspInstrument->SellRate; + data["SellMax"] = pRspInstrument->SellMax; + data["StrikeRate"] = pRspInstrument->StrikeRate; + data["StrikePrice"] = pRspInstrument->StrikePrice; + data["ReceivePrice"] = pRspInstrument->ReceivePrice; + data["ExpireDate"] = toUtf(pRspInstrument->ExpireDate); + data["SellRateKeep"] = pRspInstrument->SellRateKeep; + data["StrikeCommodityNo"] = toUtf(pRspInstrument->StrikeCommodityNo); + data["CallPutFlag"] = toUtf(pRspInstrument->CallPutFlag); + data["Publisher"] = toUtf(pRspInstrument->Publisher); + } + dict data; + if (pRspInfo) + { + data["ErrorID"] = pRspInfo->ErrorID; + data["ErrorMsg"] = toUtf(pRspInfo->ErrorMsg); + } + this->onRspQryInstrument(data, data, iRequestID, bIsLast); +}; + diff --git a/vnpy/api/da/generator/da_stock_struct.py b/vnpy/api/da/generator/da_stock_struct.py index 0d7324aa..896e8e91 100644 --- a/vnpy/api/da/generator/da_stock_struct.py +++ b/vnpy/api/da/generator/da_stock_struct.py @@ -155,7 +155,7 @@ CStockReqOrderModifyField = { "ErrorDescription": "string", } -CStockRspOrderInsertField = CStockRspOrderModifyField +CStockRspOrderModifyField = CStockRspOrderInsertField CStockReqOrderCancelField = { "UserId": "string", @@ -556,9 +556,9 @@ CStockRtnCapitalField = { "SellNeedAddMargin": "double", } -CStockRspPositionField = CStockRtnPositionField +CStockRtnPositionField = CStockRspPositionField -CStockRspTradeField = CStockRtnTradeField +CStockRtnTradeField = CStockRspTradeField CStockReqGetQuestionField = { "Unused": "int", diff --git a/vnpy/api/da/generator/generate_api_functions.py b/vnpy/api/da/generator/generate_api_functions.py index d9dbe612..123b7b92 100644 --- a/vnpy/api/da/generator/generate_api_functions.py +++ b/vnpy/api/da/generator/generate_api_functions.py @@ -21,7 +21,7 @@ class ApiGenerator: def load_struct(self): """加载Struct""" - module_name = f"{self.prefix}_struct" + module_name = f"{self.prefix}_{self.name}_struct" module = importlib.import_module(module_name) for name in dir(module): @@ -37,14 +37,10 @@ class ApiGenerator: self.f_cpp.close() - self.generate_header_define() - self.generate_header_process() self.generate_header_on() self.generate_header_function() self.generate_source_task() - self.generate_source_switch() - self.generate_source_process() self.generate_source_function() self.generate_source_on() self.generate_source_module() @@ -57,10 +53,10 @@ class ApiGenerator: line = line.replace("\n", "") line = line.replace("\t", "") line = line.replace("{}", "") - + if "virtual void On" in line: self.process_callback(line) - elif "virtual int Req" in line: + elif "virtual bool Req" in line: self.process_function(line) def process_callback(self, line: str): @@ -87,28 +83,12 @@ class ApiGenerator: d = {} for arg in args: + arg = arg.replace("const ", "") words = arg.split(" ") words = [word for word in words if word] d[words[1].replace("*", "")] = words[0] return d - def generate_header_define(self): - """""" - filename = f"{self.prefix}_{self.name}_header_define.h" - with open(filename, "w") as f: - for n, name in enumerate(self.callbacks.keys()): - line = f"#define {name.upper()} {n}\n" - f.write(line) - - def generate_header_process(self): - """""" - filename = f"{self.prefix}_{self.name}_header_process.h" - with open(filename, "w") as f: - for name in self.callbacks.keys(): - name = name.replace("On", "process") - line = f"void {name}(Task *task);\n\n" - f.write(line) - def generate_header_on(self): """""" filename = f"{self.prefix}_{self.name}_header_on.h" @@ -117,12 +97,13 @@ class ApiGenerator: name = name.replace("On", "on") args_list = [] + for type_ in d.values(): if type_ == "int": args_list.append("int reqid") elif type_ == "bool": args_list.append("bool last") - elif type_ == "CThostFtdcRspInfoField": + elif type_ == "CMarketRspInfoField": args_list.append("const dict &error") else: args_list.append("const dict &data") @@ -147,58 +128,9 @@ class ApiGenerator: with open(filename, "w") as f: for name, d in self.callbacks.items(): line = self.lines[name] - - f.write(line.replace("virtual void ", - f"void {self.class_name}::") + "\n") - f.write("{\n") - f.write("\tTask task = Task();\n") - f.write(f"\ttask.task_name = {name.upper()};\n") - - for field, type_ in d.items(): - if type_ == "int": - f.write(f"\ttask.task_id = {field};\n") - elif type_ == "bool": - f.write(f"\ttask.task_last = {field};\n") - elif type_ == "CThostFtdcRspInfoField": - f.write(f"\tif ({field})\n") - f.write("\t{\n") - f.write(f"\t\t{type_} *task_error = new {type_}();\n") - f.write(f"\t\t*task_error = *{field};\n") - f.write(f"\t\ttask.task_error = task_error;\n") - f.write("\t}\n") - else: - f.write(f"\tif ({field})\n") - f.write("\t{\n") - f.write(f"\t\t{type_} *task_data = new {type_}();\n") - f.write(f"\t\t*task_data = *{field};\n") - f.write(f"\t\ttask.task_data = task_data;\n") - f.write("\t}\n") - - f.write(f"\tthis->task_queue.push(task);\n") - f.write("};\n\n") - - def generate_source_switch(self): - """""" - filename = f"{self.prefix}_{self.name}_source_switch.cpp" - with open(filename, "w") as f: - for name in self.callbacks.keys(): - process_name = name.replace("On", "process") - f.write(f"case {name.upper()}:\n") - f.write("{\n") - f.write(f"\tthis->{process_name}(&task);\n") - f.write(f"\tbreak;\n") - f.write("}\n\n") - - def generate_source_process(self): - """""" - filename = f"{self.prefix}_{self.name}_source_process.cpp" - with open(filename, "w") as f: - for name, d in self.callbacks.items(): - process_name = name.replace("On", "process") on_name = name.replace("On", "on") - f.write( - f"void {self.class_name}::{process_name}(Task *task)\n") + f.write(line.replace("virtual void ", f"void {self.class_name}::") + "\n") f.write("{\n") f.write("\tgil_scoped_acquire acquire;\n") @@ -206,48 +138,40 @@ class ApiGenerator: for field, type_ in d.items(): if type_ == "int": - args.append("task->task_id") + args.append(field) elif type_ == "bool": - args.append("task->task_last") - elif type_ == "CThostFtdcRspInfoField": + args.append(field) + elif type_ == "char*": + args.append(f"string({field})") + elif type_ == "CMarketRspInfoField": args.append("error") f.write("\tdict error;\n") - f.write("\tif (task->task_error)\n") + f.write("\tif (pRspInfo)\n") f.write("\t{\n") - f.write( - f"\t\t{type_} *task_error = ({type_}*)task->task_error;\n") - + struct_fields = self.structs[type_] for struct_field, struct_type in struct_fields.items(): if struct_type == "string": - f.write( - f"\t\terror[\"{struct_field}\"] = toUtf(task_error->{struct_field});\n") + f.write(f"\t\terror[\"{struct_field}\"] = toUtf({field}->{struct_field});\n") else: - f.write( - f"\t\terror[\"{struct_field}\"] = task_error->{struct_field};\n") + f.write(f"\t\terror[\"{struct_field}\"] = {field}->{struct_field};\n") - f.write("\t\tdelete task_error;\n") f.write("\t}\n") else: args.append("data") f.write("\tdict data;\n") - f.write("\tif (task->task_data)\n") + f.write(f"\tif ({field})\n") f.write("\t{\n") - f.write( - f"\t\t{type_} *task_data = ({type_}*)task->task_data;\n") - + struct_fields = self.structs[type_] for struct_field, struct_type in struct_fields.items(): if struct_type == "string": - f.write( - f"\t\tdata[\"{struct_field}\"] = toUtf(task_data->{struct_field});\n") + f.write(f"\t\tdata[\"{struct_field}\"] = toUtf({field}->{struct_field});\n") else: - f.write( - f"\t\tdata[\"{struct_field}\"] = task_data->{struct_field};\n") + f.write(f"\t\tdata[\"{struct_field}\"] = {field}->{struct_field};\n") - f.write("\t\tdelete task_data;\n") f.write("\t}\n") args_str = ", ".join(args) @@ -296,7 +220,7 @@ class ApiGenerator: elif type_ == "bool": args.append("bool last") bind_args.append("last") - elif type_ == "CThostFtdcRspInfoField": + elif type_ == "CMarketRspInfoField": args.append("const dict &error") bind_args.append("error") else: @@ -336,8 +260,11 @@ class ApiGenerator: if __name__ == "__main__": - md_generator = ApiGenerator("../include/ctp/ThostFtdcMdApi.h", "ctp", "md", "MdApi") - md_generator.run() + market_generator = ApiGenerator("../include/da/DAMarketApi.h", "da", "market", "MarketApi") + market_generator.run() - td_generator = ApiGenerator("../include/ctp/ThostFtdcTraderApi.h", "ctp", "td", "TdApi") - td_generator.run() + future_generator = ApiGenerator("../include/da/DAFutureApi.h", "da", "future", "FutureApi") + future_generator.run() + + stock_generator = ApiGenerator("../include/da/DAStockApi.h", "da", "stock", "StockApi") + stock_generator.run() diff --git a/vnpy/api/da/generator/generate_struct.py b/vnpy/api/da/generator/generate_struct.py index 530ad53b..dc2a79e0 100644 --- a/vnpy/api/da/generator/generate_struct.py +++ b/vnpy/api/da/generator/generate_struct.py @@ -58,7 +58,7 @@ class StructGenerator: words = line.split(" ") name = words[1] value = words[2] - new_line = f"{name} = {value}\n\n" + new_line = f"{value} = {name}\n\n" self.f_struct.write(new_line) def process_declare(self, line: str): diff --git a/vnpy/api/da/include/da/DAFutureApi.h b/vnpy/api/da/include/da/DAFutureApi.h index 035161bf..42c6bdad 100644 --- a/vnpy/api/da/include/da/DAFutureApi.h +++ b/vnpy/api/da/include/da/DAFutureApi.h @@ -14,9 +14,9 @@ class IFutureEvent { //״̬º¯Êý public: - virtual void OnFrontConnected() {}; - virtual void OnFrontDisconnected(int iReason) {}; - virtual void OnHeartBeatWarning(int iTimeLapse) {}; + virtual void OnFrontConnected(){}; + virtual void OnFrontDisconnected(int iReason){}; + virtual void OnHeartBeatWarning(int iTimeLapse){}; //ÇëÇóº¯Êý public: @@ -54,8 +54,8 @@ public: virtual void OnRspQryInstrument(CFutureRspInstrumentField *pRspInstrument, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) {} virtual void OnRspQryExchangeTime(CFutureRspExchangeTimeField *pRspExchangeTime, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) {} virtual void OnRspQryCommodityTime(CFutureRspCommodityTimeField *pRspCommodityTime, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) {} - virtual void OnRspQryTotalPosition(CFutureRspTotalPositionField* pRspTotalPosition, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) {} - virtual void OnRspQryStrategyDetail(CFutureRspStrategyDetailField* pRspStrategyDetail, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) {} + virtual void OnRspQryTotalPosition(CFutureRspTotalPositionField *pRspTotalPosition, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) {} + virtual void OnRspQryStrategyDetail(CFutureRspStrategyDetailField *pRspStrategyDetail, CFutureRspInfoField *pRspInfo, int iRequestID, bool bIsLast) {} }; class DA_API_EXPORT CFutureApi @@ -63,12 +63,12 @@ class DA_API_EXPORT CFutureApi // ¾²Ì¬º¯Êý public: static const char *GetVersion(); - static CFutureApi *CreateFutureApi(bool bRecordLog, const char* lpszLogFileName = "Future.log"); + static CFutureApi *CreateFutureApi(bool bRecordLog, const char *lpszLogFileName = "Future.log"); // ¹¹Ô캯Êý public: - CFutureApi() {}; - virtual ~CFutureApi() {}; + CFutureApi(){}; + virtual ~CFutureApi(){}; // ³õʼ»¯º¯Êý public: @@ -90,7 +90,7 @@ public: virtual bool ReqOrderModify(CFutureReqOrderModifyField *pReqOrderModify, int iRequestID) = 0; virtual bool ReqOrderCancel(CFutureReqOrderCancelField *pReqOrderCancel, int iRequestID) = 0; virtual bool ReqPasswordUpdate(CFutureReqPasswordUpdateField *pReqPasswordUpdate, int iRequestID) = 0; - + // ²éѯº¯Êý public: virtual bool ReqQryOrder(CFutureQryOrderField *pQryOrder, int iRequestID) = 0; @@ -108,4 +108,3 @@ public: virtual bool ReqQryTotalPosition(CFutureQryTotalPositionField *pQryTotalPosition, int iRequestID) = 0; virtual bool ReqQryStrategyDetail(CFutureQryStrategyDetailField *pQryStrategyDetail, int iRequestID) = 0; }; - diff --git a/vnpy/api/da/include/da/DAMarketApi.h b/vnpy/api/da/include/da/DAMarketApi.h index 27edb64c..d9a26b77 100644 --- a/vnpy/api/da/include/da/DAMarketApi.h +++ b/vnpy/api/da/include/da/DAMarketApi.h @@ -12,13 +12,13 @@ class IMarketEvent { - //״̬º¯Êý + //״̬���� public: virtual void OnFrontConnected() {}; virtual void OnFrontDisconnected(int iReason) {}; virtual void OnHeartBeatWarning(int iTimeLapse) {}; - //ÇëÇóº¯Êý + //������ public: virtual void OnRspRawData(const char* rawData) {} virtual void OnRspUserLogin(CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast) {}; @@ -29,17 +29,17 @@ public: class DA_API_EXPORT CMarketApi { - // ¾²Ì¬º¯Êý + // ��̬���� public: static const char *GetVersion(); static CMarketApi *CreateMarketApi(bool bRecordLog, const char* lpszLogFileName = "Market.log"); - // ¹¹Ô캯Êý + // ���캯�� public: CMarketApi() {}; virtual ~CMarketApi() {}; - // ³õʼ»¯º¯Êý + // ��ʼ������ public: virtual bool Init() = 0; virtual void Release() = 0; @@ -47,11 +47,11 @@ public: virtual void RegisterSpi(IMarketEvent *pIMarketEvent) = 0; virtual void RegisterNameServer(const char *pszNsAddress) = 0; - // ÇëÇóº¯Êý + // ������ public: virtual bool ReqUserLogin(CMarketReqUserLoginField *pReqUserLoginField, int iRequestID) = 0; - virtual bool ReqBrokerData(CMarketReqBrokerDataField* pReqBrokerDataField, int iRequestID) = 0; - virtual bool ReqMarketData(CMarketReqMarketDataField* pReqMarketDataField, int iRequestID) = 0; + virtual bool ReqBrokerData(CMarketReqBrokerDataField *pReqBrokerDataField, int iRequestID) = 0; + virtual bool ReqMarketData(CMarketReqMarketDataField *pReqMarketDataField, int iRequestID) = 0; }; diff --git a/vnpy/api/da/libs/_DAApi_x64.lib b/vnpy/api/da/libs/_DAApi_x64.lib deleted file mode 100644 index c45b37cc12f591f96e008c2616ac9027af7f1f87..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7110 zcmcIpy;B=U6#pS0*fN%d#J49iieoz@As{dk_QZ)!;v>NZO!yj43LgY1vBo$svY5%Z zN#}8qKfsmi{0WRF1%=0T3KuC;q;TcZEqQylce{7m+tVSqnWw$o_jcd+zTML&x3_CM z55J9%XS~l>6W+el%kr0rTrOw7Zp8t70dyY%iT6Nq1W0|bq4zDoAobLS{u00-)nP;L z1Hu#ZJh!3m2w;$YXG7l|>Jy}QZRmeZ^9crs*T5_=I0_8Ev0;eb84SX z*NZ3=vNKEDwMUgYEn^rz%oU5q{U2$q>f?Pg09hzZ$a6M)bCgKcQpLH_X4Wut++31E zVM^x7`AJi%V8Y_@YV`;ciV+B&hr$N|8QCt$Hv9zpKV?7;{ zWUaop^C&>!MjX>uj5ey9W}Kj&O!JDf6(0m}*bTf-03%7@ zLkf7?3p}N^)DLt}`+)k-dw`=p;9VNHL+viLuL*xR0L&7M(n4>BsT~65seMWP`OCm7 z>Qli&9Ov*6I*>p&&Z83-aRFVpgnsm55Pe8v0Bwi`()A#Tl!v~KRZm_%&4y08=TCB-Zjp7}zlAoe~AX|^&P9lpu~kU)x6 z{e`vpg6~r-@F*mBX^N`0CQ6*N)spLH*Dc}N<|~L`ByT9Eu%C0uj-<&se$g)4?xS*LW9n zxxgPzhqnfjrLk&xyS{yO(m_!f!ruh{@qu<~4P=ivU7in9r2t~Y&!J=E1~Nx6YWt}A zuqWYF>NBL1T{O&=XHS9_c~MO*Rd;H8PxgMUXGT^(&nzx1-?h=+Un-wqvM`{EX}vKS zI;}S^Ba&oi@9{o~{G!^{c6=<)B62VpV{kM#sOYkhht7zlqs@!cOfecF5i~h5!p1*k zKm1{90k?UNH8I?$-;-{Ry0G!;9Ue84xf@c{#H^_K%aV}E38&# zI`M9!y+(CwXLaBG%)+*8UpJhqPU9HoDis^wd89SoI*r={c%OpC&gSFu@t0)h4$f87 zO|8O_^EWrG_VG31-Kpl?sBmVi2H{E|NyjAfV;&_R9 zHrmyyMg4WsB!x7>>iSDti_%O7Wd7G=n;s#J>ksV*!4_r7Ycep!WRY)>%8RB~fT(ez e +#include +#include +#include +#include + +#include "pybind11/pybind11.h" + + +using namespace std; +using namespace pybind11; + + +//´Ó×ÖµäÖлñȡij¸ö½¨Öµ¶ÔÓ¦µÄÕûÊý£¬²¢¸³Öµµ½ÇëÇó½á¹¹Ìå¶ÔÏóµÄÖµÉÏ +void getInt(const dict &d, const char *key, int *value) +{ + if (d.contains(key)) //¼ì²é×ÖµäÖÐÊÇ·ñ´æÔڸüüÖµ + { + object o = d[key]; //»ñÈ¡¸Ã¼üÖµ + *value = o.cast(); + } +}; + + +//´Ó×ÖµäÖлñȡij¸ö½¨Öµ¶ÔÓ¦µÄ¸¡µãÊý£¬²¢¸³Öµµ½ÇëÇó½á¹¹Ìå¶ÔÏóµÄÖµÉÏ +void getDouble(const dict &d, const char *key, double *value) +{ + if (d.contains(key)) + { + object o = d[key]; + *value = o.cast(); + } +}; + + +//´Ó×ÖµäÖлñȡij¸ö½¨Öµ¶ÔÓ¦µÄ×Ö·û£¬²¢¸³Öµµ½ÇëÇó½á¹¹Ìå¶ÔÏóµÄÖµÉÏ +void getChar(const dict &d, const char *key, char *value) +{ + if (d.contains(key)) + { + object o = d[key]; + *value = o.cast(); + } +}; + + +template +using string_literal = char[size]; + +//´Ó×ÖµäÖлñȡij¸ö½¨Öµ¶ÔÓ¦µÄ×Ö·û´®£¬²¢¸³Öµµ½ÇëÇó½á¹¹Ìå¶ÔÏóµÄÖµÉÏ +template +void getString(const pybind11::dict &d, const char *key, string_literal &value) +{ + if (d.contains(key)) + { + object o = d[key]; + string s = o.cast(); + const char *buf = s.c_str(); + strcpy(value, buf); + } +}; + +//½«GBK±àÂëµÄ×Ö·û´®×ª»»ÎªUTF8 +inline string toUtf(const string &gb2312) +{ +#ifdef _MSC_VER + const static locale loc("zh-CN"); +#else + const static locale loc("zh_CN.GB18030"); +#endif + + vector wstr(gb2312.size()); + wchar_t* wstrEnd = nullptr; + const char* gbEnd = nullptr; + mbstate_t state = {}; + int res = use_facet > + (loc).in(state, + gb2312.data(), gb2312.data() + gb2312.size(), gbEnd, + wstr.data(), wstr.data() + wstr.size(), wstrEnd); + + if (codecvt_base::ok == res) + { + wstring_convert> cutf8; + return cutf8.to_bytes(wstring(wstr.data(), wstrEnd)); + } + + return string(); +} diff --git a/vnpy/api/da/vnda/vnda.sln b/vnpy/api/da/vnda/vnda.sln new file mode 100644 index 00000000..4b2114d7 --- /dev/null +++ b/vnpy/api/da/vnda/vnda.sln @@ -0,0 +1,51 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.28010.2003 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vndamarket", "vndamarket\vndamarket.vcxproj", "{2F6FA88B-CD40-465C-860E-2FCC354CBB11}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vndafuture", "vndafuture\vndafuture.vcxproj", "{0B01BFAB-DB45-4B6E-AB61-0870DD596339}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vndastock", "vndastock\vndastock.vcxproj", "{7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {2F6FA88B-CD40-465C-860E-2FCC354CBB11}.Debug|x64.ActiveCfg = Debug|x64 + {2F6FA88B-CD40-465C-860E-2FCC354CBB11}.Debug|x64.Build.0 = Debug|x64 + {2F6FA88B-CD40-465C-860E-2FCC354CBB11}.Debug|x86.ActiveCfg = Debug|Win32 + {2F6FA88B-CD40-465C-860E-2FCC354CBB11}.Debug|x86.Build.0 = Debug|Win32 + {2F6FA88B-CD40-465C-860E-2FCC354CBB11}.Release|x64.ActiveCfg = Release|x64 + {2F6FA88B-CD40-465C-860E-2FCC354CBB11}.Release|x64.Build.0 = Release|x64 + {2F6FA88B-CD40-465C-860E-2FCC354CBB11}.Release|x86.ActiveCfg = Release|Win32 + {2F6FA88B-CD40-465C-860E-2FCC354CBB11}.Release|x86.Build.0 = Release|Win32 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339}.Debug|x64.ActiveCfg = Debug|x64 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339}.Debug|x64.Build.0 = Debug|x64 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339}.Debug|x86.ActiveCfg = Debug|Win32 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339}.Debug|x86.Build.0 = Debug|Win32 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339}.Release|x64.ActiveCfg = Release|x64 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339}.Release|x64.Build.0 = Release|x64 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339}.Release|x86.ActiveCfg = Release|Win32 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339}.Release|x86.Build.0 = Release|Win32 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}.Debug|x64.ActiveCfg = Debug|x64 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}.Debug|x64.Build.0 = Debug|x64 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}.Debug|x86.ActiveCfg = Debug|Win32 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}.Debug|x86.Build.0 = Debug|Win32 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}.Release|x64.ActiveCfg = Release|x64 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}.Release|x64.Build.0 = Release|x64 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}.Release|x86.ActiveCfg = Release|Win32 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {8B2AFD3D-5C06-4ABA-9980-87896FEFA9BC} + EndGlobalSection +EndGlobal diff --git a/vnpy/api/da/vnda/vndafuture/dllmain.cpp b/vnpy/api/da/vnda/vndafuture/dllmain.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bc73c03e2243f021cfbdb113030fb209176fe945 GIT binary patch literal 848 zcmbu7!AiqW5JfL875^dVCW2Vkx~itoLR&R$6%iU@TZvdrN!lukyYAh%@=yF8|3f|R zwOK?FqB6XYH_W|r@67vnFR3I)eGQ3gg}T&@w$#&zaJ0jDIjc1td8!kRp1ba3<^HKV zn+}fNTCby}?Nu#n-Qs$1OyC+&x29BM{zF~p4#tR#sWfL#2ZUiO>rgdS)Kpu(PRV#y zNn@eJB~w*{YEK;y748xD80HC;18rJHhkWtybONIfr@5H`f2n-K)<5J>scxD47@ZML+(KUFJlVAJe8#U)nC&~j zgO7)OCf_0gHr6J}WU9Olv(1d@JGM=Y53D{W{iQ?U44=Z+lAWbrx~;{u-rj{=9w`abMCbQ(MXqDk^8ZE2}J;6^+mjlLOHptjtir zPz1C+ogo)UDlp_T!Wldn{1}WGj2Pk>d>C9A9D%%eFzEuMeW4->K$X}b#JA`CKqi6AOaZ#G z92jm23?`AF(9!jql$FfaW6G0E!PgxW7Pp5aw!x hr)0B4ipFb{a#!`oF-&jlY$+=XyynNAVG;>a1pvGWW1|27 literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vnda/vndafuture/targetver.h b/vnpy/api/da/vnda/vndafuture/targetver.h new file mode 100644 index 0000000000000000000000000000000000000000..7f8bdf09a6d7392ba6d17f1672874cb1e1eec24f GIT binary patch literal 368 zcmezWPnn^Bp@<=oA)O%?NGdSoGvqNOGo&)`GH`*hK7&3`lr{KGk^)08gA0Q<5QE4t zpqe5EJ%$XREL+U1XivZQ!5XD4Wen*zW_c9pq_>nQFoZK?0!>Q+npw_J3{+Pf_aT_c z0M+EC$T{haomPHN{d|LP>5(rLNSYF-QOaG_AIJ0mdpE>25Yr)ULb!(Ke_0&J28g@a zViXwSf$s2R@MAD$FoLuF7(#&V>5tymomX$=*Vw6_%9z|z267+If3rfqklsLiK1TRK Z8SKMkh8%`cpg&WAX4>EgB|C6v0ssTXQbPa$ literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vnda/vndafuture/vndafuture.cpp b/vnpy/api/da/vnda/vndafuture/vndafuture.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fe6e5042733017f9de6f0d6d6cc3db1bda72f878 GIT binary patch literal 142 zcmezWPoF`bL4l!+A&()2A(0`Cp_HKnh>I9f8T1&E847? + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 15.0 + {0B01BFAB-DB45-4B6E-AB61-0870DD596339} + Win32Proj + vndafuture + 10.0.17763.0 + + + + DynamicLibrary + true + v141 + Unicode + + + DynamicLibrary + false + v141 + true + Unicode + + + DynamicLibrary + true + v141 + Unicode + + + DynamicLibrary + false + v141 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + Use + Level3 + Disabled + true + WIN32;_DEBUG;VNDAFUTURE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Use + Level3 + Disabled + true + _DEBUG;VNDAFUTURE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Use + Level3 + MaxSpeed + true + true + true + WIN32;NDEBUG;VNDAFUTURE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + Use + Level3 + MaxSpeed + true + true + true + NDEBUG;VNDAFUTURE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + \ No newline at end of file diff --git a/vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.filters b/vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.filters new file mode 100644 index 00000000..3392dee3 --- /dev/null +++ b/vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.filters @@ -0,0 +1,45 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + + + æºæ–‡ä»¶ + + + æºæ–‡ä»¶ + + + æºæ–‡ä»¶ + + + \ No newline at end of file diff --git a/vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.user b/vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.user new file mode 100644 index 00000000..be250787 --- /dev/null +++ b/vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/vnpy/api/da/vnda/vndamarket/dllmain.cpp b/vnpy/api/da/vnda/vndamarket/dllmain.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bc73c03e2243f021cfbdb113030fb209176fe945 GIT binary patch literal 848 zcmbu7!AiqW5JfL875^dVCW2Vkx~itoLR&R$6%iU@TZvdrN!lukyYAh%@=yF8|3f|R zwOK?FqB6XYH_W|r@67vnFR3I)eGQ3gg}T&@w$#&zaJ0jDIjc1td8!kRp1ba3<^HKV zn+}fNTCby}?Nu#n-Qs$1OyC+&x29BM{zF~p4#tR#sWfL#2ZUiO>rgdS)Kpu(PRV#y zNn@eJB~w*{YEK;y748xD80HC;18rJHhkWtybONIfr@5H`f2n-K)<5J>scxD47@ZML+(KUFJlVAJe8#U)nC&~j zgO7)OCf_0gHr6J}WU9Olv(1d@JGM=Y53D{W{iQ?U44=Z+lAWbrx~;{u-rj{=9w`abMCbQ(MXqDk^8ZE2}J;6^+mjlLOHptjtir zPz1C+ogo)UDlp_T!Wldn{1}WGj2Pk>d>C9A9D%%eFzEuMeW4->K$X}b#JA`CKqi6AOaZ#G z92jm23?`AF(9!jql$FfaW6G0E!PgxW7Pp5aw!x hr)0B4ipFb{a#!`oF-&jlY$+=XyynNAVG;>a1pvGWW1|27 literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vnda/vndamarket/targetver.h b/vnpy/api/da/vnda/vndamarket/targetver.h new file mode 100644 index 0000000000000000000000000000000000000000..7f8bdf09a6d7392ba6d17f1672874cb1e1eec24f GIT binary patch literal 368 zcmezWPnn^Bp@<=oA)O%?NGdSoGvqNOGo&)`GH`*hK7&3`lr{KGk^)08gA0Q<5QE4t zpqe5EJ%$XREL+U1XivZQ!5XD4Wen*zW_c9pq_>nQFoZK?0!>Q+npw_J3{+Pf_aT_c z0M+EC$T{haomPHN{d|LP>5(rLNSYF-QOaG_AIJ0mdpE>25Yr)ULb!(Ke_0&J28g@a zViXwSf$s2R@MAD$FoLuF7(#&V>5tymomX$=*Vw6_%9z|z267+If3rfqklsLiK1TRK Z8SKMkh8%`cpg&WAX4>EgB|C6v0ssTXQbPa$ literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vnda/vndamarket/vndamarket.cpp b/vnpy/api/da/vnda/vndamarket/vndamarket.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bc75a6e6e071066fe436552925b64e47fc3de425 GIT binary patch literal 24416 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 literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vnda/vndamarket/vndamarket.h b/vnpy/api/da/vnda/vndamarket/vndamarket.h new file mode 100644 index 00000000..0322705a --- /dev/null +++ b/vnpy/api/da/vnda/vndamarket/vndamarket.h @@ -0,0 +1,91 @@ +//ϵͳ +#ifdef WIN32 +#include "stdafx.h" +#endif + +#include + +#include "vnda.h" +#include "pybind11/pybind11.h" +#include "da/DAMarketApi.h" + +using namespace pybind11; +using namespace std; + +///------------------------------------------------------------------------------------- +///C++ SPIµÄ»Øµ÷º¯Êý·½·¨ÊµÏÖ +///------------------------------------------------------------------------------------- + +//APIµÄ¼Ì³ÐʵÏÖ +class MarketApi : public IMarketEvent +{ +private: + CMarketApi* api; //API¶ÔÏó + +public: + MarketApi() + { + }; + + ~MarketApi() + { + }; + + //------------------------------------------------------------------------------------- + //API»Øµ÷º¯Êý + //------------------------------------------------------------------------------------- + + void OnFrontConnected(); + void OnFrontDisconnected(int iReason); + void OnHeartBeatWarning(int iTimeLapse); + + void OnRspRawData(const char* rawData); + void OnRspUserLogin(CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast); + void OnRspTradeDate(CMarketRspTradeDateField *pRspTradeDate, CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast); + void OnRspBrokerData(CMarketRspBrokerDataField *pRspBrokerData, CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast); + void OnRspMarketData(CMarketRspMarketDataField *pRspMarketData, CMarketRspInfoField *pRspInfo, int iRequestID, bool bIsLast); + + //------------------------------------------------------------------------------------- + //Python»Øµ÷º¯Êý + //------------------------------------------------------------------------------------- + + virtual void onFrontConnected() {}; + + virtual void onFrontDisconnected(int reqid) {}; + + virtual void onHeartBeatWarning(int reqid) {}; + + virtual void onRspRawData(string data) {}; + + virtual void onRspUserLogin(const dict &error, int reqid, bool last) {}; + + virtual void onRspTradeDate(const dict &data, const dict &error, int reqid, bool last) {}; + + virtual void onRspBrokerData(const dict &data, const dict &error, int reqid, bool last) {}; + + virtual void onRspMarketData(const dict &data, const dict &error, int reqid, bool last) {}; + + //------------------------------------------------------------------------------------- + //req:Ö÷¶¯º¯ÊýµÄÇëÇó×Öµä + //------------------------------------------------------------------------------------- + + string getVersion(); + + void createMarketApi(bool recordLog, string logFileName); + + void init(); + + void release(); + + int exit(); + + void setHeartbeatTimeout(int timeout); + + void registerNameServer(string address); + + int reqUserLogin(const dict &req, int reqid); + + int reqBrokerData(const dict &req, int reqid); + + int reqMarketData(const dict &req, int reqid); +}; diff --git a/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj b/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj new file mode 100644 index 00000000..2f390b16 --- /dev/null +++ b/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj @@ -0,0 +1,178 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 15.0 + {2F6FA88B-CD40-465C-860E-2FCC354CBB11} + Win32Proj + vndamarket + 10.0.17763.0 + + + + DynamicLibrary + true + v141 + Unicode + + + DynamicLibrary + false + v141 + true + Unicode + + + DynamicLibrary + true + v141 + Unicode + + + DynamicLibrary + false + v141 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + $(SolutionDir)..\ + .pyd + C:\Miniconda3\include;$(SolutionDir);$(SolutionDir)..\include;$(SolutionDir)..\include\da;$(IncludePath) + C:\Miniconda3\libs;$(SolutionDir)..\libs;$(LibraryPath) + + + + Use + Level3 + Disabled + true + WIN32;_DEBUG;VNDAMARKET_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Use + Level3 + Disabled + true + _DEBUG;VNDAMARKET_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Use + Level3 + MaxSpeed + true + true + true + WIN32;NDEBUG;VNDAMARKET_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + Use + Level3 + MaxSpeed + true + true + true + NOMINMAX;_CRT_SECURE_NO_WARNINGS;NDEBUG;VNDAMARKET_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + MultiThreaded + + + Windows + true + true + true + C:\GitHub\vnpy\vnpy\api\da\libs;C:\Miniconda3\libs;%(AdditionalLibraryDirectories) + DAApi_x64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies) + + + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + \ No newline at end of file diff --git a/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.filters b/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.filters new file mode 100644 index 00000000..fa4e4680 --- /dev/null +++ b/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.filters @@ -0,0 +1,51 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + + + æºæ–‡ä»¶ + + + æºæ–‡ä»¶ + + + æºæ–‡ä»¶ + + + \ No newline at end of file diff --git a/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.user b/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.user new file mode 100644 index 00000000..be250787 --- /dev/null +++ b/vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/vnpy/api/da/vnda/vndastock/dllmain.cpp b/vnpy/api/da/vnda/vndastock/dllmain.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bc73c03e2243f021cfbdb113030fb209176fe945 GIT binary patch literal 848 zcmbu7!AiqW5JfL875^dVCW2Vkx~itoLR&R$6%iU@TZvdrN!lukyYAh%@=yF8|3f|R zwOK?FqB6XYH_W|r@67vnFR3I)eGQ3gg}T&@w$#&zaJ0jDIjc1td8!kRp1ba3<^HKV zn+}fNTCby}?Nu#n-Qs$1OyC+&x29BM{zF~p4#tR#sWfL#2ZUiO>rgdS)Kpu(PRV#y zNn@eJB~w*{YEK;y748xD80HC;18rJHhkWtybONIfr@5H`f2n-K)<5J>scxD47@ZML+(KUFJlVAJe8#U)nC&~j zgO7)OCf_0gHr6J}WU9Olv(1d@JGM=Y53D{W{iQ?U44=Z+lAWbrx~;{u-rj{=9w`abMCbQ(MXqDk^8ZE2}J;6^+mjlLOHptjtir zPz1C+ogo)UDlp_T!Wldn{1}WGj2Pk>d>C9A9D%%eFzEuMeW4->K$X}b#JA`CKqi6AOaZ#G z92jm23?`AF(9!jql$FfaW6G0E!PgxW7Pp5aw!x hr)0B4ipFb{a#!`oF-&jlY$+=XyynNAVG;>a1pvGWW1|27 literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vnda/vndastock/targetver.h b/vnpy/api/da/vnda/vndastock/targetver.h new file mode 100644 index 0000000000000000000000000000000000000000..7f8bdf09a6d7392ba6d17f1672874cb1e1eec24f GIT binary patch literal 368 zcmezWPnn^Bp@<=oA)O%?NGdSoGvqNOGo&)`GH`*hK7&3`lr{KGk^)08gA0Q<5QE4t zpqe5EJ%$XREL+U1XivZQ!5XD4Wen*zW_c9pq_>nQFoZK?0!>Q+npw_J3{+Pf_aT_c z0M+EC$T{haomPHN{d|LP>5(rLNSYF-QOaG_AIJ0mdpE>25Yr)ULb!(Ke_0&J28g@a zViXwSf$s2R@MAD$FoLuF7(#&V>5tymomX$=*Vw6_%9z|z267+If3rfqklsLiK1TRK Z8SKMkh8%`cpg&WAX4>EgB|C6v0ssTXQbPa$ literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vnda/vndastock/vndastock.cpp b/vnpy/api/da/vnda/vndastock/vndastock.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b0b1f26ab3644cc79cf2a2a42b7d2bd7520bd116 GIT binary patch literal 140 zcmezWPoF`bL4l!+A&()2A(5e&p@boyA(eJ(BxF0E+w$(AY0NH ODuCu^07YP`K{NoVm>WR= literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vnda/vndastock/vndastock.vcxproj b/vnpy/api/da/vnda/vndastock/vndastock.vcxproj new file mode 100644 index 00000000..653a9af8 --- /dev/null +++ b/vnpy/api/da/vnda/vndastock/vndastock.vcxproj @@ -0,0 +1,169 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 15.0 + {7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3} + Win32Proj + vndastock + 10.0.17763.0 + + + + DynamicLibrary + true + v141 + Unicode + + + DynamicLibrary + false + v141 + true + Unicode + + + DynamicLibrary + true + v141 + Unicode + + + DynamicLibrary + false + v141 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + Use + Level3 + Disabled + true + WIN32;_DEBUG;VNDASTOCK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Use + Level3 + Disabled + true + _DEBUG;VNDASTOCK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Use + Level3 + MaxSpeed + true + true + true + WIN32;NDEBUG;VNDASTOCK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + Use + Level3 + MaxSpeed + true + true + true + NDEBUG;VNDASTOCK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + \ No newline at end of file diff --git a/vnpy/api/da/vnda/vndastock/vndastock.vcxproj.filters b/vnpy/api/da/vnda/vndastock/vndastock.vcxproj.filters new file mode 100644 index 00000000..a9054452 --- /dev/null +++ b/vnpy/api/da/vnda/vndastock/vndastock.vcxproj.filters @@ -0,0 +1,45 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + + + æºæ–‡ä»¶ + + + æºæ–‡ä»¶ + + + æºæ–‡ä»¶ + + + \ No newline at end of file diff --git a/vnpy/api/da/vnda/vndastock/vndastock.vcxproj.user b/vnpy/api/da/vnda/vndastock/vndastock.vcxproj.user new file mode 100644 index 00000000..be250787 --- /dev/null +++ b/vnpy/api/da/vnda/vndastock/vndastock.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/vnpy/api/da/vndamarket.lib b/vnpy/api/da/vndamarket.lib new file mode 100644 index 0000000000000000000000000000000000000000..7bc14c1a1a0b15b198b8443f4324e51ac1be2202 GIT binary patch literal 1784 zcmcIl%TC)s6g_rQ9##brk0p{3h?WH*1RMzoAp@z@h!CO>BzA)vlO{qTQ3yz^*k#3s z@CB?`@Chtgvgne32>04EBo;1@su{^M_ujeooO2)J={2WWs;nD}W^gPl1$Ct*q_AWu z>Cgc11<-DQ$PDp-9k~Mf9!1)GWp_eL7bnsPR(f^AGIJvZa>5bwB@)wztYAg7eYONt&+ds`H)nybVN;ewt6anUlTYJExh$uAZG)F>l z{2N;#!tuWqg>Hc2jSF|td@oy8A|>;7Xt?bNIyAw<`6CS!F4#!iNxzgdBSwNw=P5t7+c58RS|>5gDn^2&zF|Bz zNM`;#j}eTbTp8P`mYVg`dbwqOFU*_SOm5rX4$famWi0%F^2HKkpj46+Jcy8#>a_+z zE>|?I)9HPS+`$-iDCRccp{^*4$I(Aa`mC@Iy@VGZt7~EV3{P_K*MT*u@uK5^=6>`} zkoWslleCt5sz&#!=GH^VIK!*P^|xN;o~l_^My{G`rO1`5reD?Yk^D{(j=x?=#-}5< zn(T?3-*1m}f}id1$i2~TmJE{Duc{%G&4#V|ZAIC*uOE~mSN7{igg+8plQ8_(`%D$4 X$$ua2S+~u1+O)?t8ge@aGYI1u5)NdQ literal 0 HcmV?d00001 diff --git a/vnpy/api/da/vndamarket.pyd b/vnpy/api/da/vndamarket.pyd new file mode 100644 index 0000000000000000000000000000000000000000..3d7f4f7c4aa15fb6a4e3d5443d89b2a917603461 GIT binary patch literal 680448 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 z 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 z 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 literal 0 HcmV?d00001