/// <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> /// Adds the thread with the ID specified to the support queue with the ID specified /// </summary> /// <param name="threadID">The thread ID.</param> /// <param name="queueID">The queue ID.</param> /// <param name="userID">The user ID of the user causing this thread to be placed in the queue specified.</param> /// <param name="transactionToUse">The transaction to use. Is not null if there's a transaction in progress.</param> /// <remarks>first removes the thread from a queue if it's in a queue</remarks> public static void AddThreadToQueue(int threadID, int queueID, int userID, Transaction transactionToUse) { // first remove the thread from any queue it's in. RemoveThreadFromQueue(threadID, transactionToUse); // then add it to the queue specified. SupportQueueThreadEntity supportQueueThread = new SupportQueueThreadEntity(); supportQueueThread.ThreadID = threadID; supportQueueThread.QueueID = queueID; supportQueueThread.PlacedInQueueByUserID = userID; supportQueueThread.PlacedInQueueOn = DateTime.Now; if(transactionToUse != null) { // transaction in progress, add the entity to the transaction transactionToUse.Add(supportQueueThread); } supportQueueThread.Save(); }
/// <summary> /// Deletes the user with the ID passed in. Will reset all posts made by the user to the userid 0. /// </summary> /// <param name="userID">The user ID.</param> /// <remarks>Can't delete user 0</remarks> /// <returns>true if succeeded, false otherwise</returns> public static bool DeleteUser(int userID) { if(userID == 0) { // can't delete the Anonymous coward user. return false; } UserEntity toDelete = UserGuiHelper.GetUser(userID); if(toDelete==null) { // user doesn't exist return false; } // all actions have to take place in a transaction. Transaction trans = new Transaction(IsolationLevel.ReadCommitted, "DeleteUser"); try { // we'll first update all PostedByUserId fields of all messages which are posted by the user to delete. MessageEntity messageUpdater = new MessageEntity(); messageUpdater.PostedByUserID = 0; // reset to AC. MessageCollection messages = new MessageCollection(); trans.Add(messages); // add to the transaction // update all entities directly in the DB, which match the following filter and update them with the new values set in messageUpdater. messages.UpdateMulti(messageUpdater, (MessageFields.PostedByUserID == userID)); // set the startuser of threads started by this user to 0 ThreadEntity threadUpdater = new ThreadEntity(); threadUpdater.StartedByUserID = 0; ThreadCollection threads = new ThreadCollection(); trans.Add(threads); threads.UpdateMulti(threadUpdater, (ThreadFields.StartedByUserID == userID)); // remove the user from the UserRoles set, as the user shouldn't be in any roles. RoleUserCollection roleUsersDeleter = new RoleUserCollection(); trans.Add(roleUsersDeleter); // delete all entities directly from the DB which match the following filter. roleUsersDeleter.DeleteMulti(RoleUserFields.UserID == userID); // delete all bookmarks of user BookmarkCollection bookmarkDeleter = new BookmarkCollection(); trans.Add(bookmarkDeleter); // delete all bookmarks for this user directly from the DB using the following filter. bookmarkDeleter.DeleteMulti(BookmarkFields.UserID == userID); // delete all audit data AuditDataCoreCollection auditDataDeleter = new AuditDataCoreCollection(); // first fetch it, then delete all entities from the collection, as the audit data is in an inheritance hierarchy of TargetPerEntity which can't // be deleted directly from the db. trans.Add(auditDataDeleter); auditDataDeleter.GetMulti(AuditDataCoreFields.UserID == userID); auditDataDeleter.DeleteMulti(); // set IP bans set by this user to userid 0 IPBanEntity ipbanUpdater = new IPBanEntity(); ipbanUpdater.IPBanSetByUserID = 0; IPBanCollection ipBans = new IPBanCollection(); trans.Add(ipBans); ipBans.UpdateMulti(ipbanUpdater, (IPBanFields.IPBanSetByUserID == userID)); // delete threadsubscriptions ThreadSubscriptionCollection threadSubscriptionsDeleter = new ThreadSubscriptionCollection(); trans.Add(threadSubscriptionsDeleter); threadSubscriptionsDeleter.DeleteMulti(ThreadSubscriptionFields.UserID == userID); // remove supportqueuethread claims SupportQueueThreadCollection supportQueueThreads = new SupportQueueThreadCollection(); trans.Add(supportQueueThreads); supportQueueThreads.DeleteMulti(SupportQueueThreadFields.ClaimedByUserID == userID); // set all placed in queue references to userid 0, so the threads stay in the queues. SupportQueueThreadEntity supportQueueThreadUpdater = new SupportQueueThreadEntity(); supportQueueThreadUpdater.PlacedInQueueByUserID=0; supportQueueThreads.UpdateMulti(supportQueueThreadUpdater, (SupportQueueThreadFields.PlacedInQueueByUserID == userID)); // now delete the actual user entity trans.Add(toDelete); toDelete.Delete(); // all done trans.Commit(); return true; } catch { trans.Rollback(); throw; } finally { trans.Dispose(); } }
/// <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> /// 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> /// Creates a new thread in the given forum and places the passed in message as the first message in the thread. /// Caller should validate input parameters. /// </summary> /// <param name="forumID">Forum wherein the new thread will be placed</param> /// <param name="userID">User who started this thread</param> /// <param name="subject">Subject of the thread</param> /// <param name="messageText">First message of the thread</param> /// <param name="messageAsHTML">Message text as HTML</param> /// <param name="isSticky">Flag if the thread is sticky / pinned (true) or not (false)</param> /// <param name="userIDIPAddress">IP address of user calling this method</param> /// <param name="defaultSupportQueueID">The ID of the default support queue for this forum. If not null, the thread created will be /// added to the support queue with the ID specified.</param> /// <param name="messageID">The message ID of the new message, which is the start message in the thread.</param> /// <returns>ThreadID if succeeded, 0 if not.</returns> public static int CreateNewThreadInForum(int forumID, int userID, string subject, string messageText, string messageAsHTML, bool isSticky, string userIDIPAddress, int? defaultSupportQueueID, bool subscribeToThread, out int messageID) { Transaction trans = new Transaction(IsolationLevel.ReadCommitted, "NewThread"); try { DateTime postDate = DateTime.Now; ThreadEntity newThread = new ThreadEntity(); newThread.ForumID = forumID; newThread.IsClosed = false; newThread.IsSticky = isSticky; newThread.StartedByUserID = userID; newThread.Subject = subject; newThread.ThreadLastPostingDate = postDate; if(defaultSupportQueueID.HasValue) { // a support queue has been specified as the default support queue for this forum. Add the new thread to this support queue. SupportQueueThreadEntity supportQueueThread = new SupportQueueThreadEntity(); supportQueueThread.QueueID = defaultSupportQueueID.Value; supportQueueThread.PlacedInQueueByUserID = userID; supportQueueThread.PlacedInQueueOn = DateTime.Now; // assign the Thread property to the newly created thread entity, so this supportqueuethreadentity will be part of the graph // of objects which will be saved. supportQueueThread.Thread = newThread; } DateTime postingDate = DateTime.Now; MessageEntity newMessage = new MessageEntity(); newMessage.MessageText = messageText; newMessage.MessageTextAsHTML = messageAsHTML; newMessage.PostedByUserID = userID; newMessage.PostingDate = postingDate; newMessage.PostedFromIP = userIDIPAddress; newMessage.Thread = newThread; // add the newMessage entity to the transaction object. All entities saved recursively will be added automatically trans.Add(newMessage); // save the complete graph newMessage.Save(true); messageID = newMessage.MessageID; int threadID = newMessage.ThreadID; // update thread statistics, this is the task for the message manager, and we pass the transaction object so the actions will run in // the same transaction. MessageManager.UpdateStatisticsAfterMessageInsert(threadID, userID, trans, postingDate, false, subscribeToThread); trans.Commit(); return newThread.ThreadID; } catch(Exception) { trans.Rollback(); throw; } finally { trans.Dispose(); } }
/// <summary>Creates a new, empty SupportQueueThreadEntity object.</summary> /// <returns>A new, empty SupportQueueThreadEntity object.</returns> public override IEntity Create() { IEntity toReturn = new SupportQueueThreadEntity(); // __LLBLGENPRO_USER_CODE_REGION_START CreateNewSupportQueueThread // __LLBLGENPRO_USER_CODE_REGION_END return toReturn; }
/// <summary> setups the sync logic for member _supportQueueThread</summary> /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param> private void SetupSyncSupportQueueThread(IEntityCore relatedEntity) { if(_supportQueueThread!=relatedEntity) { DesetupSyncSupportQueueThread(true, true); _supportQueueThread = (SupportQueueThreadEntity)relatedEntity; this.PerformSetupSyncRelatedEntity( _supportQueueThread, new PropertyChangedEventHandler( OnSupportQueueThreadPropertyChanged ), "SupportQueueThread", SD.HnD.DAL.RelationClasses.StaticThreadRelations.SupportQueueThreadEntityUsingThreadIDStatic, false, ref _alreadyFetchedSupportQueueThread, new string[] { } ); } }
/// <summary> Removes the sync logic for member _supportQueueThread</summary> /// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param> /// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param> private void DesetupSyncSupportQueueThread(bool signalRelatedEntity, bool resetFKFields) { this.PerformDesetupSyncRelatedEntity( _supportQueueThread, new PropertyChangedEventHandler( OnSupportQueueThreadPropertyChanged ), "SupportQueueThread", SD.HnD.DAL.RelationClasses.StaticThreadRelations.SupportQueueThreadEntityUsingThreadIDStatic, false, signalRelatedEntity, "Thread", false, new int[] { (int)ThreadFieldIndex.ThreadID } ); _supportQueueThread = null; }
/// <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; }
/// <summary>Private CTor for deserialization</summary> /// <param name="info"></param> /// <param name="context"></param> protected ThreadEntityBase(SerializationInfo info, StreamingContext context) : base(info, context) { _auditDataThreadRelated = (SD.HnD.DAL.CollectionClasses.AuditDataThreadRelatedCollection)info.GetValue("_auditDataThreadRelated", typeof(SD.HnD.DAL.CollectionClasses.AuditDataThreadRelatedCollection)); _alwaysFetchAuditDataThreadRelated = info.GetBoolean("_alwaysFetchAuditDataThreadRelated"); _alreadyFetchedAuditDataThreadRelated = info.GetBoolean("_alreadyFetchedAuditDataThreadRelated"); _presentInBookmarks = (SD.HnD.DAL.CollectionClasses.BookmarkCollection)info.GetValue("_presentInBookmarks", typeof(SD.HnD.DAL.CollectionClasses.BookmarkCollection)); _alwaysFetchPresentInBookmarks = info.GetBoolean("_alwaysFetchPresentInBookmarks"); _alreadyFetchedPresentInBookmarks = info.GetBoolean("_alreadyFetchedPresentInBookmarks"); _messages = (SD.HnD.DAL.CollectionClasses.MessageCollection)info.GetValue("_messages", typeof(SD.HnD.DAL.CollectionClasses.MessageCollection)); _alwaysFetchMessages = info.GetBoolean("_alwaysFetchMessages"); _alreadyFetchedMessages = info.GetBoolean("_alreadyFetchedMessages"); _threadSubscription = (SD.HnD.DAL.CollectionClasses.ThreadSubscriptionCollection)info.GetValue("_threadSubscription", typeof(SD.HnD.DAL.CollectionClasses.ThreadSubscriptionCollection)); _alwaysFetchThreadSubscription = info.GetBoolean("_alwaysFetchThreadSubscription"); _alreadyFetchedThreadSubscription = info.GetBoolean("_alreadyFetchedThreadSubscription"); _usersWhoBookmarkedThread = (SD.HnD.DAL.CollectionClasses.UserCollection)info.GetValue("_usersWhoBookmarkedThread", typeof(SD.HnD.DAL.CollectionClasses.UserCollection)); _alwaysFetchUsersWhoBookmarkedThread = info.GetBoolean("_alwaysFetchUsersWhoBookmarkedThread"); _alreadyFetchedUsersWhoBookmarkedThread = info.GetBoolean("_alreadyFetchedUsersWhoBookmarkedThread"); _usersWhoPostedInThread = (SD.HnD.DAL.CollectionClasses.UserCollection)info.GetValue("_usersWhoPostedInThread", typeof(SD.HnD.DAL.CollectionClasses.UserCollection)); _alwaysFetchUsersWhoPostedInThread = info.GetBoolean("_alwaysFetchUsersWhoPostedInThread"); _alreadyFetchedUsersWhoPostedInThread = info.GetBoolean("_alreadyFetchedUsersWhoPostedInThread"); _usersWhoSubscribedThread = (SD.HnD.DAL.CollectionClasses.UserCollection)info.GetValue("_usersWhoSubscribedThread", typeof(SD.HnD.DAL.CollectionClasses.UserCollection)); _alwaysFetchUsersWhoSubscribedThread = info.GetBoolean("_alwaysFetchUsersWhoSubscribedThread"); _alreadyFetchedUsersWhoSubscribedThread = info.GetBoolean("_alreadyFetchedUsersWhoSubscribedThread"); _forum = (ForumEntity)info.GetValue("_forum", typeof(ForumEntity)); if(_forum!=null) { _forum.AfterSave+=new EventHandler(OnEntityAfterSave); } _forumReturnsNewIfNotFound = info.GetBoolean("_forumReturnsNewIfNotFound"); _alwaysFetchForum = info.GetBoolean("_alwaysFetchForum"); _alreadyFetchedForum = info.GetBoolean("_alreadyFetchedForum"); _userWhoStartedThread = (UserEntity)info.GetValue("_userWhoStartedThread", typeof(UserEntity)); if(_userWhoStartedThread!=null) { _userWhoStartedThread.AfterSave+=new EventHandler(OnEntityAfterSave); } _userWhoStartedThreadReturnsNewIfNotFound = info.GetBoolean("_userWhoStartedThreadReturnsNewIfNotFound"); _alwaysFetchUserWhoStartedThread = info.GetBoolean("_alwaysFetchUserWhoStartedThread"); _alreadyFetchedUserWhoStartedThread = info.GetBoolean("_alreadyFetchedUserWhoStartedThread"); _supportQueueThread = (SupportQueueThreadEntity)info.GetValue("_supportQueueThread", typeof(SupportQueueThreadEntity)); if(_supportQueueThread!=null) { _supportQueueThread.AfterSave+=new EventHandler(OnEntityAfterSave); } _supportQueueThreadReturnsNewIfNotFound = info.GetBoolean("_supportQueueThreadReturnsNewIfNotFound"); _alwaysFetchSupportQueueThread = info.GetBoolean("_alwaysFetchSupportQueueThread"); _alreadyFetchedSupportQueueThread = info.GetBoolean("_alreadyFetchedSupportQueueThread"); this.FixupDeserialization(FieldInfoProviderSingleton.GetInstance(), PersistenceInfoProviderSingleton.GetInstance()); // __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor // __LLBLGENPRO_USER_CODE_REGION_END }