public void InitializeDatabase()
{
System.Configuration.Configuration configuration = DicomDemoSettingsManager.GetGlobalPacsAddinsConfiguration(Module.ServiceDirectory);
if (!DataAccessServices.IsDataAccessServiceRegistered <IAeManagementDataAccessAgent>())
{
_ConfigView = new AeManagementDataAccessConfigurationView(configuration, null, Module.ServiceName);
_aeManagementAgent = DataAccessFactory.GetInstance(_ConfigView).CreateDataAccessAgent <IAeManagementDataAccessAgent>();
DataAccessServices.RegisterDataAccessService <IAeManagementDataAccessAgent>(_aeManagementAgent);
}
else
{
_aeManagementAgent = DataAccessServices.GetDataAccessService <IAeManagementDataAccessAgent>();
}
if (!DataAccessServices.IsDataAccessServiceRegistered <IStorageDataAccessAgent>())
{
_StorageAgent = DataAccessFactory.GetInstance(new StorageDataAccessConfigurationView(configuration, null, Module.ServiceName)).CreateDataAccessAgent <IStorageDataAccessAgent>();
DataAccessServices.RegisterDataAccessService <IStorageDataAccessAgent>(_StorageAgent);
}
else
{
_StorageAgent = DataAccessServices.GetDataAccessService <IStorageDataAccessAgent>();
}
}
public static void InsertDefaultImages(string prefix, int max, Configuration configuration)
{
MedicalWorkstationConfigurationDemo.UI.MainForm.StoreClientSessionProxy proxy = null;
InstanceCStoreCommand cmd = null;
IStorageDataAccessAgent agent = DataAccessFactory.GetInstance(new StorageDataAccessConfigurationView(configuration, DicomDemoSettingsManager.ProductNameStorageServer, null)).CreateDataAccessAgent <IStorageDataAccessAgent>();
string formatString = Path.Combine(DemosGlobal.ImagesFolder, prefix);
for (int i = 1; i < max + 1; i++)
{
using (DicomDataSet ds = new DicomDataSet())
{
string fileName = string.Format(formatString, i);
if (File.Exists(fileName))
{
ds.Load(fileName, DicomDataSetLoadFlags.None);
proxy = new MedicalWorkstationConfigurationDemo.UI.MainForm.StoreClientSessionProxy();
cmd = new InstanceCStoreCommand(proxy, ds, agent);
proxy.AffectedSOPInstance = ds.GetValue <string>(DicomTag.SOPInstanceUID, string.Empty);
proxy.AbstractClass = ds.GetValue <string>(DicomTag.SOPClassUID, string.Empty);
ds.InsertElementAndSetValue(DicomTag.MediaStorageSOPInstanceUID, proxy.AffectedSOPInstance);
cmd.Execute();
ImageCountUpdate();
}
}
}
}
public static void InsertDefaultImages(string prefix, int max, int padding, Configuration configuration)
{
MedicalWorkstationConfigurationDemo.UI.MainForm.StoreClientSessionProxy proxy = null;
InstanceCStoreCommand cmd = null;
IStorageDataAccessAgent agent = DataAccessFactory.GetInstance(new StorageDataAccessConfigurationView(configuration, DicomDemoSettingsManager.ProductNameStorageServer, null)).CreateDataAccessAgent <IStorageDataAccessAgent>();
string formatString = BuildDefaultImageFormatString(padding);
for (int i = 1; i < max + 1; i++)
{
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format(formatString, prefix, i)))
{
using (DicomDataSet ds = new DicomDataSet())
{
ds.Load(stream, DicomDataSetLoadFlags.None);
proxy = new MedicalWorkstationConfigurationDemo.UI.MainForm.StoreClientSessionProxy();
cmd = new InstanceCStoreCommand(proxy, ds, agent);
proxy.AffectedSOPInstance = ds.GetValue <string>(DicomTag.SOPInstanceUID, string.Empty);
proxy.AbstractClass = ds.GetValue <string>(DicomTag.SOPClassUID, string.Empty);
ds.InsertElementAndSetValue(DicomTag.MediaStorageSOPInstanceUID, proxy.AffectedSOPInstance);
cmd.Execute();
ImageCountUpdate();
}
}
}
}
public JobManager(ForwardOptions options, IForwardDataAccessAgent fagent, IAeManagementDataAccessAgent aagent, IStorageDataAccessAgent sagent)
{
_Options = options;
_forwardAgent = fagent;
_aeAgent = aagent;
_storageAgent = sagent;
}
public RemoveDicomBackgroundWorker(IStorageDataAccessAgent dataAccessAgent)
{
base.WorkerReportsProgress = true;
base.WorkerSupportsCancellation = true;
_dataAccessAgent = dataAccessAgent;
}
private static bool CanAccessDatabase(out string errorString)
{
bool result = true;
errorString = string.Empty;
IStorageDataAccessAgent agent = null;
if (DataAccessServices.IsDataAccessServiceRegistered <IStorageDataAccessAgent>())
{
agent = DataAccessServices.GetDataAccessService <IStorageDataAccessAgent>();
}
if (agent == null)
{
errorString = "Error: Cannot create IStorageDataAccessAgent";
return(false);
}
agent.MaxQueryResults = 10;
try
{
agent.IsPatientsExists("patientIdNotUsed");
}
catch (Exception ex)
{
errorString = ex.Message;
result = false;
}
return(result);
}
public EmptyDatabaseBackgroundWorker(IStorageDataAccessAgent dataAccessAgent)
{
base.WorkerReportsProgress = false;
base.WorkerSupportsCancellation = false;
_dataAccessAgent = dataAccessAgent;
}
public ExportDicomBackgroundWorker(IStorageDataAccessAgent dataAccessAgent)
{
WorkerReportsProgress = true;
WorkerSupportsCancellation = true;
_dataAccessAgent = dataAccessAgent;
}
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;
}
static void RegisterDataAccessAgents(string serviceName)
{
System.Configuration.Configuration configuration = DicomDemoSettingsManager.GetGlobalPacsAddinsConfiguration(ServiceDirectory);
if (!DataAccessServices.IsDataAccessServiceRegistered <IStorageDataAccessAgent> ( ))
{
IStorageDataAccessAgent storageDataAccess = DataAccessFactory.GetInstance(new StorageDataAccessConfigurationView(configuration, null, serviceName)).CreateDataAccessAgent <IStorageDataAccessAgent> ( );
DataAccessServices.RegisterDataAccessService <IStorageDataAccessAgent> (storageDataAccess);
DataAccess = storageDataAccess;
}
else
{
DataAccess = DataAccessServices.GetDataAccessService <IStorageDataAccessAgent>();
}
if (!DataAccessServices.IsDataAccessServiceRegistered <IPermissionManagementDataAccessAgent> ( ))
{
try
{
IPermissionManagementDataAccessAgent permissionsDataAccess = DataAccessFactory.GetInstance(new AePermissionManagementDataAccessConfigurationView(configuration, null, serviceName)).CreateDataAccessAgent <IPermissionManagementDataAccessAgent>();
DataAccessServices.RegisterDataAccessService <IPermissionManagementDataAccessAgent>(permissionsDataAccess);
PermissionsAgent = permissionsDataAccess;
}
catch (Exception)
{
}
}
else
{
PermissionsAgent = DataAccessServices.GetDataAccessService <IPermissionManagementDataAccessAgent>();
}
if (!DataAccessServices.IsDataAccessServiceRegistered <IOptionsDataAccessAgent> ( ))
{
try
{
IOptionsDataAccessAgent optionsDataAccess = DataAccessFactory.GetInstance(new OptionsDataAccessConfigurationView(configuration, null, serviceName)).CreateDataAccessAgent <IOptionsDataAccessAgent>();
DataAccessServices.RegisterDataAccessService <IOptionsDataAccessAgent>(optionsDataAccess);
}
catch (Exception)
{
}
}
//TODO: Check if workstastion data access is registered if not then check if config information
//is available. create only if config options available otherwise don't.
//the database manager will use the ws dataAccess only if registered.
//if ( !DataAccessServices.IsDataAccessServiceRegistered <IWorkstationDataAccess> ( ) )
//{
// IOptionsDataAccessAgent optionsDataAccess = DataAccessFactory.GetInstance ( new OptionsDataAccessConfigurationView (configuration, null, serviceName) ).CreateDataAccessAgent <IOptionsDataAccessAgent> ( ) ;
// DataAccessServices.RegisterDataAccessService <IOptionsDataAccessAgent> ( optionsDataAccess ) ;
//}
}
public AddDicomBackgroundWorker(string AETitle, IStorageDataAccessAgent dataAccess, string implementationClassUID)
{
base.WorkerReportsProgress = true;
base.WorkerSupportsCancellation = true;
_AETitle = AETitle;
_DataAccess = dataAccess;
_ImplementationClassUID = implementationClassUID;
}
public bool CanAccessDatabase(out string error)
{
error = string.Empty;
bool ret = false;
try
{
System.Configuration.Configuration configuration = DicomDemoSettingsManager.GetGlobalPacsAddinsConfiguration(Module.ServiceDirectory);
IStorageDataAccessAgent storageAgent = GetAgent <IStorageDataAccessAgent>(configuration, new StorageDataAccessConfigurationView(configuration, null, Module.ServiceName));
IAeManagementDataAccessAgent aeManagementAgent = GetAgent <IAeManagementDataAccessAgent>(configuration, new AeManagementDataAccessConfigurationView(configuration, null, Module.ServiceName));
IOptionsDataAccessAgent optionsAgent = GetAgent <IOptionsDataAccessAgent>(configuration, new OptionsDataAccessConfigurationView(configuration, null, Module.ServiceName));
bool bContinue = true;
if (aeManagementAgent == null)
{
error = string.Format("{0} {1}", AssemblyName, "Cannot create IAeManagementDataAccessAgent");
bContinue = false;
}
if (bContinue)
{
if (storageAgent == null)
{
error = string.Format("{0} {1}", AssemblyName, "Cannot create IStorageDataAccessAgent");
bContinue = false;
}
}
if (bContinue)
{
if (optionsAgent == null)
{
error = string.Format("{0} {1}", AssemblyName, "Cannot create IOptionsDataAccessAgent");
bContinue = false;
}
}
if (bContinue)
{
storageAgent.MaxQueryResults = 10;
storageAgent.IsPatientsExists("patientIdNotUsed");
aeManagementAgent.GetAeTitle("notUsed");
optionsAgent.GetDefaultOptions();
}
}
catch (Exception e)
{
error = string.Format("{0} {1}", AssemblyName, e.Message);
}
ret = string.IsNullOrEmpty(error);
return(ret);
}
private void textBoxTotalImages_DoubleClick(object sender, EventArgs e)
{
IStorageDataAccessAgent db = GetDataAccessAgent();
if (db != null)
{
_imageCount = db.FindCompositeInstancesCount(_mpc);
textBoxTotalImages.Text = _imageCount.ToString();
}
}
private void textBoxTotalSeries_DoubleClick(object sender, EventArgs e)
{
IStorageDataAccessAgent db = GetDataAccessAgent();
if (db != null)
{
_seriesCount = db.FindSeriesCount(_mpc);
textBoxTotalSeries.Text = _seriesCount.ToString();
}
}
public MediaComposer
(
MediaCreationManagement mediaObject,
IStorageDataAccessAgent storageService
)
{
MediaObject = mediaObject;
StorageService = storageService;
ProfileProcessors = new List <IDicomMediaProfileProcessor> ( );
}
private void backgroundworker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
int nPercentComplete = 0;
backgroundWorker.ReportProgress(nPercentComplete);
IStorageDataAccessAgent db = GetDataAccessAgent();
if (db == null)
{
e.Result = 0.0;
backgroundWorker.ReportProgress(100);
return;
}
// This takes a long time
DataSet compositeInstance = db.QueryCompositeInstances(_mpc);;
long totalBytes = 0;
int count = compositeInstance.Tables[DataTableHelper.InstanceTableName].Rows.Count;
int i = 0;
while (!backgroundWorker.CancellationPending && i < count)
{
string sFile = RegisteredDataRows.InstanceInfo.ReferencedFile(compositeInstance.Tables[DataTableHelper.InstanceTableName].Rows[0]);
FileInfo fi = new FileInfo(sFile);
if (fi.Exists)
{
totalBytes += fi.Length;
nPercentComplete = 100 * (i + 1) / count;
}
backgroundWorker.ReportProgress(nPercentComplete);
i++;
}
if (backgroundWorker.CancellationPending)
{
e.Cancel = true;
}
else
{
double dTotalMBytes = ((double)totalBytes / (1024.0 * 1024.0));
e.Result = dTotalMBytes;
backgroundWorker.ReportProgress(100);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void Initialize()
{
if (treeViewSqlServerInformation != null && treeViewSqlServerInformation.Nodes != null)
{
treeViewSqlServerInformation.Nodes.Clear();
}
_ciStorage = null;
// Sql Server Information
foreach (KeyValuePair <string, string> kvp in this.SqlDatabaseList)
{
ConnectionInformation ci = GetInfo(kvp.Key, kvp.Value);
UpdateDatabaseDetails(ci);
if (ci.FriendlyName == StorageDatabaseName)
{
_ciStorage = ci;
}
}
// Patient, study, series, image count
if (_ciStorage != null)
{
IStorageDataAccessAgent db = GetDataAccessAgent();
textBoxTotalPatients.Text = "0";
textBoxTotalStudies.Text = "0";
textBoxTotalSeries.Text = "0";
textBoxTotalImages.Text = "0";
double dTotalMBytes = 0;
try
{
_patientCount = db.FindPatientsCount(_mpc);
_studiesCount = db.FindStudiesCount(_mpc);
_seriesCount = db.FindSeriesCount(_mpc);
_imageCount = db.FindCompositeInstancesCount(_mpc);
// RecalculateTotalDataStored();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
textBoxTotalPatients.Text = _patientCount.ToString();
textBoxTotalStudies.Text = _studiesCount.ToString();
textBoxTotalSeries.Text = _seriesCount.ToString();
textBoxTotalImages.Text = _imageCount.ToString();
textBoxTotalDataStored.Text = string.Format("{0:F1} MB", dTotalMBytes);
}
}
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);
}
private void ConfigureDataAccessLayers( )
{
IStorageDataAccessAgent storageDataAccess = DataAccessServices.GetDataAccessService <IStorageDataAccessAgent> ( );
if (storageDataAccess != null && storageDataAccess is StorageDbDataAccessAgent)
{
StorageModuleConfigurationManager storageConfig = ServiceLocator.Retrieve <StorageModuleConfigurationManager> ( );
if (storageConfig.IsLoaded)
{
((StorageDbDataAccessAgent)storageDataAccess).AutoTruncateData = storageConfig.GetStorageAddInsSettings(ServerState.Instance.ServiceName).StoreAddIn.AutoTruncateData;
}
}
}
private IStorageDataAccessAgent GetDataAccessAgent()
{
if (_ciStorage == null)
{
return(null);
}
IStorageDataAccessAgent db = null;
if (!DataAccessServices.IsDataAccessServiceRegistered <IStorageDataAccessAgent>())
{
throw new InvalidOperationException(typeof(IStorageDataAccessAgent).Name + " is not registered.");
}
db = DataAccessServices.GetDataAccessService <IStorageDataAccessAgent>();
return(db);
}
public bool CanAccessDatabase2(out string error)
{
error = string.Empty;
bool ret = false;
try
{
System.Configuration.Configuration configuration = DicomDemoSettingsManager.GetGlobalPacsAddinsConfiguration(AddInsSession.ServiceDirectory);
IExternalStoreDataAccessAgent externalStoreAgent = GetAgent <IExternalStoreDataAccessAgent>(configuration, new ExternalStoreDataAccessConfigurationView(configuration, null, AddInsSession.DisplayName));
IStorageDataAccessAgent storageAgent = GetAgent <IStorageDataAccessAgent>(configuration, new StorageDataAccessConfigurationView(configuration, null, AddInsSession.DisplayName));
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 static void AddDefaultImages(Configuration configGlobalPacs)
{
ImageCountReset();
MainForm.StoreClientSessionProxy proxy = null;
InstanceCStoreCommand cmd = null;
IStorageDataAccessAgent agent = DataAccessFactory.GetInstance(new StorageDataAccessConfigurationView(configGlobalPacs, DicomDemoSettingsManager.ProductNameStorageServer, null)).CreateDataAccessAgent <IStorageDataAccessAgent>();
for (int i = 1; i < ImageCountResources + 1; i++)
{
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format("CSPacsDatabaseConfigurationDemo.Resources.{0}.dcm", i)))
{
using (DicomDataSet ds = new DicomDataSet())
{
ds.Load(stream, DicomDataSetLoadFlags.None);
proxy = new MainForm.StoreClientSessionProxy();
cmd = new InstanceCStoreCommand(proxy, ds, agent);
proxy.AffectedSOPInstance = ds.GetValue <string>(DicomTag.SOPInstanceUID, string.Empty);
proxy.AbstractClass = ds.GetValue <string>(DicomTag.SOPClassUID, string.Empty);
ds.InsertElementAndSetValue(DicomTag.MediaStorageSOPInstanceUID, proxy.AffectedSOPInstance);
cmd.Execute();
ImageCountUpdate();
}
}
}
#if (LEADTOOLS_V19_OR_LATER)
InsertDefaultImages("mg", ImageCountMG, configGlobalPacs);
InsertDefaultImages("cr", ImageCountCR, configGlobalPacs);
InsertDefaultImages("FMX18.de", ImageCountFMX, 2, configGlobalPacs);
#endif
#if (LEADTOOLS_V20_OR_LATER)
InsertDefaultImages("MRI.mri_", ImageCountMRI, 2, configGlobalPacs);
#endif
}
static void RegisterDataAccessAgents(string serviceDirectory, string serviceName)
{
System.Configuration.Configuration configuration = DicomDemoSettingsManager.GetGlobalPacsAddinsConfiguration(serviceDirectory);
if (!DataAccessServices.IsDataAccessServiceRegistered <IStorageDataAccessAgent> ( ))
{
IStorageDataAccessAgent storageDataAccess = DataAccessFactory.GetInstance(new StorageDataAccessConfigurationView(configuration, null, serviceName)).CreateDataAccessAgent <IStorageDataAccessAgent> ( );
DataAccessServices.RegisterDataAccessService <IStorageDataAccessAgent> (storageDataAccess);
}
if (!DataAccessServices.IsDataAccessServiceRegistered <IPatientRightsDataAccessAgent> ( ))
{
try
{
IPatientRightsDataAccessAgent patientRightsDataAccess = DataAccessFactory.GetInstance(new PatientRightsDataAccessConfigurationView(configuration, null, serviceName)).CreateDataAccessAgent <IPatientRightsDataAccessAgent>();
DataAccessServices.RegisterDataAccessService <IPatientRightsDataAccessAgent>(patientRightsDataAccess);
}
catch (Exception)
{
//Log
}
}
if (!DataAccessServices.IsDataAccessServiceRegistered <IDownloadJobsDataAccessAgent> ( ))
{
try
{
IDownloadJobsDataAccessAgent downloadDataAccess = DataAccessFactory.GetInstance(new DownloadJobsDataAccessConfigurationView(configuration, null, serviceName)).CreateDataAccessAgent <IDownloadJobsDataAccessAgent>();
DataAccessServices.RegisterDataAccessService <IDownloadJobsDataAccessAgent>(downloadDataAccess);
}
catch (Exception)
{
}
}
}
private void InitializeStorageAddinsSettings()
{
IStorageDataAccessAgent storageDataAccess = DataAccessServices.GetDataAccessService <IStorageDataAccessAgent>();
if (storageDataAccess != null && storageDataAccess is StorageDbDataAccessAgent)
{
StorageModuleConfigurationManager storageConfig = ServiceLocator.Retrieve <StorageModuleConfigurationManager>();
if (storageConfig.IsLoaded)
{
StorageAddInsConfiguration settings = storageConfig.GetStorageAddInsSettings(ServerState.Instance.ServiceName);
if (settings != null)
{
if (settings.StoreAddIn.AutoCreateFolderLocations != AutoCreateLocationsDefault)
{
settings.StoreAddIn.AutoCreateFolderLocations = AutoCreateLocationsDefault;
storageConfig.SetStorageAddinsSettings(settings);
storageConfig.Save();
}
}
}
}
}
private static DicomDataSet GetFirstReferencedInstanceDataSet
(
IStorageDataAccessAgent dataAccess,
MediaCreationManagement mediaObject)
{
MatchingParameterCollection matchingCollection;
MatchingParameterList matchingList;
CompositeInstanceDataSet compositeInstance;
matchingCollection = new MatchingParameterCollection( );
matchingList = new MatchingParameterList( );
// Instance instance = new Instance ( mediaObject.ReferencedSopSequence [ 0 ].SopInstance.ReferencedSopInstanceUid ) ;
ICatalogEntity instance = RegisteredEntities.GetInstanceEntity(mediaObject.ReferencedSopSequence [0].SopInstance.ReferencedSopInstanceUid);
matchingCollection.Add(matchingList);
matchingList.Add(instance);
compositeInstance = dataAccess.QueryCompositeInstances(matchingCollection).ToCompositeInstanceDataSet();
if (compositeInstance.Instance.Count > 0)
{
DicomDataSet ds;
ds = new DicomDataSet( );
ds.Load(compositeInstance.Instance [0].ReferencedFile, DicomDataSetLoadFlags.None);
return(ds);
}
else
{
return(null);
}
}
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(IForwardDataAccessAgent forwardAgent, IStorageDataAccessAgent storageAgent)
{
lock (cleanLock)
{
ForwardInstance[] instances = forwardAgent.GetCleanList();
StorageAddInsConfiguration storageSettings = Module.StorageConfigManager.GetStorageAddInsSettings();
string message = string.Format("[Forwarder] {0} {1} found to clean", instances.Length, instances.Length == 1 ? "dataset" : "datasets");
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;
}
Logger.Global.SystemMessage(LogType.Debug, message, _ServerAE);
foreach (ForwardInstance instance in instances)
{
#if LEADTOOLS_V18_OR_LATER
if (_cancelClean)
{
_cancelClean = false;
Logger.Global.SystemMessage(LogType.Information, string.Format("Cancelling Clean Process"), _ServerAE);
break;
}
#endif // #if LEADTOOLS_V18_OR_LATER
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
//
storageAgent.DeleteInstance(GetMatchingParameters(instance.SOPInstanceUID));
if (ds != null)
{
deleter.Delete(null, ds.Tables[DataTableHelper.InstanceTableName].Select());
}
}
catch (Exception e)
{
message = string.Format("[Forwarder] Error ({0}) deleting instance: {1}", e.Message, instance.SOPInstanceUID);
Logger.Global.SystemMessage(LogType.Error, message, _ServerAE);
}
finally
{
mpc.Clear();
}
}
deleter.DicomFileDeleted -= deleter_DicomFileDeleted;
deleter.DicomFileDeleteFailed -= deleter_DicomFileDeleteFailed;
}
}
public void Run(IForwardDataAccessAgent forwardAgent, IStorageDataAccessAgent storageAgent)
{
Thread thread = new Thread(() => RunThread(forwardAgent, storageAgent));
thread.Start();
}
