private bool RefreshItems(string FullFilePath = null)
        {
            if (FullFilePath == null)
            {
                Comps.Clear();

                GlobalDefines.CheckPublishingDirExists();

                foreach (string Dir in Directory.EnumerateDirectories(GlobalDefines.STD_PUBLISHING_LOG_DIR))
                {
                    try
                    {
                        foreach (string FullPath in Directory.EnumerateFiles(Dir))
                        {
                            HandleFile(FullPath);
                        }
                    }
                    catch
                    { }
                }
                return(true);
            }
            else
            {
                return(HandleFile(FullFilePath));
            }
        }
        private void AddItemToLog(CLogItem LogItem, CQueueItem Item)
        {
            GlobalDefines.CheckPublishingDirExists();

            string Dir = GlobalDefines.STD_PUBLISHING_LOG_DIR + Item.CompId.ToString() + "\\";

            if (!Directory.Exists(Dir))
            {
                Directory.CreateDirectory(Dir);
            }

            try
            {
                using (TextWriter tw = new StreamWriter(string.Format("{0}{1}\\{2}{3}",
                                                                      GlobalDefines.STD_PUBLISHING_LOG_DIR,
                                                                      Item.CompId,
                                                                      Item.GroupId,
                                                                      GlobalDefines.PUBLISHING_LOG_FILE_EXTENSION), true))
                {
                    tw.WriteLine(LogItem.ToLogFileString());
                }
            }
            catch (Exception ex)
            {
                ex.ToString(); // make compiler happy
            }
        }
            private void Groups_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
            {
                switch (e.Action)
                {
                case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
                case System.Collections.Specialized.NotifyCollectionChangedAction.Replace:
                    if (e.NewItems != null)
                    {
                        Groups.CollectionChanged -= Groups_CollectionChanged;

                        foreach (CGroupItem item in e.NewItems)
                        {
                            item.ClearCommaand = new CCommand(() =>
                            {
                                if (MessageBox.Show(Properties.Resources.resDeleteLogQuestion,
                                                    Properties.Resources.resDeletion,
                                                    MessageBoxButton.YesNo,
                                                    MessageBoxImage.Question,
                                                    MessageBoxResult.No) == MessageBoxResult.Yes)
                                {
                                    GlobalDefines.CheckPublishingDirExists();

                                    File.Delete(string.Format("{0}{1}\\{2}{3}",
                                                              GlobalDefines.STD_PUBLISHING_LOG_DIR,
                                                              id,
                                                              item.id,
                                                              GlobalDefines.PUBLISHING_LOG_FILE_EXTENSION));
                                    Groups.Remove(item);

                                    if (Groups.Count == 0)
                                    {
                                        Directory.Delete(string.Format("{0}{1}",
                                                                       GlobalDefines.STD_PUBLISHING_LOG_DIR,
                                                                       id));
                                        RaiseDeleteMe();
                                    }
                                }
                            });
                        }

                        Groups.CollectionChanged += Groups_CollectionChanged;
                    }
                    break;
                }
            }
        };                                                                             // инициализацию m_PathWatcher нужно делать именно здесь, а не в конструкторе, т.к метод Start вызывется раньше создания класса


        public CPublishingResultsLogWnd()
        {
            InitializeComponent();

            GlobalDefines.CheckPublishingDirExists();

            txtLogFilePath.Text = GlobalDefines.STD_PUBLISHING_LOG_DIR;

            m_LogFileWatcher.Changed += m_LogFileWatcher_Changed;

            m_LogFileWatcher.BeginInit();
            m_LogFileWatcher.Path = GlobalDefines.STD_PUBLISHING_LOG_DIR;
            m_LogFileWatcher.EnableRaisingEvents = true; // Эту операцию нужно делать после запуска всех сканеров файлов
            m_LogFileWatcher.EndInit();

            Comps.CollectionChanged += Comps_CollectionChanged;

            RefreshItems();
        }
        private bool HandleFile(string FullFilePath)
        {
            CGroupItem GroupChanged = null;
            CCompItem  Comp         = null;

            long   id        = -1;
            string FileDir   = System.IO.Path.GetDirectoryName(FullFilePath);
            int    LastSlash = FileDir.LastIndexOf('\\');

            if (long.TryParse(FileDir.Right(FileDir.Length - LastSlash - 1), out id))
            {
                Comp = Comps.FirstOrDefault(arg => arg.id == id);
                if (Comp == null)
                {       // Такого соревнования нет => его нужно добавить
                    Comp = new CCompItem(id)
                    {
                        FolderName = id.ToString() + "\\"
                    };
                    descriptions desc = DBManagerApp.m_Entities.descriptions.FirstOrDefault(arg => arg.id_desc == id);
                    if (desc == null)
                    {
                        return(false);
                    }
                    else
                    {
                        Comp.CompName = desc.name;
                    }

                    if (long.TryParse(System.IO.Path.GetFileNameWithoutExtension(FullFilePath), out id))
                    {
                        GroupChanged = AddNewGroup(Comp, id);
                        if (GroupChanged == null)
                        {
                            return(false);
                        }
                    }
                    else
                    {   // неверное название файла
                        return(false);
                    }

                    Comps.Add(Comp);
                }
                else
                {
                    if (long.TryParse(System.IO.Path.GetFileNameWithoutExtension(FullFilePath), out id))
                    {
                        GroupChanged = Comp.Groups.FirstOrDefault(arg => arg.id == id);
                        if (GroupChanged == null)
                        {       // Группы нет => добавляем
                            GroupChanged = AddNewGroup(Comp, id);
                            if (GroupChanged == null)
                            {
                                return(false);
                            }
                        }
                    }
                }
            }
            else
            {   // неверное название файла
                return(false);
            }

            GroupChanged.Items.Clear();

            GlobalDefines.CheckPublishingDirExists();

            List <CLogItem> lstItems = new List <CLogItem>();

            try
            {
                using (TextReader tr = new StreamReader(string.Format("{0}{1}\\{2}{3}",
                                                                      GlobalDefines.STD_PUBLISHING_LOG_DIR,
                                                                      Comp.id,
                                                                      GroupChanged.id,
                                                                      GlobalDefines.PUBLISHING_LOG_FILE_EXTENSION)))
                {
                    string   line         = null;
                    CLogItem CurLogItem   = null;
                    DateTime ItemDateTime = DateTime.Now;
                    enOnlineResultsLogItemType ItemType = enOnlineResultsLogItemType.None;

                    do
                    {
                        line = tr.ReadLine();

                        if (line == null)
                        {       // Файл закончился
                            break;
                        }
                        else
                        {
                            string[] Fields = line.Split(GlobalDefines.PUBLISHING_LOG_FIELDS_SEPARATOR);
                            // Переносы строк не используем в логе для удобства, поэтому добавляем их там, где они нужны
                            for (int i = 0; i < Fields.Length; i++)
                            {
                                Fields[i] = Fields[i].Replace(GlobalDefines.PUBLISHING_LOG_LFCR_SYMBOL, '\n');
                            }
                            int Index = 0;
                            if (Enum.TryParse <enOnlineResultsLogItemType>(Fields[Index++], out ItemType) &&
                                DateTime.TryParse(Fields[Index++], out ItemDateTime))
                            {
                                CurLogItem = new CLogItem()
                                {
                                    Type         = ItemType,
                                    CreationDate = ItemDateTime,
                                };

                                if (Fields.Length > Index)
                                {
                                    CurLogItem.PCWbkName = Fields[Index].Trim();
                                }
                                Index++;

                                if (Fields.Length > Index)
                                {
                                    CurLogItem.Text = Fields[Index].Trim();
                                }
                                Index++;

                                lstItems.Add(CurLogItem);
                            }
                        }
                    }while (line != null);
                }
            }
            catch
            { }

            lstItems.Sort((lhs, rhs) => - lhs.CreationDate.CompareTo(rhs.CreationDate));
            GroupChanged.Items.AddRange(lstItems);

            return(true);
        }