[Add] DA market api

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:

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);
+

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) {};
+

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;
+};
+

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)
+;

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;
+	}
+};
+

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);
+};
+

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",

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);
+

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) {};
+

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;
+};
+

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)
+;

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;
+	}
+};
+

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);
+};
+

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);
+

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) {};
+

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;
+};
+

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)
+;

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;
+	}
+};
+

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);
+};
+

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",

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()

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):

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

vnpy/api/da/include/da/DAMarketApi.h

@@ -12,13 +12,13 @@
 
 class IMarketEvent
 {
-	//状态函数
+	//״̬<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 public:
 	virtual void OnFrontConnected() {};
 	virtual void OnFrontDisconnected(int iReason) {};
 	virtual void OnHeartBeatWarning(int iTimeLapse) {};
 
-	//请求函数
+	//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 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
 {
-	// 静态函数
+	// <EFBFBD><EFBFBD>̬<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 public:
 	static const char *GetVersion();
 	static CMarketApi *CreateMarketApi(bool bRecordLog, const char* lpszLogFileName = "Market.log");
 
-	// 构造函数
+	// <EFBFBD><EFBFBD><EFBFBD>캯<EFBFBD><EFBFBD>
 public:
 	CMarketApi() {};
 	virtual ~CMarketApi() {};
 
-	// 初始化函数
+	// <EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 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;
 
-	// 请求函数
+	// <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 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;
 };
 
 

vnpy/api/da/vnda/vnda.h

@@ -0,0 +1,88 @@
+#include <string>
+#include <iostream>
+#include <codecvt>
+#include <condition_variable>
+#include <locale>
+
+#include "pybind11/pybind11.h"
+
+
+using namespace std;
+using namespace pybind11;
+
+
+//从字典中获取某个建值对应的整数，并赋值到请求结构体对象的值上
+void getInt(const dict &d, const char *key, int *value)
+{
+    if (d.contains(key))		//检查字典中是否存在该键值
+    {
+        object o = d[key];		//获取该键值
+        *value = o.cast<int>();
+    }
+};
+
+
+//从字典中获取某个建值对应的浮点数，并赋值到请求结构体对象的值上
+void getDouble(const dict &d, const char *key, double *value)
+{
+    if (d.contains(key))
+    {
+        object o = d[key];
+        *value = o.cast<double>();
+    }
+};
+
+
+//从字典中获取某个建值对应的字符，并赋值到请求结构体对象的值上
+void getChar(const dict &d, const char *key, char *value)
+{
+    if (d.contains(key))
+    {
+        object o = d[key];
+        *value = o.cast<char>();
+    }
+};
+
+
+template <size_t size>
+using string_literal = char[size];
+
+//从字典中获取某个建值对应的字符串，并赋值到请求结构体对象的值上
+template <size_t size>
+void getString(const pybind11::dict &d, const char *key, string_literal<size> &value)
+{
+    if (d.contains(key))
+    {
+        object o = d[key];
+        string s = o.cast<string>();
+        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<wchar_t> wstr(gb2312.size());
+    wchar_t* wstrEnd = nullptr;
+    const char* gbEnd = nullptr;
+    mbstate_t state = {};
+    int res = use_facet<codecvt<wchar_t, char, mbstate_t> >
+        (loc).in(state,
+            gb2312.data(), gb2312.data() + gb2312.size(), gbEnd,
+            wstr.data(), wstr.data() + wstr.size(), wstrEnd);
+
+    if (codecvt_base::ok == res)
+    {
+        wstring_convert<codecvt_utf8<wchar_t>> cutf8;
+        return cutf8.to_bytes(wstring(wstr.data(), wstrEnd));
+    }
+
+    return string();
+}

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

vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{0B01BFAB-DB45-4B6E-AB61-0870DD596339}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>vndafuture</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;VNDAFUTURE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;VNDAFUTURE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;VNDAFUTURE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;VNDAFUTURE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\da\DADataType.h" />
+    <ClInclude Include="..\..\include\da\DAFutureApi.h" />
+    <ClInclude Include="..\..\include\da\DAFutureStruct.h" />
+    <ClInclude Include="stdafx.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="stdafx.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="vndafuture.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.filters

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="源文件">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="头文件">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="资源文件">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="stdafx.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="targetver.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DAFutureStruct.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DADataType.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DAFutureApi.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="stdafx.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="vndafuture.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

vnpy/api/da/vnda/vndafuture/vndafuture.vcxproj.user

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>

vnpy/api/da/vnda/vndamarket/vndamarket.h

@@ -0,0 +1,91 @@
+//系统
+#ifdef WIN32
+#include "stdafx.h"
+#endif
+
+#include <string>
+
+#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);
+};

vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj

@@ -0,0 +1,178 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{2F6FA88B-CD40-465C-860E-2FCC354CBB11}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>vndamarket</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)..\</OutDir>
+    <TargetExt>.pyd</TargetExt>
+    <IncludePath>C:\Miniconda3\include;$(SolutionDir);$(SolutionDir)..\include;$(SolutionDir)..\include\da;$(IncludePath)</IncludePath>
+    <LibraryPath>C:\Miniconda3\libs;$(SolutionDir)..\libs;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;VNDAMARKET_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;VNDAMARKET_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;VNDAMARKET_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NOMINMAX;_CRT_SECURE_NO_WARNINGS;NDEBUG;VNDAMARKET_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>C:\GitHub\vnpy\vnpy\api\da\libs;C:\Miniconda3\libs;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>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)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\da\DADataType.h" />
+    <ClInclude Include="..\..\include\da\DAMarketApi.h" />
+    <ClInclude Include="..\..\include\da\DAMarketStruct.h" />
+    <ClInclude Include="..\vnda.h" />
+    <ClInclude Include="stdafx.h" />
+    <ClInclude Include="targetver.h" />
+    <ClInclude Include="vndamarket.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="stdafx.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="vndamarket.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.filters

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="源文件">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="头文件">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="资源文件">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="stdafx.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="targetver.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="vndamarket.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DADataType.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DAMarketApi.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DAMarketStruct.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\vnda.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="stdafx.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="vndamarket.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

vnpy/api/da/vnda/vndamarket/vndamarket.vcxproj.user

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>

vnpy/api/da/vnda/vndastock/vndastock.vcxproj

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{7EA519E8-2D38-4EA8-AFC1-D8F913AB46B3}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>vndastock</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;VNDASTOCK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;VNDASTOCK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;VNDASTOCK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;VNDASTOCK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\da\DADataType.h" />
+    <ClInclude Include="..\..\include\da\DAStockApi.h" />
+    <ClInclude Include="..\..\include\da\DAStockStruct.h" />
+    <ClInclude Include="stdafx.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="stdafx.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="vndastock.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

vnpy/api/da/vnda/vndastock/vndastock.vcxproj.filters

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="源文件">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="头文件">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="资源文件">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="stdafx.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="targetver.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DAStockApi.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DAStockStruct.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\da\DADataType.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="stdafx.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="vndastock.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

vnpy/api/da/vnda/vndastock/vndastock.vcxproj.user

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>