示例#1
0
 /// <summary>
 /// 加入用户持股
 /// </summary>
 /// <param name="UserID"></param>
 /// <param name="UserStock"></param>
 /// <returns></returns>
 public bool AddUserStocks(int UserID, RemotingInterface.RI_Stock UserStock)
 {
     try
     {
         if (UserID <= 0 || UserStock.Volume <= 0 || UserStock.SellableVolume < 0)
         {
             return(false);
         }
         if (UserStock.StockCode == null || UserStock.StockCode.Trim().Length != 6 ||
             UserStock.StockMarket == RemotingInterface.RI_Market.Unknown)
         {
             return(false);
         }
         lock (mapRIUserStocks)
         {
             if (mapRIUserStocks.ContainsKey(UserID))
             {
                 List <RemotingInterface.RI_Stock> listStocks = mapRIUserStocks[UserID];
                 bool bExist = false;
                 for (int i = 0; i < listStocks.Count; i++)
                 {
                     RemotingInterface.RI_Stock data = listStocks[i];
                     if (string.Compare(data.StockCode.ToUpper().Trim(), UserStock.StockCode.ToUpper().Trim()) == 0 &&
                         data.StockMarket == UserStock.StockMarket)
                     {
                         data.AveragePrice = Common.ConvertPrice((data.AveragePrice * data.Volume + UserStock.AveragePrice * UserStock.Volume)
                                                                 / (data.Volume + UserStock.Volume));
                         data.Volume         += UserStock.Volume;
                         data.SellableVolume += UserStock.SellableVolume;
                         listStocks[i]        = data;
                         bExist = true;
                         Common.Debug("SetStocksInfoInBuffer: UserID-" + UserID + "; StockCode-" + data.StockCode + (byte)data.StockMarket +
                                      "; Volume-" + data.Volume + "; SellableVolume-" + data.SellableVolume + "; Price-" + data.AveragePrice.ToString("f3"));
                     }
                 }
                 if (!bExist)
                 {
                     listStocks.Add(UserStock);
                     Common.Debug("AddStocksInfoInBuffer: UserID-" + UserID + "; StockCode-" + UserStock.StockCode + (byte)UserStock.StockMarket +
                                  "; Volume-" + UserStock.Volume + "; SellableVolume-" + UserStock.SellableVolume + "; Price-" + UserStock.AveragePrice.ToString("f3"));
                 }
                 mapRIUserStocks[UserID] = listStocks;
             }
             else
             {
                 List <RemotingInterface.RI_Stock> listStocks = new List <RemotingInterface.RI_Stock>();
                 listStocks.Add(UserStock);
                 Common.Debug("AddStocksInfoInBuffer: UserID-" + UserID + "; StockCode-" + UserStock.StockCode + (byte)UserStock.StockMarket +
                              "; Volume-" + UserStock.Volume + "; SellableVolume-" + UserStock.SellableVolume + "; Price-" + UserStock.AveragePrice.ToString("f3"));
                 mapRIUserStocks[UserID] = listStocks;
             }
         }
         return(true);
     }
     catch (Exception err)
     {
         Common.Log(err);
         return(false);
     }
 }
示例#2
0
 /// <summary>
 /// 合并用户持股
 /// </summary>
 /// <param name="UserID"></param>
 /// <param name="UserStock"></param>
 /// <returns></returns>
 public bool SubUserStocks(int UserID, RemotingInterface.RI_Stock UserStock)
 {
     try
     {
         if (UserID <= 0 || UserStock.Volume <= 0)
         {
             return(false);
         }
         if (UserStock.StockCode == null || UserStock.StockCode.Trim().Length != 6 ||
             UserStock.StockMarket == RemotingInterface.RI_Market.Unknown)
         {
             return(false);
         }
         lock (mapRIUserStocks)
         {
             if (mapRIUserStocks.ContainsKey(UserID))
             {
                 List <RemotingInterface.RI_Stock> listStocks = mapRIUserStocks[UserID];
                 bool bRtn = false;
                 for (int i = 0; i < listStocks.Count; i++)
                 {
                     if (listStocks[i].SellableVolume >= UserStock.SellableVolume && listStocks[i].StockCode != null &&
                         string.Compare(listStocks[i].StockCode.ToUpper().Trim(), UserStock.StockCode.ToUpper().Trim()) == 0 &&
                         listStocks[i].StockMarket == UserStock.StockMarket && listStocks[i].Volume >= UserStock.Volume)
                     {
                         RemotingInterface.RI_Stock data = listStocks[i];
                         if (data.Volume <= UserStock.Volume)
                         {
                             data.AveragePrice = 0;
                         }
                         else
                         {
                             data.AveragePrice = Common.ConvertPrice((data.AveragePrice * data.Volume - UserStock.AveragePrice * UserStock.Volume)
                                                                     / (data.Volume - UserStock.Volume));
                         }
                         data.Volume         -= UserStock.Volume;
                         data.SellableVolume -= UserStock.SellableVolume;
                         Common.Debug("SubStocksInfoInBuffer: UserID-" + UserID + "; StockCode-" + data.StockCode + (byte)data.StockMarket +
                                      "; Volume-" + data.Volume + "; SellableVolume-" + data.SellableVolume + "; Price-" + data.AveragePrice.ToString("f3"));
                         if (data.Volume <= 0)
                         {
                             listStocks.RemoveAt(i--);
                         }
                         else
                         {
                             listStocks[i] = data;
                         }
                         mapRIUserStocks[UserID] = listStocks;
                         bRtn = true;
                         break;
                     }
                 }
                 return(bRtn);
             }
             else
             {
                 return(false);
             }
         }
     }
     catch (Exception err)
     {
         Common.Log(err);
         return(false);
     }
 }
示例#3
0
        /// <summary>
        /// ����״̬�����ı�
        /// </summary>
        /// <param name="userFund"></param>
        /// <param name="userOrder"></param>
        /// <param name="userStock"></param>
        /// <returns></returns>
        public bool OrderChanged(TradingSystem.UserFund userFund, TradingSystem.UserOrders userOrder, TradingSystem.UserStocks userStock)
        {
            try
            {
                if (userFund.UserID != userOrder.UserID)
                {
                    Common.Log("Illegal Trading [UserFund.UserID=" + userFund.UserID + ";UserOrder.UserID=" + userOrder.UserID + "] @ OrderChanged.");
                    return false;
                }
                if (userOrder.OrdStatus == TradingSystem.OrderStatus.Finished
                    && userStock.UserID != userOrder.UserID)
                {
                    Common.Log("Illegal Trading [UserStock.UserID=" + userStock.UserID + ";UserOrder.UserID=" + userOrder.UserID + "] @ OrderChanged.");
                    return false;
                }

                bool bExist = false;
                switch (userOrder.OrdStatus)
                {
                    case TradingSystem.OrderStatus.Finished:
                        {
                            lock (listUserOrders)
                            {
                                for (int i = 0; i < listUserOrders.Count; i++)
                                {
                                    if (listUserOrders[i].OrderID == userOrder.OrderID)
                                    {
                                        listUserOrders.RemoveAt(i);
                                        break;
                                    }
                                }
                            }

                            bExist = false;
                            lock (listOrdersHistory)
                            {
                                for (int i = 0; i < listOrdersHistory.Count; i++)
                                {
                                    if (listOrdersHistory[i].OrderID == userOrder.OrderID)
                                    {
                                        bExist = true;
                                        listOrdersHistory[i] = userOrder;
                                        break;
                                    }
                                }
                                if (!bExist)
                                    listOrdersHistory.Add(userOrder);
                            }
                            lock (listRemoveOrders)
                            {
                                listRemoveOrders.Add(userOrder.OrderID);
                            }
                            if (userOrder.OrdType == TradingSystem.OrderType.ImmediateOrder
                                || userOrder.OrdType == TradingSystem.OrderType.LimitedOrder)
                            {
                                bExist = false;
                                lock (listUserStocks)
                                {
                                    for (int i = 0; i < listUserStocks.Count; i++)
                                    {
                                        if (listUserStocks[i].UserID == userStock.UserID
                                            && listUserStocks[i].StockCode != null
                                            && string.Compare(userStock.StockCode.Trim(),
                                            listUserStocks[i].StockCode.Trim()) == 0
                                            && userStock.Market == listUserStocks[i].Market)
                                        {
                                            bExist = true;
                                            listUserStocks[i] = userStock;
                                            break;
                                        }
                                    }
                                    if (!bExist)
                                        listUserStocks.Add(userStock);
                                }

                                TradingHistory TradeItem = new TradingHistory();
                                TradeItem.Initialize();
                                TradeItem.OrderID = userOrder.OrderID;
                                TradeItem.Side = userOrder.Side;
                                TradeItem.StockCode = userOrder.StockCode;
                                TradeItem.Market = userOrder.Market;
                                TradeItem.TradeVolume = userOrder.OrderVolume;
                                TradeItem.TradeDate = userOrder.UpdatedDate;
                                if (userOrder.TradePrice > 0)
                                    TradeItem.TradePrice = userOrder.TradePrice;
                                else
                                {
                                    Common.Log("Illegal Trading Price [TradePrice=" + userOrder.TradePrice.ToString("f4") + "].");
                                    TradeItem.TradePrice = userOrder.OrderPrice;
                                }
                                TradeItem.Curr = userOrder.Curr;
                                TradeItem.UserID = userOrder.UserID;
                                lock (listTradingHistory)
                                {
                                    listTradingHistory.Add(TradeItem);
                                }
                            }

                            if (Common.stkBuffer != null)
                            {
                                RemotingInterface.RI_Order stiOrder = new RemotingInterface.RI_Order();
                                stiOrder.Clear();
                                stiOrder.ExpiredDate = userOrder.ExpiredDate;
                                stiOrder.OrderDate = userOrder.OrderDate;
                                stiOrder.OrderID = userOrder.OrderID;
                                stiOrder.OrderPrice = Common.ConvertPrice(userOrder.OrderPrice);
                                stiOrder.TradePrice = Common.ConvertPrice(userOrder.TradePrice);
                                stiOrder.OrderStatus = (RemotingInterface.RI_Status)userOrder.OrdStatus;
                                stiOrder.OrderType = (RemotingInterface.RI_Type)userOrder.OrdType;
                                stiOrder.OrderVolume = userOrder.OrderVolume;
                                stiOrder.Side = userOrder.Side;
                                stiOrder.StockCode = userOrder.StockCode.Trim();
                                stiOrder.StockMarket = (RemotingInterface.RI_Market)userOrder.Market;
                                stiOrder.UpdatedDate = userOrder.UpdatedDate;
                                stiOrder.Curr = (RemotingInterface.RI_Currency)userOrder.Curr;
                                Common.stkBuffer.SetUserOrders(userOrder.UserID, stiOrder);

                                if (userOrder.OrdType == TradingSystem.OrderType.ImmediateOrder
                                    || userOrder.OrdType == TradingSystem.OrderType.LimitedOrder)
                                {
                                    RemotingInterface.RI_Stock stiStock = new RemotingInterface.RI_Stock();
                                    stiStock.Clear();
                                    stiStock.AveragePrice = Common.ConvertPrice(userStock.AveragePrice);
                                    stiStock.Curr = (RemotingInterface.RI_Currency)userStock.Curr;
                                    stiStock.StockCode = userStock.StockCode.Trim();
                                    stiStock.StockMarket = (RemotingInterface.RI_Market)userStock.Market;
                                    stiStock.Volume = userOrder.OrderVolume;
                                    if (userStock.Sellable)
                                        stiStock.SellableVolume = userOrder.OrderVolume;
                                    else
                                        stiStock.SellableVolume = 0;
                                    if (userOrder.Side)
                                        Common.stkBuffer.AddUserStocks(userStock.UserID, stiStock);
                                    else
                                        Common.stkBuffer.SubUserStocks(userStock.UserID, stiStock);

                                    RemotingInterface.RI_Trading stiTrading = new RemotingInterface.RI_Trading();
                                    stiTrading.Clear();
                                    stiTrading.Side = userOrder.Side;
                                    stiTrading.StockCode = userOrder.StockCode.Trim();
                                    stiTrading.StockMarket = (RemotingInterface.RI_Market)userOrder.Market;
                                    stiTrading.TradeVolume = userOrder.OrderVolume;
                                    stiTrading.TradeDate = userOrder.UpdatedDate;
                                    stiTrading.Curr = (RemotingInterface.RI_Currency)userOrder.Curr;
                                    if (userOrder.TradePrice > 0)
                                        stiTrading.TradePrice = Common.ConvertPrice(userOrder.TradePrice);
                                    else
                                        stiTrading.TradePrice = Common.ConvertPrice(userOrder.OrderPrice);
                                    Common.stkBuffer.SetUserTradings(userOrder.UserID, stiTrading);
                                }
                            }
                        }
                        break;
                    case TradingSystem.OrderStatus.Cancelled:
                    case TradingSystem.OrderStatus.Failure:
                    case TradingSystem.OrderStatus.Unknown:
                        {
                            bExist = false;
                            lock (listUserOrders)
                            {
                                for (int i = 0; i < listUserOrders.Count; i++)
                                {
                                    if (listUserOrders[i].OrderID == userOrder.OrderID)
                                    {
                                        listUserOrders.RemoveAt(i);
                                        break;
                                    }
                                }
                            }
                            lock (listOrdersHistory)
                            {
                                for (int i = 0; i < listOrdersHistory.Count; i++)
                                {
                                    if (listOrdersHistory[i].OrderID == userOrder.OrderID)
                                    {
                                        bExist = true;
                                        listOrdersHistory[i] = userOrder;
                                        break;
                                    }
                                }
                                if (!bExist)
                                    listOrdersHistory.Add(userOrder);
                            }
                            lock (listRemoveOrders)
                            {
                                listRemoveOrders.Add(userOrder.OrderID);
                            }

                            if (Common.stkBuffer != null)
                            {
                                RemotingInterface.RI_Order stiOrder = new RemotingInterface.RI_Order();
                                stiOrder.Clear();
                                stiOrder.ExpiredDate = userOrder.ExpiredDate;
                                stiOrder.OrderDate = userOrder.OrderDate;
                                stiOrder.OrderID = userOrder.OrderID;
                                stiOrder.OrderPrice = Common.ConvertPrice(userOrder.OrderPrice);
                                stiOrder.OrderStatus = (RemotingInterface.RI_Status)userOrder.OrdStatus;
                                stiOrder.OrderType = (RemotingInterface.RI_Type)userOrder.OrdType;
                                stiOrder.OrderVolume = userOrder.OrderVolume;
                                stiOrder.Side = userOrder.Side;
                                stiOrder.StockCode = userOrder.StockCode.Trim();
                                stiOrder.StockMarket = (RemotingInterface.RI_Market)userOrder.Market;
                                stiOrder.UpdatedDate = userOrder.UpdatedDate;
                                stiOrder.Curr = (RemotingInterface.RI_Currency)userOrder.Curr;
                                Common.stkBuffer.SetUserOrders(userOrder.UserID, stiOrder);
                            }
                        }
                        break;
                    case TradingSystem.OrderStatus.Cancelling:
                    case TradingSystem.OrderStatus.Waiting:
                        {
                            bExist = false;
                            lock (listUserOrders)
                            {
                                for (int i = 0; i < listUserOrders.Count; i++)
                                {
                                    if (listUserOrders[i].OrderID == userOrder.OrderID)
                                    {
                                        bExist = true;
                                        listUserOrders[i] = userOrder;
                                        break;
                                    }
                                }
                                if (!bExist)
                                {
                                    listUserOrders.Add(userOrder);
                                }
                            }

                            if (Common.stkBuffer != null)
                            {
                                RemotingInterface.RI_Order stiOrder = new RemotingInterface.RI_Order();
                                stiOrder.Clear();
                                stiOrder.ExpiredDate = userOrder.ExpiredDate;
                                stiOrder.OrderDate = userOrder.OrderDate;
                                stiOrder.OrderID = userOrder.OrderID;
                                stiOrder.OrderPrice = Common.ConvertPrice(userOrder.OrderPrice);
                                stiOrder.OrderStatus = (RemotingInterface.RI_Status)userOrder.OrdStatus;
                                stiOrder.OrderType = (RemotingInterface.RI_Type)userOrder.OrdType;
                                stiOrder.OrderVolume = userOrder.OrderVolume;
                                stiOrder.Side = userOrder.Side;
                                stiOrder.StockCode = userOrder.StockCode.Trim();
                                stiOrder.StockMarket = (RemotingInterface.RI_Market)userOrder.Market;
                                stiOrder.UpdatedDate = userOrder.UpdatedDate;
                                stiOrder.Curr = (RemotingInterface.RI_Currency)userOrder.Curr;
                                Common.stkBuffer.SetUserOrders(userOrder.UserID, stiOrder);
                            }
                        }
                        break;
                    default:
                        return false;
                }

                bExist = false;
                lock (listUserCash)
                {
                    for (int i = 0; i < listUserCash.Count; i++)
                    {
                        if (listUserCash[i].UserID == userFund.UserID
                            && listUserCash[i].Curr == userFund.Curr)
                        {
                            bExist = true;
                            listUserCash[i] = userFund;
                            break;
                        }
                    }
                    if (!bExist)
                    {
                        listUserCash.Add(userFund);
                    }
                }
                if (Common.stkBuffer != null)
                {
                    RemotingInterface.RI_Fund stiFund = new RemotingInterface.RI_Fund();
                    stiFund.Clear();
                    stiFund.Cash = userFund.Cash;
                    stiFund.UsableCash = userFund.UsableCash;
                    stiFund.Wealth = Common.ConvertPrice(userFund.Wealth);
                    stiFund.Curr = (RemotingInterface.RI_Currency)userFund.Curr;
                    Common.stkBuffer.SetUserFund(userFund.UserID, stiFund);
                }

                try
                {
                    Common.OrderNotifier.UserOrders_Handled(Common.WebService_PlayID, userOrder.UserID, (byte)userOrder.OrdStatus);
                }
                catch
                {
                    Common.Log("OrderNotifier.RI_UserOrders_Handled() Failed. [" + userOrder.UserID + "/" + userOrder.OrderID + "]");
                }
                return true;
            }
            catch (Exception err)
            {
                Common.Log(err);
                return false;
            }
        }
示例#4
0
        /// <summary>
        /// ��ʼ�� ���ʽ𣬶������ֹɣ�
        /// </summary>
        /// <param name="mapUserFund">�û��ʽ�</param>
        /// <param name="mapUserOrders">�û�����</param>
        /// <param name="mapUserStocks">�û��ֹ�</param>
        /// <param name="LastOrderID">��󶩵�ID</param>
        /// <returns></returns>
        public bool Initialize(ref Dictionary<int, Dictionary<byte, TradingSystem.UserFund>> mapUserFund
            , ref Dictionary<int, TradingSystem.UserOrders> mapUserOrders
            , ref Dictionary<int, List<TradingSystem.UserStocks>> mapUserStocks, ref int LastOrderID)
        {
            try
            {
                listOrdersHistory.Clear(); // ������ʷ����
                listTradingHistory.Clear();// ������ʷ����
                listUserCash.Clear(); // �û��ֽ����
                listUserOrders.Clear(); // �û���������
                listUserStocks.Clear();// �û��ֹɶ���
                listRemoveOrders.Clear(); // �Ƴ���������
                listTradingError.Clear(); // ���״������
                listFundHistory.Clear();// �ʽ���ʷ����
                listUserUsableCash.Clear(); // �û������ʽ����
                listNewUserFund.Clear();// ���û�����
                uSyncFlag = 0;// �첽��־

                if (mapUserFund == null)
                    mapUserFund = new Dictionary<int, Dictionary<byte, TradingSystem.UserFund>>();
                else
                    mapUserFund.Clear();

                if (mapUserOrders == null)
                    mapUserOrders = new Dictionary<int, TradingSystem.UserOrders>();
                else
                    mapUserOrders.Clear();

                if (mapUserStocks == null)
                    mapUserStocks = new Dictionary<int, List<TradingSystem.UserStocks>>();
                else
                    mapUserStocks.Clear();

                // �鲢�û��ֲּ�¼����������������۵����¼��㣩
                if (!MergeDB())
                    return false;

                try
                {
                    string strTable = "tbUserWealth";
                    DataSet DSUserWealth = Common.UserWealthSvc.MapUserWealth();
                    if (DSUserWealth != null && DSUserWealth.Tables.Contains(strTable) && DSUserWealth.Tables[strTable] != null &&
                        DSUserWealth.Tables[strTable].Rows != null && DSUserWealth.Tables[strTable].Rows.Count > 0 &&
                        DSUserWealth.Tables[strTable].Columns != null && DSUserWealth.Tables[strTable].Columns.Contains("USD") &&
                        DSUserWealth.Tables[strTable].Columns.Contains("HKD") && DSUserWealth.Tables[strTable].Columns.Contains("RMB")
                        && DSUserWealth.Tables[strTable].Columns.Contains("UserID"))
                    {
                        for (int i = 0; i < DSUserWealth.Tables[strTable].Rows.Count; i++)
                        {
                            UserWealth data = new UserWealth();
                            data.Initialize();
                            data.WealthUSD = Common.ConvertPrice(Convert.ToDouble(DSUserWealth.Tables[strTable].Rows[i]["USD"].ToString().Trim()));
                            data.WealthHKD = Common.ConvertPrice(Convert.ToDouble(DSUserWealth.Tables[strTable].Rows[i]["HKD"].ToString().Trim()));
                            data.WealthRMB = Common.ConvertPrice(Convert.ToDouble(DSUserWealth.Tables[strTable].Rows[i]["RMB"].ToString().Trim()));
                            mapUserWealth[Convert.ToInt32(DSUserWealth.Tables[strTable].Rows[i]["UserID"].ToString().Trim())] = data;
                        }
                        Common.UsersStatus(mapUserWealth);
                    }
                    else
                    {
                        Common.Log("Failed to get [UserWealth] info from RankSvr.");
                    }
                }
                catch
                {
                    Common.Log("Failed to get [UserWealth] info from RankSvr.");
                }

                if (sqlConn_Init.State == ConnectionState.Closed)
                    sqlConn_Init.Open();
                LastOrderID = 0;

                RemotingInterface.RI_Fund stiFund = new RemotingInterface.RI_Fund(); stiFund.Clear();
                sqlCmd_Init = new SqlCommand("SELECT * FROM [UserFund] ORDER BY UserID", sqlConn_Init);
                sqlReader_Init = sqlCmd_Init.ExecuteReader();
                while (sqlReader_Init.Read())
                {
                    Dictionary<byte, TradingSystem.UserFund> mapCurrFund = null;
                    if (mapUserFund.ContainsKey((int)sqlReader_Init["UserID"]))
                        mapCurrFund = mapUserFund[(int)sqlReader_Init["UserID"]];

                    if (mapCurrFund == null)
                        mapCurrFund = new Dictionary<byte, TradingSystem.UserFund>();

                    TradingSystem.UserFund currFund = new TradingSystem.UserFund();
                    currFund.Initialize();
                    currFund.UserID = (int)sqlReader_Init["UserID"];
                    currFund.Cash = Convert.ToDouble(sqlReader_Init["Cash"].ToString().Trim());
                    currFund.UsableCash = Convert.ToDouble(sqlReader_Init["UsableCash"].ToString().Trim());
                    currFund.Curr = (TradingSystem.Currency)Convert.ToByte(sqlReader_Init["Currency"].ToString().Trim());
                    if (currFund.Curr == TradingSystem.Currency.Unknown)
                        continue;
                    switch (currFund.Curr)
                    {
                        case TradingSystem.Currency.USD:
                            if (mapUserWealth.ContainsKey(currFund.UserID))
                                currFund.Wealth = mapUserWealth[currFund.UserID].WealthUSD;
                            else
                                currFund.Wealth = Common.stkTrading.defaultUSD;
                            break;
                        case TradingSystem.Currency.HKD:
                            if (mapUserWealth.ContainsKey(currFund.UserID))
                                currFund.Wealth = mapUserWealth[currFund.UserID].WealthHKD;
                            else
                                currFund.Wealth = Common.stkTrading.defaultHKD;
                            break;
                        default:
                            if (mapUserWealth.ContainsKey(currFund.UserID))
                                currFund.Wealth = mapUserWealth[currFund.UserID].WealthRMB;
                            else
                                currFund.Wealth = Common.stkTrading.defaultRMB;
                            break;
                    }

                    mapCurrFund[(byte)currFund.Curr] = currFund;
                    mapUserFund[currFund.UserID] = mapCurrFund;

                    if (Common.stkBuffer != null)
                    {
                        stiFund.Cash = Common.ConvertPrice(currFund.Cash);
                        stiFund.UsableCash = Common.ConvertPrice(currFund.UsableCash);
                        stiFund.Wealth = Common.ConvertPrice(currFund.Wealth);
                        stiFund.Curr = (RemotingInterface.RI_Currency)currFund.Curr;
                        Common.stkBuffer.SetUserFund(currFund.UserID, stiFund);
                    }
                }
                sqlReader_Init.Close();
                if (mapUserFund != null)
                    Common.Log(" *** [" + mapUserFund.Count + "] User Accounts've Been Loaded. *** ");

                RemotingInterface.RI_Order stiOrder = new RemotingInterface.RI_Order(); stiOrder.Clear();
                sqlCmd_Init = new SqlCommand("SELECT * FROM [UserOrders] WHERE " +
                    "(UserID IN (SELECT UserID FROM [UserFund])) AND " +
                    "(ExpiredDate >= DATENAME([year], GETDATE()) + '-' + DATENAME([month], GETDATE()) " +
                    "+ '-' + DATENAME([day], GETDATE())) ORDER BY OrderID", sqlConn_Init);
                sqlReader_Init = sqlCmd_Init.ExecuteReader();
                while (sqlReader_Init.Read())
                {
                    TradingSystem.UserOrders userOrders = new TradingSystem.UserOrders();
                    userOrders.Initialize();
                    userOrders.OrderID = (int)sqlReader_Init["OrderID"];
                    userOrders.UserID = (int)sqlReader_Init["UserID"];
                    userOrders.OrderDate = Convert.ToDateTime(sqlReader_Init["OrderDate"].ToString().Trim());
                    userOrders.UpdatedDate = Convert.ToDateTime(sqlReader_Init["UpdatedDate"].ToString().Trim());
                    userOrders.ExpiredDate = Convert.ToDateTime(sqlReader_Init["ExpiredDate"].ToString().Trim());
                    if (DateTime.Now.TimeOfDay > Common.EndPMTS && userOrders.ExpiredDate.TimeOfDay <= Common.EndPMTS)
                        continue;
                    userOrders.OrderPrice = Convert.ToDouble(sqlReader_Init["OrderPrice"].ToString().Trim());
                    userOrders.TradePrice = Convert.ToDouble(sqlReader_Init["TradePrice"].ToString().Trim());
                    userOrders.Curr = (TradingSystem.Currency)Convert.ToByte(sqlReader_Init["Currency"].ToString().Trim());
                    userOrders.OrdStatus = (TradingSystem.OrderStatus)Convert.ToByte(sqlReader_Init["OrderStatus"].ToString().Trim());
                    userOrders.OrdType = (TradingSystem.OrderType)Convert.ToByte(sqlReader_Init["OrderType"].ToString().Trim());
                    userOrders.StockCode = sqlReader_Init["StockCode"].ToString().Trim();
                    userOrders.Market = (TradingSystem.StockMarket)Convert.ToByte(sqlReader_Init["Market"].ToString().Trim());
                    userOrders.OrderVolume = (int)sqlReader_Init["OrderVolume"];
                    if (sqlReader_Init["OrderSide"].ToString().ToLower().Trim() == "true")
                        userOrders.Side = true;
                    else
                        userOrders.Side = false;
                    LastOrderID = userOrders.OrderID;
                    mapUserOrders[userOrders.OrderID] = userOrders;
                    if (Common.stkBuffer != null)
                    {
                        if (userOrders.OrderDate.Date == DateTime.Now.Date)
                        {
                            stiOrder = new RemotingInterface.RI_Order(); stiOrder.Clear();
                            stiOrder.ExpiredDate = userOrders.ExpiredDate;
                            stiOrder.OrderDate = userOrders.OrderDate;
                            stiOrder.OrderID = userOrders.OrderID;
                            stiOrder.OrderPrice = Common.ConvertPrice(userOrders.OrderPrice);
                            stiOrder.TradePrice = Common.ConvertPrice(userOrders.TradePrice);
                            stiOrder.Curr = (RemotingInterface.RI_Currency)userOrders.Curr;
                            stiOrder.OrderStatus = (RemotingInterface.RI_Status)userOrders.OrdStatus;
                            stiOrder.OrderType = (RemotingInterface.RI_Type)userOrders.OrdType;
                            stiOrder.OrderVolume = userOrders.OrderVolume;
                            stiOrder.Side = userOrders.Side;
                            stiOrder.StockCode = userOrders.StockCode.Trim();
                            stiOrder.StockMarket = (RemotingInterface.RI_Market)userOrders.Market;
                            stiOrder.UpdatedDate = userOrders.UpdatedDate;
                            Common.stkBuffer.SetUserOrders(userOrders.UserID, stiOrder);
                        }
                    }
                }
                sqlReader_Init.Close();

                RemotingInterface.RI_Stock stiStock = new RemotingInterface.RI_Stock(); stiStock.Clear();
                sqlCmd_Init = new SqlCommand("SELECT * FROM [UserStocks] WHERE " +
                    "(UserID IN (SELECT UserID FROM [UserFund])) AND (Volume > 0) ORDER BY UserID, StockCode, Market", sqlConn_Init);
                sqlReader_Init = sqlCmd_Init.ExecuteReader();
                List<TradingSystem.UserStocks> listStocks = new List<TradingSystem.UserStocks>();
                int nLastUserID = 0;
                while (sqlReader_Init.Read())
                {
                    TradingSystem.UserStocks userStock = new TradingSystem.UserStocks();
                    userStock.Initialize();
                    userStock.UserID = (int)sqlReader_Init["UserID"];
                    userStock.StockCode = sqlReader_Init["StockCode"].ToString().Trim();
                    userStock.Market = (TradingSystem.StockMarket)Convert.ToByte(sqlReader_Init["Market"].ToString().Trim());
                    userStock.Volume = (int)sqlReader_Init["Volume"];
                    userStock.AveragePrice = double.Parse(sqlReader_Init["AveragePrice"].ToString().Trim());
                    userStock.Curr = (TradingSystem.Currency)Convert.ToByte(sqlReader_Init["Currency"].ToString().Trim());
                    if (sqlReader_Init["Sellable"].ToString().Trim() == "1")
                        userStock.Sellable = true;
                    else
                        userStock.Sellable = false;
                    if (nLastUserID != userStock.UserID)
                    {
                        if (nLastUserID > 0)
                            mapUserStocks[nLastUserID] = listStocks;

                        listStocks = new List<TradingSystem.UserStocks>();
                        listStocks.Add(userStock);
                        nLastUserID = userStock.UserID;
                    }
                    else
                    {
                        listStocks.Add(userStock);
                    }
                    if (Common.stkBuffer != null)
                    {
                        stiStock.AveragePrice = Common.ConvertPrice(userStock.AveragePrice);
                        stiStock.Curr = (RemotingInterface.RI_Currency)userStock.Curr;
                        stiStock.Volume = userStock.Volume;
                        if (userStock.Sellable)
                            stiStock.SellableVolume = userStock.Volume;
                        else
                            stiStock.SellableVolume = 0;
                        stiStock.StockCode = userStock.StockCode.Trim();
                        stiStock.StockMarket = (RemotingInterface.RI_Market)userStock.Market;
                        if (Common.stkBuffer != null)
                        {
                            Common.stkBuffer.AddUserStocks(userStock.UserID, stiStock);
                        }
                    }
                }
                if (nLastUserID > 0 && listStocks.Count > 0)
                    mapUserStocks[nLastUserID] = listStocks;
                sqlReader_Init.Close();

                RemotingInterface.RI_Order stiHistoryOrder = new RemotingInterface.RI_Order();
                stiOrder.Clear();
                sqlCmd_Init = new SqlCommand("SELECT * FROM [OrdersHistory] WHERE " +
                    "(UserID IN (SELECT UserID FROM [UserFund])) AND (OrderDate >= " +
                    "DATENAME([year], GETDATE()) + '-' + DATENAME([month], GETDATE()) + '-' + " +
                    "DATENAME([day], GETDATE())) ORDER BY OrderID", sqlConn_Init);
                sqlReader_Init = sqlCmd_Init.ExecuteReader();
                while (sqlReader_Init.Read())
                {
                    TradingSystem.UserOrders userOrders = new TradingSystem.UserOrders();
                    userOrders.Initialize();
                    userOrders.OrderID = (int)sqlReader_Init["OrderID"];
                    userOrders.UserID = (int)sqlReader_Init["UserID"];
                    userOrders.OrderDate = Convert.ToDateTime(sqlReader_Init["OrderDate"].ToString().Trim());
                    userOrders.UpdatedDate = Convert.ToDateTime(sqlReader_Init["UpdatedDate"].ToString().Trim());
                    userOrders.ExpiredDate = Convert.ToDateTime(sqlReader_Init["ExpiredDate"].ToString().Trim());
                    if (DateTime.Now.TimeOfDay > Common.EndPMTS && userOrders.ExpiredDate.TimeOfDay <= Common.EndPMTS)
                        continue;
                    userOrders.OrderPrice = Convert.ToDouble(sqlReader_Init["OrderPrice"].ToString().Trim());
                    userOrders.TradePrice = Convert.ToDouble(sqlReader_Init["TradePrice"].ToString().Trim());
                    userOrders.OrdStatus = (TradingSystem.OrderStatus)Convert.ToByte(sqlReader_Init["OrderStatus"].ToString().Trim());
                    userOrders.OrdType = (TradingSystem.OrderType)Convert.ToByte(sqlReader_Init["OrderType"].ToString().Trim());
                    userOrders.StockCode = sqlReader_Init["StockCode"].ToString().Trim();
                    userOrders.Market = (TradingSystem.StockMarket)Convert.ToByte(sqlReader_Init["Market"].ToString().Trim());
                    userOrders.OrderVolume = (int)sqlReader_Init["OrderVolume"];
                    if (sqlReader_Init["OrderSide"].ToString().ToLower().Trim() == "true")
                        userOrders.Side = true;
                    else
                        userOrders.Side = false;
                    userOrders.Curr = (TradingSystem.Currency)Convert.ToByte(sqlReader_Init["Currency"].ToString().Trim());
                    mapUserOrders[userOrders.OrderID] = userOrders;
                    if (Common.stkBuffer != null)
                    {
                        if (userOrders.OrderDate.Date == DateTime.Now.Date)
                        {
                            stiHistoryOrder = new RemotingInterface.RI_Order();
                            stiOrder.Clear();
                            stiHistoryOrder.ExpiredDate = userOrders.ExpiredDate;
                            stiHistoryOrder.OrderDate = userOrders.OrderDate;
                            stiHistoryOrder.OrderID = userOrders.OrderID;
                            stiHistoryOrder.OrderPrice = Common.ConvertPrice(userOrders.OrderPrice);
                            stiHistoryOrder.TradePrice = Common.ConvertPrice(userOrders.TradePrice);
                            stiHistoryOrder.Curr = (RemotingInterface.RI_Currency)userOrders.Curr;
                            stiHistoryOrder.OrderStatus = (RemotingInterface.RI_Status)userOrders.OrdStatus;
                            stiHistoryOrder.OrderType = (RemotingInterface.RI_Type)userOrders.OrdType;
                            stiHistoryOrder.OrderVolume = userOrders.OrderVolume;
                            stiHistoryOrder.Side = userOrders.Side;
                            stiHistoryOrder.StockCode = userOrders.StockCode.Trim();
                            stiHistoryOrder.StockMarket = (RemotingInterface.RI_Market)userOrders.Market;
                            stiHistoryOrder.UpdatedDate = userOrders.UpdatedDate;
                            Common.stkBuffer.SetUserOrders(userOrders.UserID, stiHistoryOrder);
                        }
                    }
                }
                sqlReader_Init.Close();

                if (Common.stkBuffer != null)
                {
                    RemotingInterface.RI_Trading stiTrading = new RemotingInterface.RI_Trading();
                    sqlCmd_Init = new SqlCommand("SELECT * FROM [TradingHistory] WHERE (TradeDate >= " +
                        "DATENAME([year], GETDATE()) + '-' + DATENAME([month], GETDATE()) + '-' + DATENAME([day], GETDATE())) " +
                        "ORDER BY TradeDate", sqlConn_Init);
                    sqlReader_Init = sqlCmd_Init.ExecuteReader();
                    while (sqlReader_Init.Read())
                    {
                        stiTrading.Clear();
                        if (sqlReader_Init["OrderSide"].ToString().ToLower().Trim() == "true")
                            stiTrading.Side = true;
                        else
                            stiTrading.Side = false;
                        stiTrading.TradeDate = DateTime.Parse(sqlReader_Init["TradeDate"].ToString().Trim());
                        if (stiTrading.TradeDate.Date != DateTime.Now.Date ||
                            (DateTime.Now.TimeOfDay > Common.EndPMTS && stiTrading.TradeDate.TimeOfDay <= Common.EndPMTS))
                            continue;
                        stiTrading.StockCode = sqlReader_Init["StockCode"].ToString().Trim();
                        stiTrading.StockMarket = (RemotingInterface.RI_Market)byte.Parse(sqlReader_Init["Market"].ToString().Trim());
                        stiTrading.TradePrice = Common.ConvertPrice(double.Parse(sqlReader_Init["TradePrice"].ToString().Trim()));
                        stiTrading.Curr = (RemotingInterface.RI_Currency)Convert.ToByte(sqlReader_Init["Currency"].ToString().Trim());
                        stiTrading.TradeVolume = (int)sqlReader_Init["TradeVolume"];
                        if (Common.stkBuffer != null)
                        {
                            Common.stkBuffer.SetUserTradings((int)sqlReader_Init["UserID"], stiTrading);
                        }
                    }
                    sqlReader_Init.Close();

                    RemotingInterface.RI_FundChanges stiFundChanges = new RemotingInterface.RI_FundChanges();
                    sqlCmd_Init = new SqlCommand("SELECT * FROM [FundHistory] WHERE (ChangedTime >= " +
                        "DATENAME([year], GETDATE()) + '-' + DATENAME([month], GETDATE()) + '-' + DATENAME([day], GETDATE())) " +
                        "ORDER BY ChangedTime", sqlConn_Init);
                    sqlReader_Init = sqlCmd_Init.ExecuteReader();
                    while (sqlReader_Init.Read())
                    {
                        stiFundChanges.Clear();
                        stiFundChanges.ChangedCash = Convert.ToDouble(sqlReader_Init["ChangedCash"].ToString().Trim());
                        stiFundChanges.ChangedDate = Convert.ToDateTime(sqlReader_Init["ChangedTime"].ToString().Trim());
                        if (stiFundChanges.ChangedDate.Date != DateTime.Now.Date ||
                            (DateTime.Now.TimeOfDay > Common.EndPMTS && stiFundChanges.ChangedDate.TimeOfDay <= Common.EndPMTS))
                            continue;
                        stiFundChanges.Curr = (RemotingInterface.RI_Currency)Convert.ToByte(sqlReader_Init["Currency"].ToString().Trim());
                        stiFundChanges.OrderID = (int)sqlReader_Init["OrderID"];
                        stiFundChanges.OriginalCash = Convert.ToDouble(sqlReader_Init["OriginalCash"].ToString().Trim());
                        if (Common.stkBuffer != null)
                        {
                            Common.stkBuffer.SetUserFundChanges((int)sqlReader_Init["UserID"], stiFundChanges);
                        }
                    }
                    sqlReader_Init.Close();
                }

                sqlCmd_Init = new SqlCommand("SELECT TOP 1 OrderID FROM [OrdersHistory] ORDER BY OrderID DESC", sqlConn_Init);
                sqlReader_Init = sqlCmd_Init.ExecuteReader();
                if (sqlReader_Init.Read() && ((int)sqlReader_Init["OrderID"]) > LastOrderID)
                {
                    LastOrderID = (int)sqlReader_Init["OrderID"];
                }
                sqlReader_Init.Close();

                ThSync = new Thread(new ThreadStart(Synchronizing));
                ThSync.Name = "ThSynchronizing";
                ThSync.Start();
                return true;
            }
            catch (Exception err)
            {
                Common.Log(err);
                return false;
            }
            finally
            {
                if (sqlConn_Init.State != ConnectionState.Closed)
                    sqlConn_Init.Close();
            }
        }