public ServiceMessage Process(ServiceMessage Message) { ServiceMessage serviceMessage = null; switch (Message.Message) { #if (LEADTOOLS_V19_OR_LATER_MEDICAL_VERIFY_ADDINS) || (LEADTOOLS_V19_OR_LATER) case MessageNames.IsAddinHealthy: serviceMessage = new ServiceMessage(); string error; serviceMessage.Message = Message.Message; serviceMessage.Success = CanAccessDatabase(out error); serviceMessage.Error = error; break; #endif case ExternalStoreMessage.ExternalStore: ExternalStore(Message.Data[0] as string); break; case ExternalStoreMessage.CancelExternalStore: CancelExternalStore(); break; case ExternalStoreMessage.Clean: int expirationDays = 0; int?intValue = Message.Data[1] as int?; if (intValue.HasValue) { expirationDays = intValue.Value; } Clean(Message.Data[0] as string, expirationDays); break; case ExternalStoreMessage.Restore: Restore(Message.Data[0] as string, Message.Data[1] as DateRange); break; case ExternalStoreMessage.CancelRestore: CancelRestore(); break; case ExternalStoreMessage.Reset: DateRange range = Message.Data[0] as DateRange; Reset(range); break; case ExternalStoreMessage.SettingsChanged: DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "Received 'ExternalStoreMessage.SettingsChanged' Message"); Module.StopExternalStoreJobs(); IEnumerable <ICrud> allCruds = DataAccessServiceLocator.RetrieveAll <ICrud>(); foreach (ICrud crud in allCruds) { crud.SettingsChanged(); } break; } return(serviceMessage); }
public static void ExternalStoreSettingsChanged() { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "Azure Module.ExternalStoreSettingsChanged()"); Settings.RefreshSettings(); Type[] extraTypes = new Type[] { typeof(AzureConfiguration) }; Options = Settings.GetAddInCustomData <ExternalStoreOptions>(ExternalStorePresenter._Name, "ExternalStoreOptions", extraTypes); ExternalStorePresenter.MyDumpExternalStoreOptions("Azure ExternalStoreSettingsChanged() -- options about to be saved", Options); ExternalStore.Addin.Module.StartExternalStoreJobs(AzureExternalStoreAddinConfig, "Azure"); }
public static void MyDumpExternalStoreOptions(string prefix, ExternalStoreOptions options) { ExternalStoreItem item = options.GetCurrentOption(); if (item != null) { string s = string.Format("****** '{0}' \n\tExternalStoreJob '{1}'\n\tCleanJob '{2}'", prefix, (item.ExternalStoreJob != null), (item.CleanJob != null)); DicomUtilities.DebugString(DebugStringOptions.ShowCounter, s); } }
public static void StartExternalStoreJobs(ExternalStoreAddinConfigAbstract addinExternalStoreAddinConfig, string addinFriendlyName) { ExternalStoreItem item = null; if (Options != null) { item = Options.GetCurrentOption(); } if ((item != null) && (addinExternalStoreAddinConfig != null) && (item.ExternalStoreAddinConfig.Equals(addinExternalStoreAddinConfig))) { ICrud crud = item.ExternalStoreAddinConfig.GetCrudInterface(); crud.Initialize(); DataAccessServiceLocator.Register <ICrud>(crud); DataAccessServiceLocator.Register <ICrud>(crud, crud.ExternalStoreGuid); StorageConfigManager = new StorageModuleConfigurationManager(true); StorageConfigManager.Load(ServiceDirectory); System.Configuration.Configuration configuration = DicomDemoSettingsManager.GetGlobalPacsAddinsConfiguration(_serviceDirectory); IExternalStoreDataAccessAgent externalStoreAgent; if (!DataAccessServices.IsDataAccessServiceRegistered <IExternalStoreDataAccessAgent>()) { externalStoreAgent = DataAccessFactory.GetInstance(new ExternalStoreDataAccessConfigurationView(configuration, null, _displayName)).CreateDataAccessAgent <IExternalStoreDataAccessAgent>(); DataAccessServices.RegisterDataAccessService <IExternalStoreDataAccessAgent>(externalStoreAgent); } else { externalStoreAgent = DataAccessServices.GetDataAccessService <IExternalStoreDataAccessAgent>(); } IStorageDataAccessAgent storageAgent; if (!DataAccessServices.IsDataAccessServiceRegistered <IStorageDataAccessAgent>()) { storageAgent = DataAccessFactory.GetInstance(new StorageDataAccessConfigurationView(configuration, null, _displayName)).CreateDataAccessAgent <IStorageDataAccessAgent>(); DataAccessServices.RegisterDataAccessService <IStorageDataAccessAgent>(storageAgent); } else { storageAgent = DataAccessServices.GetDataAccessService <IStorageDataAccessAgent>(); } string sDebug = string.Format("{0}: Module.StartOrStopAddin() -- new JobManager()", addinFriendlyName); ExternalStorePresenter.MyDumpExternalStoreOptions(sDebug, Options); JobManager = new JobManager(Options, externalStoreAgent, storageAgent, ServiceName, StorageConfigManager.GetStorageAddInsSettings()); JobManager.ExternalStoreGuid = item.ExternalStoreAddinConfig.Guid; if (IsLicenseValid()) { sDebug = string.Format("{0}: Module.StartOrStopAddin() -- JobManager.Start", addinFriendlyName); DicomUtilities.DebugString(DebugStringOptions.ShowCounter, sDebug); JobManager.Start(); } } }
public void Cancel() { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "ForwardProcess.Cancel"); // The idea here is to enable the cancel flag, and disable it after you acquire the restoreLock // You can only acquire the forwardLock after the forward process ends _cancelForward = true; lock (forwardLock) { _cancelForward = false; } }
public void Cancel() { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "ExternalStoreProcess.Cancel"); // The idea here is to enable the cancel flag, and disable it after you acuire the restoreLock // You can only acquire the restoreLock after the restore process ends _cancelRestore = true; lock (_restoreLock) { _cancelRestore = false; } }
private void SetPatientInfo(PatientInfo_Json patientInfo, DicomDataSet ds, DicomCharacterSetType characterSetType) { DicomDateValue dateValue = GetDateTimeValue(patientInfo.BirthDate); ds.InsertElementAndSetValue(DicomTag.PatientID, patientInfo.PatientId); ds.InsertElementAndSetValue(DicomTag.PatientName, patientInfo.Name); ds.InsertElementAndSetValue(DicomTag.PatientBirthDate, dateValue); ds.InsertElementAndSetValue(DicomTag.PatientSex, patientInfo.Sex); ds.InsertElementAndSetValue(DicomTag.PatientComments, patientInfo.Comments); ds.InsertElementAndSetValue(DicomTag.EthnicGroup, patientInfo.EthnicGroup); ds.InsertElementAndSetValue(DicomTag.StudyInstanceUID, DicomUtilities.GenerateDicomUniqueIdentifier()); ds.InsertElementAndSetValue(DicomTag.SeriesInstanceUID, DicomUtilities.GenerateDicomUniqueIdentifier()); ds.InsertElementAndSetValue(DicomTag.SOPInstanceUID, DicomUtilities.GenerateDicomUniqueIdentifier()); }
public void Run(IExternalStoreDataAccessAgent externalStoreAgent, DateRange range) { lock (resetLock) { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "ResetProcess.Run"); long count = externalStoreAgent.GetResetCount(range); string message = string.Format("{0} {1} found to reset external store date", count, "dataset(s)"); Logger.Global.SystemMessage(LogType.Information, message, _serviceName); if (count > 0) { externalStoreAgent.Reset(range); message = string.Format("{0} {1} external store date successfully reset", count, "dataset(s)"); Logger.Global.SystemMessage(LogType.Information, message, _serviceName); } } }
public override void Load(string serviceDirectory, string displayName) { string msg = string.Format("serviceDirectory:{0} displayName:{1}", serviceDirectory, displayName); DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "Module.Load() -- JobManager.Start" + msg); AdvancedSettings settings = AdvancedSettings.Open(serviceDirectory); _serviceDirectory = serviceDirectory; DicomServer server = ServiceLocator.Retrieve <DicomServer>(); ServiceName = server.Name; try { Type[] extraTypes = new Type[] { typeof(AzureConfiguration) }; Options = settings.GetAddInCustomData <ExternalStoreOptions>(ExternalStorePresenter._Name, "ExternalStoreOptions", extraTypes); ExternalStorePresenter.MyDumpExternalStoreOptions("Module.Load() -- settings.GetAddInCustomData()", Options); if (Options == null) { Options = new ExternalStoreOptions(); } ICrud thisCrud = Options.GetCrud(AzureGuid); if (thisCrud != null) { DataAccessServiceLocator.Register <ICrud>(thisCrud, thisCrud.ExternalStoreGuid); } } catch (Exception e) { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "*** Exception: Module.Load() settings.GetAddInCustomData" + e.Message); if (Options == null) { Options = new ExternalStoreOptions(); } Logger.Global.Error(Source, e.Message); } ExternalStore.Addin.Module.StartExternalStoreJobs(AzureExternalStoreAddinConfig, "Azure"); }
public static void StopExternalStoreJobs() { if (JobManager != null) { string sDebug = string.Format("Module.StopExternalStoreJobs -- JobManager.Stop"); DicomUtilities.DebugString(DebugStringOptions.ShowCounter, sDebug); JobManager.Stop(); } // No cloud storage Settings.RefreshSettings(); Options = Settings.GetAddInCustomData <ExternalStoreOptions>(ExternalStorePresenter._Name, "ExternalStoreOptions", null); string s = string.Format("{0}: Module.StopExternalStoreJobs()", ExternalStorePresenter._Name); ExternalStorePresenter.MyDumpExternalStoreOptions(s, Options); if (Options.ExternalStoreIndex == -1) { DataAccessServiceLocator.Register <ICrud>(new DefaultCrud()); } }
public void SaveOptions() { _View.UpdateSettings(); if (_Settings != null) { _Settings.SetAddInCustomData <ExternalStoreOptions>(_Name, "ExternalStoreOptions", _View.Options, _extraTypeList.ToArray()); try { _Settings.Save(); DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "ExternalStorePresenter::SaveOptions -- _Settings.Save()"); MyDumpExternalStoreOptions("Saved Options", _View.Options); } catch (Exception ex) { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "ExternalStorePresenter::SaveOptions -- Exception: " + ex.Message); } } _Options = Clone(_View.Options); MyDumpExternalStoreOptions("New Options", _Options); }
public void AddRequestedProcedure(string userName, string accessionNumber, WorklistRequestedProcedure procedure) { ImagingServiceRequest imgRequest = new ImagingServiceRequest() { AccessionNumber = accessionNumber }; Check.ArgumentNotNullOrEmpty(accessionNumber, "accessionNumber"); Check.ArgumentNotNullOrEmpty(procedure.RequestedProcedureID, "RequestedProceureID"); Check.ArgumentNotNullOrEmpty(procedure.RequestedProcedureDescription, "RequestedProcedureDescription"); if (string.IsNullOrEmpty(procedure.StudyInstanceUID)) { procedure.StudyInstanceUID = DicomUtilities.GenerateDicomUniqueIdentifier(); } if (procedure.RequestedProcedureCodeSequence != null) { Check.ArgumentNotNullOrEmpty(procedure.RequestedProcedureCodeSequence.CodeValue, "RequestedProcedureCodeSequence.CodeValue"); Check.ArgumentNotNullOrEmpty(procedure.RequestedProcedureCodeSequence.CodingSchemeDesignator, "RequestedProcedureCodeSequence.CodingSchemeDesignator"); } if (procedure.ReferencedStudySequence != null) { foreach (ReferencedStudySequence rs in procedure.ReferencedStudySequence) { Check.ArgumentNotNullOrEmpty(rs.ReferencedSOPClassUID, "ReferencedStudySequence.ReferencedSOPClassUID"); Check.ArgumentNotNullOrEmpty(rs.ReferencedSOPInstanceUID, "ReferencedStudySequence.ReferencedSOPInstanceUID"); } } using (MWLDataset ds = _DataAccessAgent.Find(imgRequest)) { ImagingServiceRequest isr = new ImagingServiceRequest(); imgRequest.CopyTo(isr); ds.AddRequestedProcedure(isr, procedure); _DataAccessAgent.UpdateMWL(ds); } }
public ServiceMessage Process(ServiceMessage Message) { ServiceMessage serviceMessage = null; switch (Message.Message) { //case MessageNames.IsAddinHealthy: // serviceMessage = new ServiceMessage(); // string error; // serviceMessage.Message = Message.Message; // serviceMessage.Success = CanAccessDatabase(out error); // serviceMessage.Error = error; // break; case PatientRestrictMessage.SettingsChanged: DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "Received 'PatientRestrictMessage.SettingsChanged' Message"); AdvancedSettings settings = AdvancedSettings.Open(Module.ServiceDirectory); Module.ConfigureAddin(settings); break; } return(serviceMessage); }
void View_ConfirmChanges(object sender, EventArgs e) { // Code below prevents the "configuration file has been changed by another program' exception // This happens when an addin that the server manager does not know about (i.e. Leadtools.Medical.Rules.Addin) saves its settings into 'advanced.config', which occurs in a different process // When the main process (server manager UI) saves the advanced.config without doing a RefreshSettings first, the exception occurs // // To prevent this: // Get a reference to the global copy of 'advanced.config' and refresh from disk (RefreshSettings) // All the presenters (i.e. _PatientUpdaterPresenter) have a reference to this, but it is the same reference // Now copy all settings into the reference to 'advanced.config' and save if (ServerState.Instance.ServerService != null) { AdvancedSettings settings = AdvancedSettings.Open(ServerState.Instance.ServerService.ServiceDirectory); settings.RefreshSettings(); } // These live in Leadtools.Medical.Winforms.dll __LoggingConfigPresenter.UpdateState( ); __PatientUpdaterPresenter.SaveOptions( ); __AutoCopyPresenter.SaveOptions( ); __ForwardPresenter.SaveOptions(); if (__SecurityOptionsPresenter.IsDirty) { __SecurityOptionsPresenter.SaveOptions(); } #if LEADTOOLS_V19_OR_LATER bool isStorageCommitDirty = __StorageCommitPresenter.IsDirty; if (isStorageCommitDirty) { __StorageCommitPresenter.SaveOptions(); // This fails if the service is not running // This is not a problem, because once the service starts it will read the options try { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "SendMessage(ExternalStoreMessage.SettingsChanged)"); // ServerState.Instance.ServerService.SendMessage(ExternalStoreMessage.SettingsChanged); } catch (Exception ex) { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "Exception: SendMessage(ExternalStoreMessage.SettingsChanged)" + ex.Message); } } #endif bool isSecurityOptionsDirty = __SecurityOptionsPresenter.IsDirty; if (isSecurityOptionsDirty) { __SecurityOptionsPresenter.SaveOptions(); // This fails if the service is not running // This is not a problem, because once the service starts it will read the options try { // DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "SendMessage(SecurityOptionsMessage.SettingsChanged)"); // ServerState.Instance.ServerService.SendMessage(SecurityOptionsMessage.SettingsChanged); } catch (Exception) { // DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "Exception: SendMessage(SecurityOptionsMessage.SettingsChanged)" + ex.Message); } } #if (LEADTOOLS_V19_OR_LATER_MEDICAL_EXTERNAL_STORE) || (LEADTOOLS_V19_OR_LATER) bool isExternalStoreDirty = __ExternalStorePresenter.IsDirty; DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "__ExternalStorePresenter.IsDirty : " + isExternalStoreDirty.ToString()); if (isExternalStoreDirty) { __ExternalStorePresenter.SaveOptions(); // This fails if the service is not running // This is not a problem, because once the service starts it will read the options try { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "SendMessage(ExternalStoreMessage.SettingsChanged)"); ServerState.Instance.ServerService.SendMessage(ExternalStoreMessage.SettingsChanged); } catch (Exception ex) { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "Exception: SendMessage(ExternalStoreMessage.SettingsChanged)" + ex.Message); } } #endif // #if (LEADTOOLS_V19_OR_LATER_MEDICAL_EXTERNAL_STORE) || (LEADTOOLS_V19_OR_LATER) if (__StorageClassesPresenter.IsDirty) { StorageModuleConfigurationManager configManager; configManager = ServiceLocator.Retrieve <StorageModuleConfigurationManager> ( ); __StorageClassesPresenter.UpdateSettings(); if (configManager.IsLoaded) { configManager.SetPresentationContextsTimestamp( ); } } #if (LEADTOOLS_V19_OR_LATER_EXPORT) || (LEADTOOLS_V19_OR_LATER) if (__AnonymizeOptionsPresenter.IsDirty) { StorageModuleConfigurationManager configManager = ServiceLocator.Retrieve <StorageModuleConfigurationManager> ( ); __AnonymizeOptionsPresenter.UpdateSettings(); } #endif // #if (LEADTOOLS_V19_OR_LATER_EXPORT) || (LEADTOOLS_V19_OR_LATER) if (null != __StorageSettingsPresenter) { if (__StorageSettingsPresenter.IsDirty) { __StorageSettingsPresenter.UpdateState(); __StorageSettingsPresenter.SaveSettings(); } } if (__DatabaseManagerOptionsPresenter.IsDirty) { __DatabaseManagerOptionsPresenter.SaveOptions(); DatabaseManagerOptionsAppliedEventArgs args = new DatabaseManagerOptionsAppliedEventArgs(); EventBroker.Instance.PublishEvent <DatabaseManagerOptionsAppliedEventArgs> (this, args); } #if LEADTOOLS_V20_OR_LATER if (__ClientConfigurationOptionsPresenter.IsDirty) { __ClientConfigurationOptionsPresenter.SaveOptions(); ClientConfigurationOptionsAppliedEventArgs args = new ClientConfigurationOptionsAppliedEventArgs(); EventBroker.Instance.PublishEvent <ClientConfigurationOptionsAppliedEventArgs> (this, args); } #endif // #if LEADTOOLS_V20_OR_LATER // These live in the EXE EventBroker.Instance.PublishEvent <ApplyServerSettingsEventArgs> (this, new ApplyServerSettingsEventArgs( )); EventBroker.Instance.PublishEvent <ServerSettingsAppliedEventArgs> (this, new ServerSettingsAppliedEventArgs( )); if (null != __PasswordOptionsPresenter) { __PasswordOptionsPresenter.SaveOptions(); } LocalAuditLogQueue.FlushLogs(Logger.Global, UserManager.User.Name); View.CanApply = false; }
public void RunThread(IExternalStoreDataAccessAgent externalStoreAgent, IStorageDataAccessAgent storageAgent) { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "ExternalStoreProcess.Run"); string message; ICrud crud = _Options.GetCrud(_externalStoreGuid); if (crud == null) { message = string.Format("ExternalStore ICrud interface not found:ExternalStoreGuid[{0}], FriendlyName[{1}]", _externalStoreGuid, FriendlyName); Logger.Global.SystemMessage(LogType.Error, message, _serviceName); return; } if (!DataAccessServiceLocator.IsRegistered(_externalStoreGuid)) { DataAccessServiceLocator.Register(crud, _externalStoreGuid); } lock (_externalStoreLock) { ExternalStoreInstance[] instances = externalStoreAgent.GetExternalStoreList(); if (instances.Length > 0) { message = string.Format("{0} {1} found to send to external store", instances.Length, "dataset(s)"); Logger.Global.SystemMessage(LogType.Information, message, _serviceName); } ExternalStoreItem item = _Options.GetExternalStoreItem(_externalStoreGuid); if (item == null) { return; } if (instances.Length > 0 && item.Verify) { message = string.Format("{0} {1} will be verified after sending to external store", instances.Length, instances.Length == 1 ? "instance" : "instances"); Logger.Global.SystemMessage(LogType.Information, message, _serviceName); } foreach (ExternalStoreInstance instance in instances) { if (_cancelExternalStore) { _cancelExternalStore = false; Logger.Global.SystemMessage(LogType.Information, string.Format("Cancelling External Store Process", instance.ReferencedFile), _serviceName); break; } try { if (!File.Exists(instance.ReferencedFile)) { message = string.Format("Referenced file doesn't exist. Instance ({0}) will be removed from external store queue. [{1}]", instance.SOPInstanceUID, instance.ReferencedFile); Logger.Global.SystemMessage(LogType.Warning, message, _serviceName); // TODO: fix this up -- assign a valid token externalStoreAgent.SetInstanceExternalStored(instance.SOPInstanceUID, string.Empty, string.Empty, DateTime.Now, null); continue; } string storeToken; string externalStoreGuid; if (ExternalStoreInstance(crud, instance, out storeToken, out externalStoreGuid)) { DateTime?expires = null; DateTime externalStoreDate = DateTime.Now; if (item.ImageHold != null && item.ImageHold != 0) { switch (item.HoldInterval) { case HoldInterval.Days: expires = externalStoreDate.AddDays(item.ImageHold.Value); break; case HoldInterval.Months: expires = externalStoreDate.AddMonths(item.ImageHold.Value); break; default: expires = externalStoreDate.AddYears(item.ImageHold.Value); break; } } if (!item.Verify || VerifyInstance(crud, storeToken)) { if (item.Verify) { message = string.Format("SOP instance successfully verified: {0}", instance.SOPInstanceUID); Logger.Global.SystemMessage(LogType.Information, message, _serviceName); } externalStoreAgent.SetInstanceExternalStored(instance.SOPInstanceUID, externalStoreGuid, storeToken, externalStoreDate, expires); externalStoreAgent.SetToken(instance.SOPInstanceUID, storeToken); externalStoreAgent.SetExternalStoreGuid(instance.SOPInstanceUID, externalStoreGuid); } else { message = string.Format("Failed to verify SOP instance: {0}. Instance not marked as externally stored.", instance.SOPInstanceUID); Logger.Global.SystemMessage(LogType.Error, message, _serviceName); } } } catch (Exception e) { Logger.Global.SystemMessage(LogType.Error, string.Format("{0}", e.Message), _serviceName); } } } }
public void RunThread(IExternalStoreDataAccessAgent externalStoreAgent, IStorageDataAccessAgent storageAgent, DateRange range) { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "RestoreProcess.Run"); lock (_restoreLock) { ExternalStoreInstance[] instances = externalStoreAgent.GetRestoreList(range); string message = string.Format("{0} {1} found to restore", instances.Length, "dataset(s)"); MatchingParameterCollection mpc = new MatchingParameterCollection(); Logger.Global.SystemMessage(LogType.Information, message, _serviceName); CStoreCommandConfiguration storeConfig = new CStoreCommandConfiguration(); storeConfig.DicomFileExtension = _storageAddinsConfiguration.StoreAddIn.StoreFileExtension; FillStoreCommandDefaultSettings(storeConfig, _storageAddinsConfiguration); foreach (ExternalStoreInstance instance in instances) { if (_cancelRestore) { _cancelRestore = false; Logger.Global.SystemMessage(LogType.Information, "Cancelling Restore Process", _serviceName); break; } MatchingParameterList mpl = new MatchingParameterList(); ICatalogEntity instanceEntity = RegisteredEntities.GetInstanceEntity(instance.SOPInstanceUID); mpl.Add(instanceEntity); mpc.Add(mpl); try { DataSet ds = storageAgent.QueryCompositeInstances(mpc); DataRow[] rows = ds.Tables[DataTableHelper.InstanceTableName].Select(); foreach (DataRow row in rows) { // Get the ICrud that the file was originally stored with ICrud crud = DataAccessServiceLocator.Retrieve <ICrud>(instance.ExternalStoreGuid); if (crud != null) { DicomDataSet dicomDataSet = null; Exception ex = crud.RetrieveDicom(row, DicomDataSetLoadFlags.None, out dicomDataSet); if (ex == null) { string storageLocation = CStoreCommand.GetStorageLocation(storeConfig, dicomDataSet); string dicomInstancePath = Path.Combine(storageLocation, instance.SOPInstanceUID) + "." + storeConfig.DicomFileExtension; ex = crud.RetrieveFile(row, dicomInstancePath); if (ex != null) { throw ex; } externalStoreAgent.SetReferencedFile(instance.SOPInstanceUID, dicomInstancePath); Logger.Global.SystemMessage(LogType.Information, string.Format("File Restored: {0} ", dicomInstancePath), _serviceName); } } else { Logger.Global.SystemMessage(LogType.Information, string.Format("Error: File Not Restored -- Store Token: {0}. The Addin that for ExternalStoreGuid '{1}' cannot be found.", instance.StoreToken, instance.ExternalStoreGuid), _serviceName); } } } catch (Exception e) { message = string.Format("Error ({0}) restoring instance: {1}", e.Message, instance.SOPInstanceUID); Logger.Global.SystemMessage(LogType.Error, message, _serviceName); } finally { mpc.Clear(); } } } }
public void Run(IExternalStoreDataAccessAgent externalStoreAgent, IStorageDataAccessAgent storageAgent, int expirationDays) { DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "CleanProcess.Run"); lock (cleanLock) { ExternalStoreInstance[] instances = externalStoreAgent.GetClearList(expirationDays); // StorageAddInsConfiguration storageSettings = Module.StorageConfigManager.GetStorageAddInsSettings(); if (instances.Length > 0) { string message = string.Format("{0} {1} found to clear", instances.Length, "local dataset(s)"); Logger.Global.SystemMessage(LogType.Information, message, _serviceName); DicomFileDeleter deleter = new DicomFileDeleter(); MatchingParameterCollection mpc = new MatchingParameterCollection(); deleter.DicomFileDeleted += new EventHandler <Leadtools.Medical.Winforms.EventBrokerArgs.DicomFileDeletedEventArgs>(deleter_DicomFileDeleted); deleter.DicomFileDeleteFailed += new EventHandler <Leadtools.Medical.Winforms.EventBrokerArgs.DicomFileDeletedEventArgs>(deleter_DicomFileDeleteFailed); if (_storageSettings != null) { deleter.DeleteFilesOnDatabaseDelete = _storageSettings.StoreAddIn.DeleteFiles; deleter.BackupFilesOnDatabaseDelete = _storageSettings.StoreAddIn.BackupFilesOnDelete; deleter.BackupFilesOnDeleteFolder = _storageSettings.StoreAddIn.DeleteBackupLocation; deleter.DeleteAnnotationsOnImageDelete = false; deleter.DeleteReferencedImagesOnImageDelete = false; } foreach (ExternalStoreInstance instance in instances) { MatchingParameterList mpl = new MatchingParameterList(); ICatalogEntity instanceEntity = RegisteredEntities.GetInstanceEntity(instance.SOPInstanceUID); mpl.Add(instanceEntity); mpc.Add(mpl); try { DataSet ds = storageAgent.QueryCompositeInstances(mpc); // // Find the instance to delete //// deleter.Delete(null, ds.Tables[DataTableHelper.InstanceTableName].Select()); externalStoreAgent.SetReferencedFile(instance.SOPInstanceUID, string.Empty); } catch (Exception e) { message = string.Format("Error ({0}) deleting instance: {1}", e.Message, instance.SOPInstanceUID); Logger.Global.SystemMessage(LogType.Error, message, _serviceName); } finally { mpc.Clear(); } } deleter.DicomFileDeleted -= deleter_DicomFileDeleted; deleter.DicomFileDeleteFailed -= deleter_DicomFileDeleteFailed; } } }