public static DataSet Init(Session session, DataSet initData)
        {
            TraderState       state = SessionManager.Default.GetTradingConsoleState(session);
            DataRowCollection rows  = initData.Tables["Instrument"].Rows;
            List <Guid>       instrumentsFromBursa = new List <Guid>();

            foreach (DataRow instrumentRow in rows)
            {
                state.AddInstrumentIDToQuotePolicyMapping((Guid)instrumentRow["ID"], (Guid)instrumentRow["QuotePolicyID"]);
                if (IsFromBursa(instrumentRow))
                {
                    instrumentsFromBursa.Add((Guid)instrumentRow["ID"]);
                }
            }
            //Account
            rows = initData.Tables["Account"].Rows;
            Guid[] accountIDs = new Guid[rows.Count];
            int    i          = 0;

            foreach (DataRow accountRow in rows)
            {
                if (!state.Accounts.ContainsKey(accountRow["ID"]))
                {
                    state.Accounts.Add(accountRow["ID"], null);
                    state.AccountGroups[accountRow["GroupID"]] = null;
                }
                accountIDs[i++] = (Guid)accountRow["ID"];
            }
            SessionManager.Default.AddTradingConsoleState(session, state);
            int commandSequence = CommandManager.Default.LastSequence;

            SessionManager.Default.AddNextSequence(session, commandSequence);
            DataTable customerTable = initData.Tables["Customer"];

            state.IsEmployee = (bool)customerTable.Rows[0]["IsEmployee"];
            Token   token        = SessionManager.Default.GetToken(session);
            DataSet ds           = Merge(token, initData, accountIDs);
            bool    supportBursa = Convert.ToBoolean(ConfigurationManager.AppSettings["SupportBursa"]);

            if (supportBursa)
            {
                DateTime tradeDay = DateTime.Now.Date;
                AddDefaultTimeTableForBursa(ds, tradeDay);
            }
            AddBestLimitsForBursa(ds, instrumentsFromBursa);
            ds.SetInstrumentGuidMapping();
            ds.SetCommandSequence(commandSequence);
            state.CaculateQuotationFilterSign();
            return(ds);
        }
        private InitializeData Parse(DataSet initData)
        {
            DataRowCollection rows        = initData.Tables["Instrument"].Rows;
            TraderState       traderState = SessionManager.Default.GetTradingConsoleState(_Request.ClientInfo.Session);

            Debug.Assert(traderState != null);
            traderState.Instruments.Clear();
            foreach (DataRow instrumentRow in rows)
            {
                traderState.AddInstrumentIDToQuotePolicyMapping((Guid)instrumentRow["ID"], (Guid)instrumentRow["QuotePolicyID"]);
            }
            traderState.CaculateQuotationFilterSign();

            rows = initData.Tables["Account"].Rows;
            Guid[] accountIds = new Guid[rows.Count];
            int    i          = 0;

            traderState.Accounts.Clear();
            foreach (DataRow accountRow in rows)
            {
                Guid accountId      = (Guid)accountRow["ID"];
                Guid accountGroupId = (Guid)accountRow["GroupID"];
                traderState.Accounts.Add(accountId, null);
                if (!traderState.AccountGroups.Contains(accountGroupId))
                {
                    traderState.AccountGroups.Add(accountGroupId, null);
                }
                accountIds[i++] = accountId;
            }
            InitializeData initializeData = new InitializeData();

            if (initData.Tables["OrganizationName"].Rows.Count > 0)
            {
                initializeData.OrganizationName = initData.Tables["OrganizationName"].Rows[0]["Name"] == DBNull.Value ? "" : (string)initData.Tables["OrganizationName"].Rows[0]["Name"];
            }
            else
            {
                initializeData.OrganizationName = "";
            }
            initializeData.LastSequence = CommandManager.Default.LastSequence;
            initializeData.SettingSet   = new SettingSet();
            initializeData.SettingSet.Initialize(initData);
            initializeData.TradingSet = new TradingSet();
            initializeData.TradingSet.Initialize(initData);
            if (initializeData.TradingSet.HasMessage)
            {
                DataSet dataSet = Trader.Server.CppTrader.DataMapping.Util.DataAccess.GetMessages(_Token);
                initializeData.TradingSet.InitializeMessages(dataSet);
            }

            AccountBalance[]  accountBalances   = null;
            AccountCurrency[] accountCurrencies = null;
            Contract[]        contracts         = null;

            XmlNode   accountsData = Application.Default.StateServer.GetAccountsForInit(accountIds);
            DataTable orderTable   = initData.Tables["Order"];

            orderTable.PrimaryKey = new DataColumn[] { orderTable.Columns["ID"] };

            Dictionary <Guid, Transaction> exectuedTransactions = new Dictionary <Guid, Transaction>();

            foreach (Transaction transaction in initializeData.TradingSet.Transactions)
            {
                if (transaction.Phase == Phase.Executed)
                {
                    exectuedTransactions.Add(transaction.Id, transaction);
                }
            }

            this.ParseAccountData(accountsData, orderTable.Rows, exectuedTransactions, out accountBalances, out accountCurrencies, out contracts);

            initializeData.TradingSet.AccountBalances   = accountBalances;
            initializeData.TradingSet.AccountCurrencies = accountCurrencies;
            initializeData.TradingSet.Contracts         = contracts;

            return(initializeData);
        }