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;
}
}
}
