Exemple #1
0
        public static void ReadConfig <TypeOfConfig>(ref TypeOfConfig config, string configName) where TypeOfConfig : IXMLSerializable, IIsValidable, new()
        {
            string configFileName = @"\" + configName + ".xml";

            string pathToConfig = CUtil.GetConfigDir() + configFileName;

            config = new TypeOfConfig()
            {
                FileName = pathToConfig, NeedSelfInit = false
            };


            CSerializator.Read <TypeOfConfig>(ref config);

            if (!config.IsValid)
            {
                string pathToBkpConfig = CUtil.GetConfigBackupDir() + configFileName;
                config = new TypeOfConfig()
                {
                    FileName = pathToConfig, NeedSelfInit = false
                };
                CSerializator.Read <TypeOfConfig>(ref config);

                if (config.IsValid)
                {
                    config.FileName = pathToConfig;
                    CSerializator.Write <TypeOfConfig>(ref config);
                }
                else //backup is still invalid
                {
                    throw new ApplicationException("Invalid config " + configName);
                }
            }
        }
        public MainWindowViewModel()
        {
            try
            {
                m_mainWindow = (MainWindow)App.Current.Windows[0];

                string path = CUtil.GetConfigDir() + "\\GUIConfig.xml";

                m_GUICOnfig = new CGUIConfig(path);
                CSerializator.Read <CGUIConfig>(ref m_GUICOnfig);


                if (m_mainWindow != null)
                {
                    if (!DesignerProperties.GetIsInDesignMode(m_mainWindow))
                    {
                        (new Thread(ThreadFunc)).Start();
                    }
                }



                //TODO normal, command, etc...

                m_mainWindow.Closed += new EventHandler(m_mainWindow_Closed);
            }
            catch (Exception e)
            {
                Error(" MainWindowViewModel. ", e);
            }
        }
Exemple #3
0
        public CLogger(string fileName, bool flushMode = true, string subDir = "", bool useMicroseconds = false)
        {
            _subDir = subDir;

            m_fileName        = fileName;
            m_flushMode       = flushMode;
            m_useMicroseconds = useMicroseconds;

            string m_rootDir = Application.StartupPath;
            // _creationTime = DateTime.Now;


            string        pathToConfig = CUtil.GetConfigDir() + @"\globalSettings.xml"; //System.AppDomain.CurrentDomain.BaseDirectory + @"config\globalSettings.xml";
            CGlobalConfig GlobalConfig = new CGlobalConfig(pathToConfig);

            CSerializator.Read <CGlobalConfig>(ref GlobalConfig);


            //       CSerializator.Write<CGlobalConfig>(ref GlobalConfig);

            if (GlobalConfig.LogExternal)
            {
                //string stEnvPathToLog = GlobalConfig.EnvVarLogFilePath;
                stLogDir = CUtil.GetLogDir() + "\\"; ///      Environment.GetEnvironmentVariable(stEnvPathToLog);
            }
            else
            {
                stLogDir = m_rootDir + "\\log\\";
            }


            CreateNewFile(bInitial: true);
        }
Exemple #4
0
        private void ReadGlobalConfig()
        {
            string pathFile = CUtil.GetConfigDir() + @"\globalSettings.xml";

            _globalConfig = new CGlobalConfig(pathFile);
            CSerializator.Read <CGlobalConfig>(ref _globalConfig);
        }
Exemple #5
0
        public void ReadVisualStockConfig()
        {
            string pathToConfig = CUtil.GetConfigDir() + @"\StockVisual.xml";

            _stocksVisualConf = new CStocksVisualConf(pathToConfig, false);

            CSerializator.Read <CStocksVisualConf>(ref _stocksVisualConf);
        }
Exemple #6
0
        public void LoadColorList()
        {
            _colorList = new CColorList(needSelfInit: false);


            string path = CUtil.GetConfigDir() + @"\colorlist.xml";

            _colorList.FileName = path;
            CSerializator.Read(ref _colorList);
        }
        public void WriteAllDataToDisk()
        {
            //TO DO older 2 days

            //  if (bCopyIsBusy)
            //     return;



            bCopyIsBusy = true;


            CopyDictTFArray(ref CopyDict);

            //m_timeFrameAnalyzer.Plaza2Connector.Log("ElapsedMilliseconds=" + sw.ElapsedMilliseconds + " " + m_timeFrameAnalyzer.IsinDir);
            //    CDictTFArray cp = (CDictTFArray)  this.MemberwiseClone();



            try
            {
                foreach (KeyValuePair <string, SortedDictionary <DateTime, CTimeFrameArray> > kv in CopyDict)// this)
                {
                    string tf = kv.Key;

                    foreach (KeyValuePair <DateTime, CTimeFrameArray> kv2 in kv.Value)
                    {
                        DateTime        dt  = kv2.Key;
                        CTimeFrameArray tfa = kv2.Value;
                        if (!CUtilTime.OlderThanTwoWorkDays(dt))
                        {
                            tfa.FileName = m_timeFrameAnalyzer.GetFileName(tf, dt);

                            //   tfa.mxLockFile.WaitOne();
                            this.m_timeFrameAnalyzer.CreateDirectoriesIfNeed();
                            CSerializator.Write <CTimeFrameArray>(ref tfa);

                            tfa.DtLastWrite = DateTime.Now;

                            //    TaskCopyBackup(tfa.FileName);



                            //   tfa.mxLockFile.ReleaseMutex();
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Error("WriteAllDataToDisk", e);
            }

            bCopyIsBusy = false;
        }
        private void ReadConfASTSConnector()
        {
            string path = CUtil.GetConfigDir() + @"\ConfASTSConnector.xml";

            _confASTSConnector = new ConfASTSConnector()
            {
                NeedSelfInit = false,
                FileName     = path
            };


            CSerializator.Read(ref _confASTSConnector);
        }
Exemple #9
0
        private void ReadServerConf()
        {
            try
            {
                string pathToConfig = CUtil.GetConfigDir() + @"\servers.xml";
                _serverConfig = new CServersConf(pathToConfig, false);

                CSerializator.Read <CServersConf>(ref _serverConfig);

                _serverConfig.Servers.ForEach(a => a.IsConnected = false);
            }
            catch (Exception e)
            {
                Error("CBaseCommunicator", e);
            }
        }
        public CStockStruct(string isin, List <CBotBase> listBot, /*CPlaza2Connector*/ IClientStockStruct plaza2Connector,
                            int stockDepth)
        {
            m_stockDepth = stockDepth;

            RawStocks = new CRawStock[stockDepth];



            string dataPath = plaza2Connector.GetDataPath();

            NeedReInitStock = false;


            this.InpBuffStocks = new CListRowStock(isin, dataPath);

            if (File.Exists(InpBuffStocks.FileName))
            {
                CSerializator.Read <CListRowStock>(ref InpBuffStocks);
            }


            m_plaza2Connector = plaza2Connector;
            Isin    = isin;
            ListBot = listBot;

            ThreadProcessing = new Thread(ThreadFunc);



            if (m_plaza2Connector.GlobalConfig.StockThreadPriorityAboveNorm)
            {
                //ThreadProcessing.Priority = ThreadPriority.AboveNormal;//KAA 2016-01-02
                ThreadProcessing.Priority = ThreadPriority.Highest;
            }
            ThreadProcessing.Start();


            _parStockStructMaxQueueSize = m_plaza2Connector.GlobalConfig.StockStructMaxQueueSize;

            /*StockConverter*/ _stockConverter = new CStockConverterP2(stockDepth, Isin, (IClientStockConverter)m_plaza2Connector);
        }
Exemple #11
0
        public MainWindow()
        {
            InitializeComponent();
            Closing += OnWindowClosing;

            string        pathToConfig = CUtil.GetConfigDir() + @"\globalSettings.xml"; //System.AppDomain.CurrentDomain.BaseDirectory + @"config\globalSettings.xml";
            CGlobalConfig GlobalConfig = new CGlobalConfig(pathToConfig);

            CSerializator.Read <CGlobalConfig>(ref GlobalConfig);



            (new Thread(ThreadTCPClient)).Start();


            Stock.ModelMarket = modelMarket;

            Stock.SetParameters(10);
            Stock.CreateStockRecords();
        }
Exemple #12
0
        /// <summary>
        /// Saves terminalc config to file
        ///
        /// Call from:
        /// 1. KernelTerminal.SaveWindowPosition (task called before)
        /// 2. SettingsTerminalWindow.SaveTerminalSettings (task)
        ///
        /// </summary>
        public void SaveTerminalSettings()
        {
            double parSecsWriteBackup = 60;

            lock (TerminalConfig)
            {
                //GUIDispatcher.Invoke(new Action(()=>ReReadSharedSettings()));
                CSerializator.Write <CTerminalConfig>(ref _terminalConfig);

                //Write backup if time to do it
                if ((DateTime.Now - _dtLastSave).TotalSeconds > parSecsWriteBackup)
                {
                    CTerminalConfig terminalConfigBackup = _terminalConfig;

                    terminalConfigBackup          = (CTerminalConfig)_terminalConfig.Copy();
                    terminalConfigBackup.FileName = CUtil.GetConfigBackupDir() + @"\terminal.xml";
                    CSerializator.Write <CTerminalConfig>(ref terminalConfigBackup);

                    _dtLastSave = DateTime.Now;
                }
            }
        }
Exemple #13
0
 public void Dump()
 {
     m_internalStock.Bids = ((CStocksDict)this.MemberwiseClone())[Direction.Down];
     m_internalStock.Asks = ((CStocksDict)this.MemberwiseClone())[Direction.Up];
     CSerializator.Write <SerializebleStock>(ref m_internalStock);
 }
Exemple #14
0
 public void SaveConfig()
 {
     CSerializator.Write <CTradeManagerConfig>(ref _tradeManagerConf);
 }
        private void AnalizeDiskData()
        {
            try
            {       //Load data from disk first
                if (Directory.Exists(IsinDir))
                {
                    string[] Files = Directory.GetFiles(IsinDir);
                    foreach (string fn in Files)
                    {
                        FileInfo f = new FileInfo(fn);
                        if (f.Length == 0)
                        {
                            File.Delete(fn);
                            Error("Remove empty file " + fn);
                            continue;
                        }

                        Regex newReg = new Regex(@"[\w\W]*([0-9]{4}_[0-9]{2}_[0-9]{2})_(M1|M5|M15|M30|H1|D1).xml");
                        Match m      = newReg.Match(fn);

                        if (m.Groups.Count > 1)
                        {
                            string          stTF   = m.Groups[2].ToString();
                            string          stDate = m.Groups[1].ToString();
                            DateTime        dt     = CUtilTime.GetDateFromString(stDate);
                            CTimeFrameArray tfa    = new CTimeFrameArray();
                            tfa.FileName = fn;
                            //CSerializator.Read<CTimeFrameArray>(ref tfa);
                            CSerializator.ReadSafe <CTimeFrameArray>(ref tfa);

                            m_dictTFArray.AddTFArray(stTF, dt, tfa);


                            string st = "";
                            if (tfa.ListTimeFrameInfo.Count == 0)
                            {
                                st = "";
                            }


                            //  Plaza2Connector.GUIBox.ExecuteCandlesUpdate
                            //    (new Action(() => Plaza2Connector.GUIBox.GUICandleBox.AddTFArray(tfa.ListTimeFrameInfo[0].Isin, stTF, dt.ToString(), tfa)));
                        }
                    }

                    AnalyzeDiskTF(CUtilTF.IsClosed_M5_M15_M30_TF, m_M5_scale, EnmTF.M5, EnmTF.M1);
                    AnalyzeDiskTF(CUtilTF.IsClosed_M5_M15_M30_TF, m_M15_scale, EnmTF.M15, EnmTF.M5);
                    AnalyzeDiskTF(CUtilTF.IsClosed_M5_M15_M30_TF, m_M30_scale, EnmTF.M30, EnmTF.M15);
                    AnalyzeDiskTF(CUtilTF.IsClosed_H1, m_M30_scale, EnmTF.H1, EnmTF.M30);

                    AnalyzeDiskTFDays();


                    //CreateCandlesArrays();
                }
            }

            catch (Exception e)
            {
                Error("AnalizeDiskData", e);
            }
        }