Пример #1
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="ScanningDir">
 /// Путь к папке
 /// </param>
 /// <param name="ParentScanner">
 ///
 /// </param>
 /// <param name="MadeChanges"></param>
 /// <param name="Sync">
 /// Нужно ли выполнить синхронизацию объекта с БД и файлами, уже имеющимися в каталоге.
 /// При этом вызывается функция SyncWithFilesAndDB
 /// </param>
 /// <param name="SyncParam">
 ///
 /// </param>
 public CDirScanner(string ScanningDir,
                    CScannerBase ParentScanner,
                    bool Sync,
                    CSyncParam SyncParam = null) :
     base(ScanningDir, ParentScanner, Sync, SyncParam)
 {
     m_PathWatcher.Created += m_PathWatcher_Created;
     m_PathWatcher.Deleted += m_PathWatcher_Deleted;
     m_PathWatcher.Changed += m_PathWatcher_Changed;
     m_PathWatcher.Renamed += m_PathWatcher_Renamed;
 }
Пример #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="MadeChanges"></param>
        public override bool SyncWithFilesAndDB(CScannerBase.CSyncParamBase Param)
        {
            LastException = null;

            CSyncParam SyncParam = Param as CSyncParam;

            if (SyncParam == null ||
                SyncParam.m_Dir == GlobalDefines.DEFAULT_XML_STRING_VAL ||
                !Directory.Exists(SyncParam.m_Dir))
            {
                return(false);
            }

            using (var wrapper = new DisposableWrapper <ShowAsyncResult>(CWaitingWnd.ShowAsync(DBManagerApp.MainWnd.Title,
                                                                                               string.Format(Properties.Resources.resfmtSyncingDir, SyncParam.m_Dir),
                                                                                               DBManagerApp.MainWnd,
                                                                                               true),
                                                                         asyncResult =>
            {
                if (asyncResult?.hFinishedSearchEvent != null)
                {
                    asyncResult.hFinishedSearchEvent.Set();
                }
            }))
            {
                lock (EventsCS)
                {
                    if (State == enScanningThreadState.Worked)
                    {   // Синхронизацию можно проводить только при незапущенном сканировании
                        return(false);
                    }

                    m_PathWatcher.EnableRaisingEvents = false;

                    List <string> ScannedFilesFullPaths = new List <string>();

                    try
                    {
                        if (SyncParam.m_lstFileScannerSettings != null)
                        {
                            bool AllFilesSync = true;

                            foreach (CFileScannerSettings ScannerSettings in SyncParam.m_lstFileScannerSettings)
                            {
                                if (Path.GetDirectoryName(ScannerSettings.FullFilePath) != SyncParam.m_Dir)
                                {   // Файл не находится в просматриваемой папке => он нам не нужен
                                    AllFilesSync = false;
                                    lock (DBManagerApp.m_AppSettings.m_SettingsSyncObj)
                                        DBManagerApp.m_AppSettings.m_Settings.dictFileScannerSettings.Remove(ScannerSettings.FullFilePath);
                                    continue;
                                }

                                string FullScannerFilePath = Path.Combine(SyncParam.m_Dir, ScannerSettings.FullFilePath);
                                ScannedFilesFullPaths.Add(FullScannerFilePath);

                                CFileScanner Scanner = null;
                                if (m_FileScanners.TryGetValue(FullScannerFilePath, out Scanner))
                                {
                                    m_FileScanners[FullScannerFilePath] =
                                        Scanner = new CFileScanner(ScannerSettings.FullFilePath,
                                                                   this,
                                                                   true,
                                                                   new CFileScanner.CSyncParam(ScannerSettings.GroupId,
                                                                                               FullScannerFilePath));
                                    if (!Scanner.SyncSuccessfully)
                                    {   // Синхронизироваться не удалось
                                        m_FileScanners.Remove(FullScannerFilePath);
                                        AllFilesSync = false;
                                        lock (DBManagerApp.m_AppSettings.m_SettingsSyncObj)
                                            DBManagerApp.m_AppSettings.m_Settings.dictFileScannerSettings.Remove(ScannerSettings.FullFilePath);
                                    }
                                }
                                else
                                {
                                    Scanner = new CFileScanner(ScannerSettings.FullFilePath,
                                                               this,
                                                               true,
                                                               new CFileScanner.CSyncParam(ScannerSettings.GroupId,
                                                                                           FullScannerFilePath));
                                    if (Scanner.SyncSuccessfully)
                                    {
                                        m_FileScanners.Add(ScannerSettings.FullFilePath, Scanner);
                                    }
                                    else
                                    {   // Синхронизироваться не удалось
                                        AllFilesSync = false;
                                        lock (DBManagerApp.m_AppSettings.m_SettingsSyncObj)
                                            DBManagerApp.m_AppSettings.m_Settings.dictFileScannerSettings.Remove(ScannerSettings.FullFilePath);
                                    }
                                }
                            }

                            if (!AllFilesSync)
                            {
                                DBManagerApp.m_AppSettings.Write();
                            }
                        }

                        // Пытаемся загрузить данные из всех остальных XML-файлов, имеющихся в папке
                        string[] AllXMLFullFilePaths = Directory.GetFiles(SyncParam.m_Dir, "*.xml");
                        foreach (string FullFilePath in from xmlFileL in AllXMLFullFilePaths
                                 join xmlFileR in ScannedFilesFullPaths on xmlFileL equals xmlFileR into XMLFiles
                                 from scannedFile in XMLFiles.DefaultIfEmpty()
                                 where scannedFile == null
                                 select xmlFileL)
                        {
                            CFileScanner Scanner = null;
                            if (m_FileScanners.TryGetValue(FullFilePath, out Scanner))
                            {
                                m_FileScanners[FullFilePath] =
                                    Scanner = new CFileScanner(FullFilePath,
                                                               this,
                                                               true,
                                                               new CFileScanner.CSyncParam(m_FileScanners[FullFilePath].Group == null ?
                                                                                           GlobalDefines.NO_OUR_COMP_IN_DB :
                                                                                           m_FileScanners[FullFilePath].Group.id_group,
                                                                                           FullFilePath));
                                if (!Scanner.SyncSuccessfully)
                                {   // Синхронизироваться не удалось
                                    m_FileScanners.Remove(FullFilePath);
                                    lock (DBManagerApp.m_AppSettings.m_SettingsSyncObj)
                                        DBManagerApp.m_AppSettings.m_Settings.dictFileScannerSettings.Remove(FullFilePath);
                                    continue;
                                }
                            }
                            else
                            {
                                Scanner = new CFileScanner(FullFilePath,
                                                           this,
                                                           true,
                                                           new CFileScanner.CSyncParam(GlobalDefines.NO_OUR_COMP_IN_DB,
                                                                                       FullFilePath));

                                if (Scanner.SyncSuccessfully)
                                {   // Удалось синхронизироваться => добавляем сканер в m_FileScanners и в файл настроек
                                    m_FileScanners.Add(FullFilePath, Scanner);
                                }
                            }

                            if (Scanner.Group != null)
                            {
                                CFileScannerSettings ScannerSettings = new CFileScannerSettings()
                                {
                                    FullFilePath = FullFilePath,
                                    GroupId      = Scanner.Group.id_group
                                };
                                lock (DBManagerApp.m_AppSettings.m_SettingsSyncObj)
                                    DBManagerApp.m_AppSettings.m_Settings.dictFileScannerSettings.TryAddValue(FullFilePath, ScannerSettings);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        List <CDataChangedInfo> Changes = new List <CDataChangedInfo>();
                        OnException(ref Changes, ex, CompId);
                    }

                    if (Directory.Exists(m_PathWatcher.Path))
                    {
                        m_PathWatcher.EnableRaisingEvents = true;
                    }
                }
            }

            return(true);
        }