public DicomInstanceRetrieveExternalStoreCommand(IStorageDataAccessAgent storeAgent, IExternalStoreDataAccessAgent externalStoreAgent, string serviceDirectory, bool cacheLocal)
{
StoreAgent = storeAgent;
ExternalStoreAgent = externalStoreAgent;
Flags = DicomDataSetLoadFlags.None;
ServiceDirectory = serviceDirectory;
CacheLocal = cacheLocal;
}
public JobManager(ExternalStoreOptions options, IExternalStoreDataAccessAgent externalStoreAgent, IStorageDataAccessAgent storeAgent, string serviceName, StorageAddInsConfiguration storageSettings)
{
_Options = options;
_externalStoreAgent = externalStoreAgent;
_storageAgent = storeAgent;
_serviceName = serviceName;
_storageSettings = storageSettings;
}
internal static string FindReferencedFile(
#if LEADTOOLS_V19_OR_LATER
IExternalStoreDataAccessAgent externalStoreAgent,
#endif // #if LEADTOOLS_V19_OR_LATER
string sopInstanceUID)
{
MatchingParameterCollection mpc = new MatchingParameterCollection();
MatchingParameterList mpl = new MatchingParameterList();
DataSet /*CompositeInstanceDataSet*/ instanceData;
IStorageDataAccessAgent agent = null;
string referencedFile = string.Empty;
if (DataAccessServices.IsDataAccessServiceRegistered <IStorageDataAccessAgent>())
{
agent = DataAccessServices.GetDataAccessService <IStorageDataAccessAgent>();
}
if (agent != null)
{
ICatalogEntity instanceEntity = RegisteredEntities.GetInstanceEntity(sopInstanceUID);
mpl.Add(instanceEntity);
mpc.Add(mpl);
instanceData = agent.QueryCompositeInstances(mpc);
if (instanceData.Tables[DataTableHelper.InstanceTableName].Rows.Count == 1)
{
DataRow row = instanceData.Tables[DataTableHelper.InstanceTableName].Rows[0];
referencedFile = RegisteredDataRows.InstanceInfo.ReferencedFile(row);
#if (LEADTOOLS_V19_OR_LATER_MEDICAL_EXTERNAL_STORE) || (LEADTOOLS_V19_OR_LATER)
if (string.IsNullOrEmpty(referencedFile))
{
// If empty, it might be on the cloud
// Use DicomInstanceRetrieveExternalStoreCommand with cache set to true to copy it locally
if (externalStoreAgent == null)
{
if (DataAccessServices.IsDataAccessServiceRegistered <IExternalStoreDataAccessAgent>())
{
externalStoreAgent = DataAccessServices.GetDataAccessService <IExternalStoreDataAccessAgent>();
}
}
DicomInstanceRetrieveExternalStoreCommand c = new DicomInstanceRetrieveExternalStoreCommand(agent, externalStoreAgent, AddInsSession.ServiceDirectory, true);
DicomDataSet ds = c.GetDicomDataSet(row, out referencedFile);
}
#endif // (LEADTOOLS_V19_OR_LATER_MEDICAL_EXTERNAL_STORE) || (LEADTOOLS_V19_OR_LATER)
}
}
return(referencedFile);
}
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 bool CanAccessDatabase(out string error)
{
error = string.Empty;
bool ret = false;
try
{
System.Configuration.Configuration configuration = DicomDemoSettingsManager.GetGlobalPacsAddinsConfiguration(Module.ServiceDirectory);
IExternalStoreDataAccessAgent externalStoreAgent = GetAgent <IExternalStoreDataAccessAgent>(configuration, new ExternalStoreDataAccessConfigurationView(configuration, null, Module.ServiceName));
IStorageDataAccessAgent storageAgent = GetAgent <IStorageDataAccessAgent>(configuration, new StorageDataAccessConfigurationView(configuration, null, Module.ServiceName));
bool bContinue = true;
if (externalStoreAgent == null)
{
error = string.Format("{0} {1}", AssemblyName, "Cannot create IExternalStoreDataAccessAgent");
bContinue = false;
}
if (bContinue)
{
if (storageAgent == null)
{
error = string.Format("{0} {1}", AssemblyName, "Cannot create IStorageDataAccessAgent");
bContinue = false;
}
}
if (bContinue)
{
externalStoreAgent.IsExternalStored("notUsed");
storageAgent.MaxQueryResults = 10;
storageAgent.IsPatientsExists("patientIdNotUsed");
}
}
catch (Exception e)
{
error = string.Format("{0} {1}", AssemblyName, e.Message);
}
ret = string.IsNullOrEmpty(error);
return(ret);
}
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, DateRange range)
{
Thread thread = new Thread(() => RunThread(externalStoreAgent, storageAgent, range));
thread.Start();
}
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 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;
}
}
}
