public StudyDeleteRecord(
      String _studyInstanceUid_
     ,DateTime _timestamp_
     ,String _serverPartitionAE_
     ,ServerEntityKey _filesystemKey_
     ,String _backupPath_
     ,String _reason_
     ,String _accessionNumber_
     ,String _patientId_
     ,String _patientsName_
     ,String _studyId_
     ,String _studyDescription_
     ,String _studyDate_
     ,String _studyTime_
     ,XmlDocument _archiveInfo_
     ,String _extendedInfo_
     ):base("StudyDeleteRecord")
 {
     StudyInstanceUid = _studyInstanceUid_;
     Timestamp = _timestamp_;
     ServerPartitionAE = _serverPartitionAE_;
     FilesystemKey = _filesystemKey_;
     BackupPath = _backupPath_;
     Reason = _reason_;
     AccessionNumber = _accessionNumber_;
     PatientId = _patientId_;
     PatientsName = _patientsName_;
     StudyId = _studyId_;
     StudyDescription = _studyDescription_;
     StudyDate = _studyDate_;
     StudyTime = _studyTime_;
     ArchiveInfo = _archiveInfo_;
     ExtendedInfo = _extendedInfo_;
 }

 static public FilesystemStudyStorage Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

 static public StudyIntegrityQueueUid Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

 static public ProcedureCode Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

 static public RequestAttributes Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

 static public RequestAttributes Load(ServerEntityKey key)
 {
     using (var read = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
     {
         return Load(read, key);
     }
 }

 static public DatabaseVersion Load(ServerEntityKey key)
 {
     using (var read = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
     {
         return Load(read, key);
     }
 }

 static public PartitionTransferSyntax Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

 static public ServerSopClass Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

 public Device(
      Boolean _dhcp_
     ,Boolean _enabled_
     ,Boolean _allowStorage_
     ,Boolean _acceptKOPR_
     ,Boolean _allowRetrieve_
     ,Boolean _allowQuery_
     ,Boolean _allowAutoRoute_
     ,Int16 _throttleMaxConnections_
     ,DateTime _lastAccessedTime_
     ,DeviceTypeEnum _deviceTypeEnum_
     ,ServerEntityKey _serverPartitionKey_
     ,String _aeTitle_
     ,Int32 _port_
     ,String _description_
     ,String _ipAddress_
     ):base("Device")
 {
     Dhcp = _dhcp_;
     Enabled = _enabled_;
     AllowStorage = _allowStorage_;
     AcceptKOPR = _acceptKOPR_;
     AllowRetrieve = _allowRetrieve_;
     AllowQuery = _allowQuery_;
     AllowAutoRoute = _allowAutoRoute_;
     ThrottleMaxConnections = _throttleMaxConnections_;
     LastAccessedTime = _lastAccessedTime_;
     DeviceTypeEnum = _deviceTypeEnum_;
     ServerPartitionKey = _serverPartitionKey_;
     AeTitle = _aeTitle_;
     Port = _port_;
     Description = _description_;
     IpAddress = _ipAddress_;
 }

 static public ArchiveQueue Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

		public LockStudyCommand(ServerEntityKey studyStorageKey, bool writeLock, bool readLock)
			: base("LockStudy")
		{
			_studyStorageKey = studyStorageKey;
			_readLock = readLock;
			_writeLock = writeLock;
		}

 static public StudyIntegrityQueueUid Load(ServerEntityKey key)
 {
     using (var read = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
     {
         return Load(read, key);
     }
 }

 static public FilesystemQueue Load(ServerEntityKey key)
 {
     using (var read = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
     {
         return Load(read, key);
     }
 }

 static public ArchiveStudyStorage Load(ServerEntityKey key)
 {
     using (var read = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
     {
         return Load(read, key);
     }
 }

 static public DataAccessGroup Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

 static public ServerTransferSyntax Load(ServerEntityKey key)
 {
     using (var read = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
     {
         return Load(read, key);
     }
 }

 static public StudyHistory Load(ServerEntityKey key)
 {
     using (var context = new ServerExecutionContext())
     {
         return Load(context.ReadContext, key);
     }
 }

        /// <summary>
        /// Inserts a move request to move one or more series in a study.
        /// </summary>
        /// <param name="context">The persistence context used for database connection.</param>
        /// <param name="partition">The <see cref="ServerPartition"/> where the study resides</param>
        /// <param name="studyInstanceUid">The Study Instance Uid of the study</param>
        /// <param name="deviceKey">The Key of the device to move the series to.</param> 
        /// <param name="seriesInstanceUids">The Series Instance Uid of the series to be move.</param>
        /// <param name="externalRequest">Optional <see cref="ExternalRequestQueue"/> entry that triggered this move</param>
        /// <returns>A MoveSeries <see cref="WorkQueue"/> entry inserted into the system.</returns>
        /// <exception cref="InvalidStudyStateOperationException"></exception>
        public static IList<WorkQueue> MoveSeries(IUpdateContext context, ServerPartition partition, string studyInstanceUid, ServerEntityKey deviceKey, List<string> seriesInstanceUids, ExternalRequestQueue externalRequest=null)
        {
            // Find all location of the study in the system and insert series delete request
			IList<StudyStorageLocation> storageLocations = StudyStorageLocation.FindStorageLocations(partition.Key, studyInstanceUid);
			IList<WorkQueue> entries = new List<WorkQueue>();

            foreach (StudyStorageLocation location in storageLocations)
            {
                try
                {
                    // insert a move series request
                    WorkQueue request = InsertMoveSeriesRequest(context, location, seriesInstanceUids, deviceKey, externalRequest);
                    Debug.Assert(request.WorkQueueTypeEnum.Equals(WorkQueueTypeEnum.WebMoveStudy));
                    entries.Add(request);
                }
                catch (Exception ex)
                {
                    Platform.Log(LogLevel.Error, ex, "Errors occurred when trying to insert move request");
                    if (!ServerHelper.UnlockStudy(location.Key))
                        throw new ApplicationException("Unable to unlock the study");
                }
            }

            return entries;
        }

 static public PartitionSopClass Load(ServerEntityKey key)
 {
     using (var read = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
     {
         return Load(read, key);
     }
 }