public Object DoVerb(VerboseCommand command, params object[] arguments)
        {
            switch (command)
            {
                case VerboseCommand.CheckReady:
                    {
                        if (System.IO.File.Exists(eegSynapseExecPath) == false)
                            throw new Exception("Не найден файл запуска программы"); // ("Application executable file not found!");

                        bool result = true;//TryToFindSemaphore(SYNAPSE_SEMAPHORE) == false ? System.IO.File.Exists(eegSynapseExecPath) : false;
                       return result;
                    }
                    //break;
                case VerboseCommand.ExtractData:
                    {
                        return PatientDataHelper.GetPatientInfo(Convert.ToString(arguments[0]));
                    }
                   // break;
                case VerboseCommand.HasLaunchedProcess:
                    {
                        if (eegSysnapseProcess != null)
                            return true;
                        else
                            return false;
                    }
                case VerboseCommand.CheckFiles:
                    {
                        Dictionary<Guid, string> files = arguments[0] as Dictionary<Guid, string>;

                        return files;
                    }
                case VerboseCommand.AllowEmptyFile:
                    {
                        return AllowEmptyFile;
                    }
                case VerboseCommand.CanCreate:
                    {
                        return CanCreate;
                    }
                case VerboseCommand.GetModeInformation:
                    {
                        return new [] {moduleInformation};

                    }
                case VerboseCommand.GetConfiguration:
                    {
                        return new[] {  String.Format("{0},{1},{2}",
                             this.GetType().Assembly.GetName().Name, this.GetType().Assembly.GetName().Version, eegSynapseExecPath) };
                    }

                default:
                     return null;

            }
        }
Exemple #2
0
        public Object DoVerb(VerboseCommand verb, params object[] args)
        {
            //Object result = null;

            return false;
        }
        /// <summary>
        /// Метод выполняет сервисные команды контроллера БД 
        /// </summary>
        /// <param name="command">Команда</param>
        /// <param name="arguments">Дополнительные параметры</param>
        /// <returns></returns>
        public Object DoVerb(VerboseCommand command, params object[] arguments)
        {
            switch (command)
            {
                case VerboseCommand.CheckReady: // проверяем готовность приложения
                    { // БД проводит только грубую проверку по семафору
                        // Дополнительную проверку на режим работы с БД производят сами модули
                        // т.е если после запуска новый модуль спрашивает существующий в каком режиме он работает, если режимы не совместимы - новый модуль завершается
                        ExecuteCommand exec = (ExecuteCommand)arguments[0];

                        bool result = true;

                        if (exec == ExecuteCommand.Open)
                        {// модулей анализа может быть много поэтому всегда true
                            if (EEGStudioModuleMode == EEG_STUDIO_MODE.ONLY_PROCESS || EEGStudioModuleMode == EEG_STUDIO_MODE.BOTH_MODULE)
                            {
                                result = CheckEEGStudioStatus(EEG_STUDIO_PROC); //true;
                            }
                            else // если модуль работает в режиме ONLY_ACQUISITION то проверяем семафор модуля ввода
                            {
                                throw new Exception("EEG_STUDIO_MODE.ONLY_ACQUISITION");
                            }
                        }
                        else if (exec == ExecuteCommand.New || exec == ExecuteCommand.Resume) // Ввод может быть только один проверяем файл и семафор
                        {
                            if (EEGStudioModuleMode == EEG_STUDIO_MODE.ONLY_ACQUISITION || EEGStudioModuleMode == EEG_STUDIO_MODE.BOTH_MODULE)
                            {
                                if (TryToFindSemaphore(EEG_STUDIO_INPUT) == true)
                                {// если обнаружен семафор модуля ввода
                                    throw new Exception("Модуль ввода может быть открыт только в одном экземпляре...");
                                }
                            }
                            else
                            {// если плагин настроен на работу в режиме только анализа
                                throw new Exception("EEG_STUDIO_MODE.ONLY_PROCESS");
                            }
                        }
                        else if (exec == ExecuteCommand.Null)
                        {
                            throw new Exception("Программа EEG Studio не найдена!");//("EEG_STUDIO_MODE.NULL");
                        }

                        return result;
                    }

                case VerboseCommand.ExtractData: // Извлекаме данные пациента из файла MDFX
                    {
                        return PatientDataHelper.ReadPatientInfoFromMDXF(Convert.ToString(arguments[0]));
                    }

                case VerboseCommand.HasLaunchedProcess: // Проверяем имеет ли модуль не завершенные процессы
                    {
                        if (eegStudioItems.Any(item => item.Process != null) == true) { return true; }
                        else { return false; }
                    }
                case VerboseCommand.CheckFiles: // проверяем файлы в работе
                    {
                        Dictionary<Guid, string> files = arguments[0] as Dictionary<Guid, string>;

                        foreach (var item in eegStudioItems)
                            FoundedFilesProcessing(item.Mode, ref files);

                        //FoundedFilesProcessing(EEG_STUDIO_INPUT, ref files);

                        //FoundedFilesProcessing(EEG_STUDIO_PROC, ref files);

                        return files;
                    }
                case VerboseCommand.GetModeInformation:
                    {
                        return eegStudioItems.Select(item => (item.ActionInformation));
                    }
                case VerboseCommand.AllowEmptyFile: // разрешено ли удаление пустого файла
                    {
                        return AllowEmptyFile;
                    }
                case VerboseCommand.CanCreate:
                    {
                        return CanCreate;
                    }
                case VerboseCommand.SupportMultiMode:
                    {
                        if (EEGStudioModuleMode == EEG_STUDIO_MODE.BOTH_MODULE) { return true; }
                        else { return false; }
                    }
                case VerboseCommand.GetConfiguration: // получаем информацию о плагине
                    {
                        return eegStudioItems.Select(item => (String.Format("{0},{1},{2}",
                            this.GetType().Assembly.GetName().Name, this.GetType().Assembly.GetName().Version, item.ExecuteFile)));
                    }

                default:
                    return false;
            }
        }
        //(String verb, params object[] args)
        public Object DoVerb(VerboseCommand command, params object[] args)
        {
            Object result = null;
            switch (command)
            {
                case VerboseCommand.CheckReady://"CheckReadyToStart":
                //    Guid oid = (Guid)args[0];
                //    if (oid== Guid.Parse(SYS_CONST.SX_EXAMINATION_TYPE_EEG_WINEEG))
                //    {
                //        try
                //        {
                //            if (System.IO.File.Exists(GetStartupPath(STARTUP_MODE.WinEEG)))
                //            {
                //                IntPtr handle = FindWindow(WIN_EEG, null);

                //                if (handle != IntPtr.Zero)
                //                {
                //                    result = false;
                //                    DevExpress.XtraEditors.XtraMessageBox.Show(DevExpress.ExpressApp.Utils.CaptionHelper.GetLocalizedText("Messages", "WinEEGIsRunning"));
                //                }
                //                else
                //                    result = true;
                //            }
                //            else result = false;
                //        }
                //        catch { }
                //        break;
                //    }

                //    if (oid==Guid.Parse(SYS_CONST.SX_EXAMINATION_TYPE_EEG_2000))
                //    {
                //        if (System.IO.File.Exists(GetStartupPath(STARTUP_MODE.Synapse)))
                //        {
                //            bool synapseExist = false;
                //            try
                //            {
                //                Semaphore semaphore = Semaphore.OpenExisting(SYNAPSE_SEMAPHORE);
                //                synapseExist = true;
                //                semaphore.Release();
                //            }
                //            catch (WaitHandleCannotBeOpenedException)
                //            {
                //                synapseExist = false;
                //            }
                //            catch (Exception ex)
                //            {
                //                synapseExist = false;
                //            }

                //            if (synapseExist == true)
                //            {
                //                result = false;
                //                DevExpress.XtraEditors.XtraMessageBox.Show(DevExpress.ExpressApp.Utils.CaptionHelper.GetLocalizedText("Messages", "SynapseIsRunning"));
                //            }
                //            else
                //                result = true;
                //        }
                //        else result = false;

                //        break;
                //    }
                //    break;
                //case VerboseCommand.CheckReady://"CheckReadyToStartWinEEG":
                //    try
                //    {
                //        if (System.IO.File.Exists(GetStartupPath(STARTUP_MODE.WinEEG)))
                //        {
                //            IntPtr handle = FindWindow(WIN_EEG, null);

                //            if (handle != IntPtr.Zero)
                //            {
                //                result = false;
                //                DevExpress.XtraEditors.XtraMessageBox.Show(DevExpress.ExpressApp.Utils.CaptionHelper.GetLocalizedText("Messages", "WinEEGIsRunning"));
                //            }
                //            else
                //                result = true;
                //        }
                //        else result = false;
                //    }
                //    catch { }
                //    break;

                //case VerboseCommand.CheckReady://"CheckReadyToStartSynapse":
                //    if (System.IO.File.Exists(GetStartupPath(STARTUP_MODE.Synapse)))
                //    {
                //        bool synapseExist = false;
                //        try
                //        {
                //            Semaphore semaphore = Semaphore.OpenExisting(SYNAPSE_SEMAPHORE);
                //            synapseExist = true;
                //            semaphore.Release();
                //        }
                //        catch (WaitHandleCannotBeOpenedException)
                //        {
                //            synapseExist = false;
                //        }
                //        catch (Exception ex)
                //        {
                //            synapseExist = false;
                //        }

                //        if (synapseExist == true)
                //        {
                //            result = false;
                //            DevExpress.XtraEditors.XtraMessageBox.Show(DevExpress.ExpressApp.Utils.CaptionHelper.GetLocalizedText("Messages", "SynapseIsRunning"));
                //        }
                //        else
                //            result = true;
                //    }
                //    else result = false;

                //    break;

                //case VerboseCommand.ExtractData://"ExtractPatientData":
                //    return PatientDataExtractorMEF.GetPatientInfo(Convert.ToString(args[0]));

                //case "OpenFile":
                //    IFileData fileData = args.Length > 0 ?args[0] as IFileData : null;
                //    if (fileData != null)
                //    {
                //        OpenFile(fileData);
                //    }
                //    break;

                case VerboseCommand.Null://"WinEEG":
                    //{
                    //    var src = this.GetType().Assembly.GetCustomAttributes(typeof(ImageAssociationAttribute), true);

                    //    RegistryKey key = RegistryKey.OpenRemoteBaseKey(Microsoft.Win32.RegistryHive.CurrentUser, "");
                    //    RegistryKey target_key = key.OpenSubKey(@"Software\Mitsar\Path");
                    //    if (target_key != null ? target_key.GetValueNames().Contains("MainEegPath") : false)
                    //    {
                    //        String path = Convert.ToString(target_key.GetValue("MainEegPath")) + "eeg.exe";

                    //        Process process = new Process();
                    //        ProcessStartInfo ps = new ProcessStartInfo(path);
                    //        process.StartInfo = ps;
                    //        process.Start();
                    //    }
                    //}
                    break;

                default:

                    break;
            }

            return false;
        }