/// <summary> /// Adds the given IPBan /// </summary> /// <param name="toAdd">the dto containing the values to add as a new entity</param> /// <returns>the ID of the new IPBan, or 0 if it failed</returns> public static async Task <int> AddNewIPBanAsync(IPBanDto toAdd) { if (toAdd == null) { return(0); } var toInsert = new IPBanEntity() { IPSegment1 = toAdd.IPSegment1, IPSegment2 = toAdd.IPSegment2, IPSegment3 = toAdd.IPSegment3, IPSegment4 = toAdd.IPSegment4, Range = toAdd.Range, Reason = toAdd.Reason, IPBanSetByUserID = toAdd.IPBanSetByUserID }; using (var adapter = new DataAccessAdapter()) { var result = await adapter.SaveEntityAsync(toInsert).ConfigureAwait(false); return(result ? toInsert.IPBanID : 0); } }
/// <summary>Creates a new, empty IPBanEntity object.</summary> /// <returns>A new, empty IPBanEntity object.</returns> public override IEntity Create() { IEntity toReturn = new IPBanEntity(); // __LLBLGENPRO_USER_CODE_REGION_START CreateNewIPBan // __LLBLGENPRO_USER_CODE_REGION_END return(toReturn); }
/// <summary> /// Checks if passed in IP address, in string format matches an IP ban. If the ip address matches an ip ban, the matching IP ban is returned /// </summary> /// <param name="allCachedIPBans">All cached IP bans from the cache.</param> /// <param name="ipAddressUser">The ip address of the user, in string format.</param> /// <returns>null if the user doesn't match any IP ban, or the first IPBan entity it matches</returns> public static IPBanEntity GetIPBanMatchingUserIPAddress(Dictionary <int, Dictionary <string, IPBanEntity> > allCachedIPBans, string ipAddressUser) { var ipAddressSegments = ipAddressUser.Split('.'); if (ipAddressSegments.Length != 4) { // can't do matching as the ip address has less or more segments return(null); } Dictionary <string, IPBanEntity> rangeBans = null; var ipTemp = new StringBuilder(); IPBanEntity toReturn = null; // for each segment we'll check if it, combined with the previous segments, results in a match. If not, the next segment will be tried. for (var i = 0; i < 4; i++) { // check range ban. Build ip address segments from ip address passed in and check that with the segments in the range ban dictionary if (i > 0) { ipTemp.Append("."); } ipTemp.Append(ipAddressSegments[i]); rangeBans = allCachedIPBans.GetValue(8 * (i + 1)); if (rangeBans == null) { // no range bans with this range, continue continue; } if (rangeBans.TryGetValue(ipTemp.ToString(), out toReturn)) { // we have a match! break; } } return(toReturn); }
private void Page_Load(object sender, System.EventArgs e) { if (!Page.IsPostBack) { string banComplainAddress = ApplicationAdapter.GetIPBanComplainEmailAddress(); lnkBanComplaintEmailAddress.Text = banComplainAddress; lnkBanComplaintEmailAddress.NavigateUrl += banComplainAddress; // get the set of IP-bans for the given IP address string ipAddressUser = Request.UserHostAddress; IPBanEntity matchingBan = SecurityGuiHelper.GetIPBanMatchingUserIPAddress(CacheManager.GetAllIPBans(), ipAddressUser); if (matchingBan != null) { // has to match a ban lblIPBanDate.Text = matchingBan.IPBanSetOn.ToString("dd-MMM-yyyy HH:mm:ss"); lblIPBanRange.Text = string.Format("{0}.{1}.{2}.{3} / {4}", matchingBan.IPSegment1, matchingBan.IPSegment2, matchingBan.IPSegment3, matchingBan.IPSegment4, matchingBan.Range); lblIPBanReason.Text = matchingBan.Reason; } } }
/// <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 async Task <bool> DeleteUserAsync(int userId) { if (userId <= 1) { // can't delete the Anonymous user nor the admin user return(false); } var toDelete = await UserGuiHelper.GetUserAsync(userId); if (toDelete == null) { // user doesn't exist return(false); } if (toDelete.NickName == "Admin") { // can't delete admin return(false); } using (var adapter = new DataAccessAdapter()) { await adapter.StartTransactionAsync(IsolationLevel.ReadCommitted, "DeleteUser").ConfigureAwait(false); try { // we'll first update all PostedByUserId fields of all messages which are posted by the user to delete. var messageUpdater = new MessageEntity { PostedByUserID = 0 }; // reset to AC. await adapter.UpdateEntitiesDirectlyAsync(messageUpdater, new RelationPredicateBucket(MessageFields.PostedByUserID.Equal(userId))) .ConfigureAwait(false); // set the startuser of threads started by this user to 0 var threadUpdater = new ThreadEntity { StartedByUserID = 0 }; await adapter.UpdateEntitiesDirectlyAsync(threadUpdater, new RelationPredicateBucket(ThreadFields.StartedByUserID.Equal(userId))) .ConfigureAwait(false); // remove the user from the UserRoles set, as the user shouldn't be in any roles. await adapter.DeleteEntitiesDirectlyAsync(typeof(RoleUserEntity), new RelationPredicateBucket(RoleUserFields.UserID.Equal(userId))) .ConfigureAwait(false); // delete all bookmarks of user await adapter.DeleteEntitiesDirectlyAsync(typeof(BookmarkEntity), new RelationPredicateBucket(BookmarkFields.UserID.Equal(userId))) .ConfigureAwait(false); // delete all audit data // 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. var auditData = await adapter.FetchQueryAsync(new QueryFactory().User.Where(UserFields.UserID.Equal(userId))).ConfigureAwait(false); await adapter.DeleteEntityCollectionAsync(auditData).ConfigureAwait(false); // set IP bans set by this user to userid 0 var ipbanUpdater = new IPBanEntity { IPBanSetByUserID = 0 }; await adapter.UpdateEntitiesDirectlyAsync(ipbanUpdater, new RelationPredicateBucket(IPBanFields.IPBanSetByUserID.Equal(userId))) .ConfigureAwait(false); // delete threadsubscriptions await adapter.DeleteEntitiesDirectlyAsync(typeof(ThreadSubscriptionEntity), new RelationPredicateBucket(ThreadSubscriptionFields.UserID.Equal(userId))) .ConfigureAwait(false); // remove supportqueuethread claims await adapter.DeleteEntitiesDirectlyAsync(typeof(SupportQueueThreadEntity), new RelationPredicateBucket(SupportQueueThreadFields.ClaimedByUserID.Equal(userId))) .ConfigureAwait(false); // set all placed in queue references to userid 0, so the threads stay in the queues. var supportQueueThreadUpdater = new SupportQueueThreadEntity { PlacedInQueueByUserID = 0 }; await adapter.UpdateEntitiesDirectlyAsync(supportQueueThreadUpdater, new RelationPredicateBucket(SupportQueueThreadFields.PlacedInQueueByUserID.Equal(userId))) .ConfigureAwait(false); // now delete the actual user entity await adapter.DeleteEntityAsync(toDelete).ConfigureAwait(false); adapter.Commit(); return(true); } catch { adapter.Rollback(); throw; } } }
/// <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(); } }