import os, time, datetime, struct, pathlib, sys
from datetime import datetime
from pathlib import Path
from pythonnet import load

load("coreclr")
import clr, System

##透過Clr引用系統標準函式
clr.AddReference('System.Collections')
from System.Collections.Generic import List

##宣告增加模組、DLL的路徑(windows可抓取當前路徑 Linux跟MAC需指定路徑)
sys.path.append(Path(pathlib.Path(__file__).parent.resolve()))
if sys.platform == "win32":
    os.add_dll_directory(Path(pathlib.Path(__file__).parent.resolve()))

##透過Clr引用YuantaSparkAPI.dll
##pythonnet引用元件不用加附檔名
try:
    clr.AddReference("YuantaSparkAPI")
except Exception as e:
    print(f"Error loading YuantaSparkAPI: {e}")
from YuantaOneAPI import YuantaSparkAPITrader, enumLogType, enumEnvironmentMode

# 建立 API 物件
objYuantaSparkAPI = YuantaSparkAPITrader()
objYuantaSparkAPI.SetLogType(enumLogType.COMMON)

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using YuantaOneAPI;

YuantaSparkAPITrader objYuantaSparkAPI = new YuantaSparkAPITrader();
string Account = "S98875005091";
string Password = "1234";
enumEnvironmentMode enumEvenMode =enumEnvironmentMode.UAT;

objYuantaSparkAPI.OnResponse += objApi_OnResponse;
objYuantaSparkAPI.SetLogType(enumLogType.ALL);

objYuantaSparkAPI.Open(enumEvenMode);
Thread.Sleep(1000);

objYuantaSparkAPI.Login(Account, Password);
Thread.Sleep(1000);

objYuantaSparkAPI.GetOrderTradeReport(false, Account);
Thread.Sleep(2000);

def on_response(intMark, dwIndex, strIndex, objHandle, objValue):
    try:
        result = ''
        match intMark:
            case 0:  # 系統回應資訊
                result = str(objValue)

            case 1:  # 查詢回應資訊
                match strIndex:
                    case 'Login':
                        loginResult = objValue
                        status = loginResult.LoginStatus
                        strMsgCode = status.MsgCode # 訊息代碼
                        strMsgContent = status.MsgContent # 訊息內容
                        intCount = status.Count # 筆數
                        result = '{0},{1},帳號筆數:{2}\r\n'.format(strMsgCode,strMsgContent, str(intCount))
                        if strMsgCode == '0001' or strMsgCode == '00001' or intCount > 0 :
                            for i in objValue.LoginList:
                                result += f"{i.Account},{i.Name},{i.InvestorID},{i.SellerNo}\n"

                    case 'GetOrderTradeReport':
                        orderTradeReport = objValue
                        SOList = orderTradeReport.StkOrderList
                        STList = orderTradeReport.StkTradeList
                        FOList = orderTradeReport.FutOrderList
                        FTList = orderTradeReport.FutTradeList
                        OVSOList = orderTradeReport.OVStkOrderList
                        OVSTList = orderTradeReport.OVStkTradeList
                        OVFOList = orderTradeReport.OVFutOrderList
                        OVFTList = orderTradeReport.OVFutTradeList

                        result += '委託成交綜合回報:\r\n'
                        for i in range(SOList.Count):
                            #tradeDate = TYuantaDate()
                            tradeDate = SOList[i].TradeDate
                            Tdate= '{0}/{1}/{2}'.format(tradeDate.ushtYear, tradeDate.bytMon, tradeDate.bytDay)
                            #acceptDate = TYuantaDate()
                            acceptDate = SOList[i].AcceptDate
                            Adate= '{0}/{1}/{2}'.format(acceptDate.ushtYear, acceptDate.bytMon, acceptDate.bytDay)        
                            #acceptTime = TYuantaTime()
                            acceptTime = SOList[i].AcceptTime
                            Atime= '{0}:{1}:{2}.{3}'.format(str(acceptTime.bytHour), str(acceptTime.bytMin), str(acceptTime.bytSec), str(acceptTime.ushtMSec))
                            #updateDate = TYuantaDate()
                            updateDate = SOList[i].UpdateDate
                            Udate= '{0}/{1}/{2}'.format(updateDate.ushtYear, updateDate.bytMon, updateDate.bytDay)
                            #updateTime = TYuantaTime()
                            updateTime = SOList[i].UpdateTime
                            Utime= '{0}:{1}:{2}.{3}'.format(str(updateTime.bytHour), str(updateTime.bytMin), str(updateTime.bytSec), str(updateTime.ushtMSec))

                            result += '{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14} {15},{16},{17},{18},{19},{20},{21},{22},{23},{24},{25},{26},{27},{28},{29},{30},{31},{32},{33},{34},{35},{36},{37} {38}\r\n'.format(
                                SOList[i].Account,Tdate,str(SOList[i].MarketNo),SOList[i].MarketName,SOList[i].CompanyNo,SOList[i].StkName,str(SOList[i].OrderType),SOList[i].BS,str(SOList[i].Price),SOList[i].PriceFlag,
                                str(SOList[i].BeforeQty),str(SOList[i].AfterQty),str(SOList[i].OkQty),str(SOList[i].OrderStatus),Adate,Atime,SOList[i].OrderNo,SOList[i].ErrorNo,SOList[i].ErrorMessage,str(SOList[i].Seller),
                                SOList[i].Channel,str(SOList[i].APCode),str(SOList[i].OTax),str(SOList[i].OCharge),str(SOList[i].ODueAmt),SOList[i].CancelFlag,SOList[i].ReduceFlag,SOList[i].TraditionFlag,SOList[i].BasketNo,
                                SOList[i].TradeCurrency,SOList[i].Time_in_Force,SOList[i].Order_Success,SOList[i].Reduce_Flag,SOList[i].Chg_Prz_Flag,SOList[i].TSE_Cancel,str(SOList[i].CancelQty),str(SOList[i].OR_QTY),Udate,Utime)

                        result += '現貨成交筆數:{0}\r\n'.format(STList.Count)
                        for i in range(STList.Count):
                            #dateTime=TYuantaDateTime()
                            dateTime=STList[i].DateTime

                            Date= '{0}/{1}/{2}'.format(dateTime.Year, dateTime.Month, dateTime.Day)
                            Time= '{0}:{1}:{2}.{3}'.format(str(dateTime.Hour), str(dateTime.Minute), str(dateTime.Second), str(dateTime.Millisecond))

                            result += '{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10} {11},{12},{13},{14},{15}\r\n'.format(
                                STList[i].Account,str(STList[i].MarketNo),STList[i].MarketName,STList[i].CompanyNo,STList[i].StkName,str(STList[i].OrderType),STList[i].BS,str(STList[i].OkQty),str(STList[i].OPrice),
                                str(STList[i].SPrice),Date,Time,STList[i].OrderNo,STList[i].TradeCurrency,STList[i].Price_Flag,str(STList[i].Exchange_Code))

                        result += '期貨委託筆數:{0}\r\n'.format(FOList.Count)
                        for i in range(FOList.Count):
                            #tradeDate = TYuantaDate()
                            tradeDate = FOList[i].TradeDate
                            Tdate= '{0}/{1}/{2}'.format(tradeDate.Year, tradeDate.Month, tradeDate.Day)
                            #acceptDate = TYuantaDate()
                            acceptDate = FOList[i].AcceptDate
                            Adate= '{0}/{1}/{2}'.format(acceptDate.Year, acceptDate.Month, acceptDate.Day)        
                            #acceptTime = TYuantaTime()
                            acceptTime = FOList[i].AcceptTime
                            Atime= '{0}:{1}:{2}.{3}'.format(str(acceptTime.Hour), str(acceptTime.Minute), str(acceptTime.Second), str(acceptTime.Millisecond))

                            result += '{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14},{15},{16},{17},{18},{19} {20},{21},{22},{23},{24},{25},{26},{27},{28},{29},{30},{31},{32},{33},{34},{35},{36},{37} {38},{39},{40},{41},{42}\r\n'.format(
                                FOList[i].Account,Tdate,str(FOList[i].MarketNo),FOList[i].MarketName,FOList[i].Commodity1,str(FOList[i].SettlementMonth1),str(FOList[i].StrikePrice1),FOList[i].BuySellKind1,FOList[i].Commodity2,
                                str(FOList[i].SettlementMonth2),str(FOList[i].StrikePrice2),FOList[i].BuySellKind2,FOList[i].OpenOffsetKind,FOList[i].OrderCondition,FOList[i].OrderPrice,str(FOList[i].BeforeQty),str(FOList[i].AfterQty),
                                str(FOList[i].OkQty),str(FOList[i].OrderStatus),Adate,Atime,FOList[i].ErrorNo,FOList[i].ErrorMessage,FOList[i].OrderNo,FOList[i].ProductType,str(FOList[i].Seller),str(FOList[i].TotalMatFee),
                                str(FOList[i].TotalMatExchTax),str(FOList[i].TotalMatPremium),FOList[i].DayTradeID,FOList[i].CancelFlag,FOList[i].ReduceFlag,FOList[i].StkName1,FOList[i].StkName2,FOList[i].TraditionFlag,
                                FOList[i].TRID,FOList[i].CurrencyType,FOList[i].CurrencyType2,FOList[i].BasketNo,str(FOList[i].MarketNo1),FOList[i].StkCode1,str(FOList[i].MarketNo2),FOList[i].StkCode2)

                        result += '期貨成交筆數:{0}\r\n'.format(FTList.Count)
                        for i in range(FTList.Count):
                            #date = TYuantaDate()
                            date = FTList[i].MatchDate
                            Mdate= '{0}/{1}/{2}'.format(date.ushtYear, date.bytMon, date.bytDay)        
                            #time = TYuantaTime()
                            time = FTList[i].MatchTime
                            Mtime= '{0}:{1}:{2}.{3}'.format(str(time.bytHour), str(time.bytMin), str(time.bytSec), str(time.ushtMSec))

                            result += '{0},{1},{2},{3},{4},{5},{6},{7},{8},{9} {10} {11},{12},{13},{14},{15},{16},{17},{18},{19} {20},{21},{22},{23},{24},{25},{26},{27}\r\n'.format(
                                FTList[i].Account,str(FTList[i].MarketNo),FTList[i].MarketName,FTList[i].Commodity1,str(FTList[i].SettlementMonth1),FTList[i].BuySellKind1,str(FTList[i].OkQty),str(FTList[i].MatchPrice1),
                                str(FTList[i].MatchPrice2),Mdate,Mtime,FTList[i].OrderNo,str(FTList[i].StrikePrice1),FTList[i].Commodity2,str(FTList[i].SettlementMonth2),FTList[i].BuySellKind2,str(FTList[i].StrikePrice2),
                                FTList[i].RecType,FTList[i].ProductType,str(FTList[i].OrderPrice),FTList[i].StkName1,FTList[i].StkName2,FTList[i].DayTradeID,str(FTList[i].SprMatchPrice),FTList[i].TRID,FTList[i].CurrencyType,
                                FTList[i].CurrencyType2,FTList[i].SubNo)

                        result += '國外現貨委託筆數:{0}\r\n'.format(OVSOList.Count)
                        for i in range(OVSOList.Count):
                            #tradeDate = TYuantaDate()
                            tradeDate = OVSOList[i].TradeDate
                            Tdate= '{0}/{1}/{2}'.format(tradeDate.ushtYear, tradeDate.bytMon, tradeDate.bytDay)
                            #dt=TYuantaDateTime()
                            dateTime=OVSOList[i].OrderTime

                            #date = TYuantaDate()
                            Date= '{0}/{1}/{2}'.format(dateTime.Year, dateTime.Month, dateTime.Day)
                            #time = TYuantaTime()
                            Time = '{0}:{1}:{2}.{3}'.format(dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond)

                            result += '{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13} {14},{15},{16},{17},{18},{19},{20},{21},{22},{23},{24},{25},{26}\r\n'.format(
                                OVSOList[i].Account,Tdate,str(OVSOList[i].MarketNo),OVSOList[i].MarketName,OVSOList[i].CompanyNo,OVSOList[i].StkName,OVSOList[i].BS,OVSOList[i].CurrencyType,str(OVSOList[i].Price),
                                OVSOList[i].PriceType,str(OVSOList[i].OrderQty),str(OVSOList[i].OkQty),str(OVSOList[i].OrderStatus),Date,Time,OVSOList[i].OrderType,OVSOList[i].OrderNo,str(OVSOList[i].Fee),str(OVSOList[i].PolarisAMT),
                                OVSOList[i].ErrorNo,OVSOList[i].ErrorMessage,OVSOList[i].CurrencyType2,OVSOList[i].CancelFlag,OVSOList[i].ReduceFlag,OVSOList[i].TraditionFlag,OVSOList[i].SettleType,OVSOList[i].BasketNo)

                        result += '國外現貨成交筆數:{0}\r\n'.format(OVSTList.Count)
                        for i in range(OVSTList.Count):
                            #dateTime=TYuantaDateTime()

                            dateTime=OVSTList[i].DateTime

                            Date= '{0}/{1}/{2}'.format(dateTime.Year, dateTime.Month, dateTime.Day)
                            Time= '{0}:{1}:{2}.{3}'.format(str(dateTime.tHour), str(dateTime.Minute), str(dateTime.Second), str(dateTime.Millisecond))

                            result += '{0},{1},{2},{3},{4},{5},{6},{7},{8},{9} {10} {11},{12},{13},{14},{15}\r\n'.format(
                                OVSTList[i].Account,str(OVSTList[i].MarketNo),OVSTList[i].MarketName,OVSTList[i].CompanyNo,OVSTList[i].StkName,OVSTList[i].BS,OVSTList[i].CurrencyType,str(OVSTList[i].OkQty),
                                str(OVSTList[i].OrderPrice),str(OVSTList[i].MatchPrice),Date,Time,str(OVSTList[i].Fee),OVSTList[i].OrderNo,str(OVSTList[i].SettlementAMT),OVSTList[i].CurrencyType2)

                        result += '國外期貨委託筆數:{0}\r\n'.format(OVFOList.Count)
                        for i in range(OVFOList.Count):
                            #tradeDate = TYuantaDate()
                            tradeDate = OVFOList[i].TradeDate
                            Tdate= '{0}/{1}/{2}'.format(tradeDate.ushtYear, tradeDate.bytMon, tradeDate.bytDay)
                            #acceptDate = TYuantaDate()
                            acceptDate = OVFOList[i].AcceptDate
                            Adate= '{0}/{1}/{2}'.format(acceptDate.ushtYear, acceptDate.bytMon, acceptDate.bytDay)        
                            #acceptTime = TYuantaTime()
                            acceptTime = OVFOList[i].AcceptTime
                            Atime= '{0}:{1}:{2}.{3}'.format(str(acceptTime.bytHour), str(acceptTime.bytMin), str(acceptTime.bytSec), str(acceptTime.ushtMSec))

                            result += '{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14} {15},{16},{17},{18},{19},{20},{21},{22},{23},{24},{25},{26},{27},{28},{29},{30},{31},{32},{33}\r\n'.format(
                                OVFOList[i].Account,Tdate,str(OVFOList[i].MarketNo),OVFOList[i].MarketName,OVFOList[i].CompanyNo,str(OVFOList[i].SettlementMonth),OVFOList[i].StkName,OVFOList[i].BS,OVFOList[i].OrderType,
                                str(OVFOList[i].Price),OVFOList[i].TouchPrice,str(OVFOList[i].OrderQty),str(OVFOList[i].OkQty),str(OVFOList[i].OrderStatus),Adate,Atime,OVFOList[i].ErrorNo,OVFOList[i].ErrorMessage,
                                OVFOList[i].OrderNo,OVFOList[i].DayTradeID,OVFOList[i].CancelFlag,OVFOList[i].ReduceFlag,str(OVFOList[i].UtPrice),str(OVFOList[i].UtPrice2),str(OVFOList[i].MinPrice2),str(OVFOList[i].UtPrice4),
                                str(OVFOList[i].UtPrice5),str(OVFOList[i].UtPrice6),OVFOList[i].TraditionFlag,OVFOList[i].BasketNo,str(OVFOList[i].MarketNo1),OVFOList[i].StkCode1,OVFOList[i].CurrencyType,OVFOList[i].CurrencyType2)

                        result += '國外期貨成交筆數:{0}\r\n'.format(OVFTList.Count)
                        for i in range(OVFTList.Count):
                            #date = TYuantaDate()
                            date = OVFTList[i].MatchDate
                            Date= '{0}/{1}/{2}'.format(date.ushtYear, date.bytMon, date.bytDay)        
                            #time = TYuantaTime()
                            time = OVFTList[i].MatchTime
                            Time= '{0}:{1}:{2}.{3}'.format(str(time.bytHour), str(time.bytMin), str(time.bytSec), str(time.ushtMSec))

                            result += '{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10} {11},{12},{13},{14}\r\n'.format(
                                OVFTList[i].Account,str(OVFTList[i].MarketNo),OVFTList[i].MarketName,OVFTList[i].CompanyNo,str(OVFTList[i].SettlementMonth),OVFTList[i].StkName,OVFTList[i].BS,str(OVFTList[i].OkQty),
                                str(OVFTList[i].OrderPrice),str(OVFTList[i].MatchPrice),Date,Time,OVFTList[i].OrderNo,OVFTList[i].CurrencyType,OVFTList[i].CurrencyType2)

        if result:
            print('##================================================##\n')
            print(result)

    except Exception as error:
        print(f"處理回應時發生錯誤: {error}")

objYuantaSparkAPI.OnResponse += on_response
#測試環境帳號:UAT 正式環境:PROD
objYuantaSparkAPI.Open(enumEnvironmentMode.UAT)
time.sleep(2)
objYuantaSparkAPI.Login('S98875005091', '1234')
time.sleep(2)

#委託成交綜合回報
objYuantaSparkAPI.GetOrderTradeReport(False,'S98875005091')

# 保持程式運行
while True:
    time.sleep(1)

void objApi_OnResponse(int intMark, uint dwIndex, string strIndex, object objHandle, object objValue)
{
    string strResult = "";
    try
    {
        if (intMark == 0)
        {
            Console.WriteLine(Convert.ToString(objValue));
            return;
        }

        if (intMark == 1)
        {
            if (strIndex == "Login")
            {
                var result = (LoginResult)objValue;

                string strMsgCode = result.LoginStatus.MsgCode;
                string strMsgContent = result.LoginStatus.MsgContent;
                int intCount = result.LoginStatus.Count;

                strResult += $"{strMsgCode}, {strMsgContent}{Environment.NewLine}";
                if (strMsgCode == "0001" || strMsgCode == "00001")
                {
                    strResult += $"帳號筆數: {intCount.ToString()}{Environment.NewLine}";
                    result.LoginList.ForEach(r => strResult += $"{r.Account},{r.Name},{r.InvestorID},{r.SellerNo}\r\n");

                }
                else
                {
                    Account = "";
                }

                Console.WriteLine("\n======================");
                Console.WriteLine(strResult.ToString());
                Console.WriteLine("======================\n");
                return;
            }

            if (strIndex == "GetOrderTradeReport")
            {
                var result = (OrderTradeReportResult)objValue;
                try
                {
                    TYuantaDate yuantaDate;
                    TYuantaTime yuantaTime;

                    strResult += "委託成交回報查詢結果 : \r\n";

                    strResult += "現貨委託筆數: " + result.StkOrderList.Count + "\r\n";
                    result.StkOrderList.ForEach(x =>
                    {
                        strResult += $"{x.Account},";
                        yuantaDate = x.TradeDate;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay},";
                        strResult += $"{x.MarketNo},{x.MarketName},{x.CompanyNo},{x.StkName},{x.OrderType},{x.BS},{x.Price},{x.PriceFlag},{x.BeforeQty},{x.AfterQty},{x.OkQty},{x.OrderStatus},";
                        yuantaDate = x.AcceptDate;
                        yuantaTime = x.AcceptTime;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay} {yuantaTime.bytHour}:{yuantaTime.bytMin}:{yuantaTime.bytSec}.{yuantaTime.ushtMSec},";
                        strResult += $"{x.OrderNo},{x.ErrorNo},{x.ErrorMessage},{x.Seller},{x.Channel},{x.APCode},{x.OTax},{x.OCharge},{x.ODueAmt},{x.CancelFlag},{x.ReduceFlag},{x.TraditionFlag}," +
                        $"{x.BasketNo},{x.TradeCurrency},{x.Time_in_Force},{x.Order_Success},{x.Reduce_Flag},{x.Chg_Prz_Flag},{x.TSE_Cancel},{x.CancelQty}";
                        yuantaDate = x.UpdateDate;
                        yuantaTime = x.UpdateTime;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay} {yuantaTime.bytHour}:{yuantaTime.bytMin}:{yuantaTime.bytSec}.{yuantaTime.ushtMSec}\r\n";
                    });

                    strResult += "現貨成交筆數: " + result.StkTradeList.Count + "\r\n";
                    result.StkTradeList.ForEach(x =>
                    {
                        strResult += $"{x.Account},{x.MarketNo},{x.MarketName},{x.CompanyNo},{x.StkName},{x.OrderType},{x.BS},{x.OkQty},{x.OPrice},{x.SPrice},";
                        strResult += $"{x.DateTime.ToString()},{x.OrderNo},{x.TradeCurrency},{x.Price_Flag},{x.Exchange_Code}\r\n";
                    });

                    strResult += "期貨委託筆數: " + result.FutOrderList.Count + "\r\n";
                    result.FutOrderList.ForEach(x =>
                    {
                        strResult += $"{x.Account},";
                        yuantaDate = x.TradeDate;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay},";
                        strResult += $"{x.MarketNo},{x.MarketName},{x.Commodity1},{x.SettlementMonth1},{x.StrikePrice1},{x.BuySellKind1},{x.Commodity2},{x.SettlementMonth2},{x.StrikePrice2}," +
                        $"{x.BuySellKind2},{x.OpenOffsetKind},{x.OrderCondition},{x.OrderPrice},{x.BeforeQty},{x.AfterQty},{x.OkQty},{x.OrderStatus},";
                        yuantaDate = x.AcceptDate;
                        yuantaTime = x.AcceptTime;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay} {yuantaTime.bytHour}:{yuantaTime.bytMin}:{yuantaTime.bytSec}.{yuantaTime.ushtMSec},";
                        strResult += $"{x.ErrorNo},{x.ErrorMessage},{x.OrderNo},{x.ProductType},{x.Seller},{x.TotalMatFee},{x.TotalMatExchTax},{x.TotalMatPremium},{x.DayTradeID},{x.CancelFlag}," +
                        $"{x.ReduceFlag},{x.StkName1},{x.StkName2},{x.TraditionFlag},{x.TRID},{x.CurrencyType},{x.CurrencyType2},{x.BasketNo},{x.MarketNo1},{x.StkCode1},{x.MarketNo2},{x.StkCode2}\r\n";
                    });

                    strResult += "期貨成交筆數: " + result.FutTradeList.Count + "\r\n";

                    result.FutTradeList.ForEach(x =>
                    {
                        strResult += $"{x.Account},{x.MarketNo},{x.MarketName},{x.Commodity1},{x.SettlementMonth1},{x.BuySellKind1},{x.OkQty},{x.MatchPrice1},{x.MatchPrice2},";
                        yuantaTime = x.MatchTime;
                        yuantaDate = x.MatchDate;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay} {yuantaTime.bytHour}:{yuantaTime.bytMin}:{yuantaTime.bytSec}.{yuantaTime.ushtMSec},";
                        strResult += $"{x.OrderNo},{x.StrikePrice1},{x.Commodity2},{x.SettlementMonth2},{x.BuySellKind2},{x.StrikePrice2},{x.RecType},{x.ProductType},{x.OrderPrice},{x.StkName1}," +
                        $"{x.StkName2},{x.DayTradeID},{x.SprMatchPrice},{x.TRID},{x.CurrencyType},{x.CurrencyType2},{x.SubNo}\r\n";
                    });

                    strResult += "國外股票委託筆數:" + result.OVStkOrderList.Count + "\r\n";
                    result.OVStkOrderList.ForEach(x =>
                    {
                        strResult += $"{x.Account},";
                        yuantaDate = x.TradeDate;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay},";
                        strResult += $"{x.MarketNo},{x.MarketName},{x.CompanyNo},{x.StkName},{x.BS},{x.CurrencyType},{x.Price},{x.PriceType},{x.OrderQty},{x.OkQty},{x.OrderStatus},";
                        strResult += $"{x.OrderTime.ToString()},{x.OrderType},{x.OrderNo},{x.Fee},{x.PolarisAMT},{x.ErrorNo},{x.ErrorMessage},{x.CurrencyType2},{x.CancelFlag},{x.ReduceFlag},{x.TraditionFlag},{x.SettleType},{x.BasketNo}\r\n";
                    });

                    strResult += "國外股票成交筆數:" + result.OVStkTradeList.Count + "\r\n";
                    result.OVStkTradeList.ForEach(x =>
                    {
                        strResult += $"{x.Account},{x.MarketNo},{x.MarketName},{x.CompanyNo},{x.StkName},{x.BS},{x.CurrencyType},{x.OkQty},{x.OrderPrice},{x.MatchPrice},";
                        strResult += $"{x.DateTime.ToString()},{x.Fee},{x.OrderNo},{x.SettlementAMT},{x.CurrencyType2}\r\n";
                    });
                    strResult += "國外期貨委託筆數:" + result.OVFutOrderList.Count + "\r\n";
                    result.OVFutOrderList.ForEach(x =>
                    {
                        strResult += $"{x.Account},";
                        yuantaDate = x.TradeDate;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay},";
                        strResult += $"{x.MarketNo},{x.MarketName},{x.CompanyNo},{x.SettlementMonth},{x.StkName},{x.BS},{x.OrderType},{x.Price},{x.TouchPrice},{x.OrderQty},{x.OkQty},{x.OrderStatus},";
                        yuantaDate = x.AcceptDate;
                        yuantaTime = x.AcceptTime;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay} {yuantaTime.bytHour}:{yuantaTime.bytMin}:{yuantaTime.bytSec}.{yuantaTime.ushtMSec},";
                        strResult += $"{x.ErrorNo},{x.ErrorMessage},{x.OrderNo},{x.DayTradeID},{x.CancelFlag},{x.ReduceFlag},{x.UtPrice},{x.UtPrice2},{x.MinPrice2},{x.UtPrice4},{x.UtPrice5},{x.UtPrice6}," +
                        $"{x.TraditionFlag},{x.BasketNo},{x.MarketNo1},{x.StkCode1},{x.CurrencyType},{x.CurrencyType2}\r\n";
                    });

                    strResult += "國外期貨成交筆數:" + result.OVFutTradeList.Count + "\r\n";
                    result.OVFutTradeList.ForEach(x =>
                    {
                        strResult += $"{x.Account},{x.MarketNo},{x.MarketName},{x.CompanyNo},{x.SettlementMonth},{x.StkName},{x.BS},{x.OkQty},{x.OrderPrice},{x.MatchPrice},";
                        yuantaDate = x.MatchDate;
                        yuantaTime = x.MatchTime;
                        strResult += $"{yuantaDate.ushtYear}/{yuantaDate.bytMon}/{yuantaDate.bytDay} {yuantaTime.bytHour}:{yuantaTime.bytMin}:{yuantaTime.bytSec}.{yuantaTime.ushtMSec},";
                        strResult += $"{x.OrderNo},{x.CurrencyType},{x.CurrencyType2}\r\n";
                    });
                }
                catch (Exception ex)
                {
                    strResult = "";
                }

                Console.WriteLine("\n======================");
                Console.WriteLine(strResult);
                Console.WriteLine("======================\n");
                return;
            }

            Console.WriteLine($"[{strIndex}] {Convert.ToString(objValue)}");
        }
    }
    catch (Exception exc)
    {
        Console.WriteLine("OnResponse Error: " + exc.Message);
    }
}