/// <summary> /// Claims the thread specified for the user specified. As the thread can be in one queue at a time, it simply has to update the SupportQueueThread entity. /// </summary> /// <param name="userID">The user ID.</param> /// <param name="threadID">The thread ID.</param> public static void ClaimThread(int userID, int threadID) { SupportQueueThreadEntity supportQueueThread = new SupportQueueThreadEntity(); supportQueueThread.FetchUsingUCThreadID(threadID); if(supportQueueThread.IsNew) { // not found, return return; } // simply overwrite an existing claim if any. supportQueueThread.ClaimedByUserID = userID; supportQueueThread.ClaimedOn = DateTime.Now; // done, save it supportQueueThread.Save(); }
/// <summary> /// Gets the support queue thread info entity and if specified, prefetches the user entity which claimed the related thread. /// </summary> /// <param name="threadID">The thread ID.</param> /// <param name="prefetchClaimUser">if set to true it will </param> /// <returns>fetched entity if found, otherwise null</returns> public static SupportQueueThreadEntity GetSupportQueueThreadInfo(int threadID, bool prefetchClaimUser) { SupportQueueThreadEntity toReturn = new SupportQueueThreadEntity(); PrefetchPath path = null; if(prefetchClaimUser) { // prefetch the user who claimed this thread (if any) path = new PrefetchPath((int)EntityType.SupportQueueThreadEntity); path.Add(SupportQueueThreadEntity.PrefetchPathClaimedByUser); } // now fetch the entity using the unique constraint on Thread by specifying the threadID passed in. Also specify the prefetch path (if any) toReturn.FetchUsingUCThreadID(threadID, path); if(toReturn.IsNew) { // not found return null; } return toReturn; }
/// <summary> /// Releases the claim on the thread specified. As the thread can be in one queue at a time, it simply has to update the SupportQueueThread entity. /// </summary> /// <param name="threadID">The thread ID.</param> public static void ReleaseClaimOnThread(int threadID) { SupportQueueThreadEntity supportQueueThread = new SupportQueueThreadEntity(); supportQueueThread.FetchUsingUCThreadID(threadID); if(supportQueueThread.IsNew) { // not found, return return; } // simply reset an existing claim supportQueueThread.ClaimedByUserID = null; // nullable type, so set to null. supportQueueThread.ClaimedOn = null; // nullable type, so set to null. // done, save it supportQueueThread.Save(); }
/// <summary> Retrieves the related entity of type 'SupportQueueThreadEntity', using a relation of type '1:1'</summary> /// <param name="forceFetch">if true, it will discard any changes currently in the currently loaded related entity and will refetch the entity from the persistent storage</param> /// <returns>A fetched entity of type 'SupportQueueThreadEntity' which is related to this entity.</returns> public virtual SupportQueueThreadEntity GetSingleSupportQueueThread(bool forceFetch) { if( ( !_alreadyFetchedSupportQueueThread || forceFetch || _alwaysFetchSupportQueueThread) && !this.IsSerializing && !this.IsDeserializing && !this.InDesignMode ) { bool performLazyLoading = this.CheckIfLazyLoadingShouldOccur(Relations.SupportQueueThreadEntityUsingThreadID); SupportQueueThreadEntity newEntity = new SupportQueueThreadEntity(); bool fetchResult = false; if(performLazyLoading) { AddToTransactionIfNecessary(newEntity); fetchResult = newEntity.FetchUsingUCThreadID(this.ThreadID); } if(fetchResult) { newEntity = (SupportQueueThreadEntity)GetFromActiveContext(newEntity); } else { if(!_supportQueueThreadReturnsNewIfNotFound) { RemoveFromTransactionIfNecessary(newEntity); newEntity = null; } } this.SupportQueueThread = newEntity; _alreadyFetchedSupportQueueThread = fetchResult; } return _supportQueueThread; }