public ActionResult Delete(DeletePrivateMessageViewModel deletePrivateMessageViewModel)
        {
            using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
            {
                if (Request.IsAjaxRequest())
                {
                    var privateMessage = _privateMessageService.Get(deletePrivateMessageViewModel.Id);
                    if (privateMessage.UserTo.Id == LoggedOnReadOnlyUser.Id | privateMessage.UserFrom.Id == LoggedOnReadOnlyUser.Id)
                    {
                        _privateMessageService.DeleteMessage(privateMessage);
                    }
                    else
                    {
                        throw new Exception(LocalizationService.GetResourceString("Errors.NoPermission"));
                    }
                }

                try
                {
                    unitOfWork.Commit();
                }
                catch (Exception ex)
                {
                    unitOfWork.Rollback();
                    LoggingService.Error(ex);
                    throw new Exception(LocalizationService.GetResourceString("Errors.GenericMessage"));
                }
            }

            return(null);
        }
Esempio n. 2
0
        public ActionResult BatchDeletePrivateMessages(BatchDeletePrivateMessagesViewModel viewModel)
        {
            try
            {
                var pms        = _privateMessageService.GetPrivateMessagesOlderThan(viewModel.Days);
                var pmToDelete = new List <PrivateMessage>();
                pmToDelete.AddRange(pms);
                var count = pmToDelete.Count;
                foreach (var pm in pmToDelete)
                {
                    _privateMessageService.DeleteMessage(pm);
                }
                Context.SaveChanges();

                TempData[Constants.MessageViewBagName] = new GenericMessageViewModel
                {
                    Message     = $"{count} Private Messages deleted",
                    MessageType = GenericMessages.success
                };
            }
            catch (Exception ex)
            {
                Context.RollBack();
                LoggingService.Error(ex);
                TempData[Constants.MessageViewBagName] = new GenericMessageViewModel
                {
                    Message     = ex.Message,
                    MessageType = GenericMessages.danger
                };
            }


            return(View(viewModel));
        }
        public ActionResult Delete(DeletePrivateMessageViewModel deletePrivateMessageViewModel)
        {
            if (Request.IsAjaxRequest())
            {
                var loggedOnReadOnlyUser = User.GetMembershipUser(MembershipService);
                var privateMessage       = _privateMessageService.Get(deletePrivateMessageViewModel.Id);
                if ((privateMessage.UserTo.Id == loggedOnReadOnlyUser.Id) |
                    (privateMessage.UserFrom.Id == loggedOnReadOnlyUser.Id))
                {
                    _privateMessageService.DeleteMessage(privateMessage);
                }
                else
                {
                    throw new Exception(LocalizationService.GetResourceString("Errors.NoPermission"));
                }
            }

            try
            {
                Context.SaveChanges();
            }
            catch (Exception ex)
            {
                Context.RollBack();
                LoggingService.Error(ex);
                throw new Exception(LocalizationService.GetResourceString("Errors.GenericMessage"));
            }


            return(null);
        }
Esempio n. 4
0
        public ActionResult BatchDeletePrivateMessages(BatchDeletePrivateMessagesViewModel viewModel)
        {
            using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
            {
                try
                {
                    var pms        = _privateMessageService.GetPrivateMessagesOlderThan(viewModel.Days);
                    var pmToDelete = new List <PrivateMessage>();
                    pmToDelete.AddRange(pms);
                    var count = pmToDelete.Count;
                    foreach (var pm in pmToDelete)
                    {
                        _privateMessageService.DeleteMessage(pm);
                    }
                    unitOfWork.Commit();

                    TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel
                    {
                        Message     = string.Format("{0} Private Messages deleted", count),
                        MessageType = GenericMessages.success
                    };
                }
                catch (Exception ex)
                {
                    unitOfWork.Rollback();
                    LoggingService.Error(ex);
                    TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel
                    {
                        Message     = ex.Message,
                        MessageType = GenericMessages.danger
                    };
                }
            }

            return(View(viewModel));
        }
Esempio n. 5
0
        public void ScrubUsers(MembershipUser user)
        {
            //// TODO - This REALLY needs to be refactored

            // PROFILE
            user.Website   = string.Empty;
            user.Twitter   = string.Empty;
            user.Facebook  = string.Empty;
            user.Avatar    = string.Empty;
            user.Signature = string.Empty;

            //// User Votes
            if (user.Votes != null)
            {
                var votesToDelete = new List <Vote>();
                votesToDelete.AddRange(user.Votes);
                votesToDelete.AddRange(user.VotesGiven);
                foreach (var d in votesToDelete)
                {
                    _voteService.Delete(d);
                }
                user.Votes.Clear();
                user.VotesGiven.Clear();
                _context.SaveChanges();
            }

            // User badge time checks
            if (user.BadgeTypesTimeLastChecked != null)
            {
                var toDelete = new List <BadgeTypeTimeLastChecked>();
                toDelete.AddRange(user.BadgeTypesTimeLastChecked);
                foreach (var obj in toDelete)
                {
                    _badgeService.DeleteTimeLastChecked(obj);
                }
                user.BadgeTypesTimeLastChecked.Clear();
                _context.SaveChanges();
            }

            // User Badges
            if (user.Badges != null)
            {
                var toDelete = new List <Badge>();
                toDelete.AddRange(user.Badges);
                foreach (var obj in toDelete)
                {
                    _badgeService.Delete(obj);
                }
                user.Badges.Clear();
                _context.SaveChanges();
            }

            // User category notifications
            if (user.CategoryNotifications != null)
            {
                var toDelete = new List <CategoryNotification>();
                toDelete.AddRange(user.CategoryNotifications);
                foreach (var obj in toDelete)
                {
                    _categoryNotificationService.Delete(obj);
                }
                user.CategoryNotifications.Clear();
                _context.SaveChanges();
            }

            // User PM Received
            if (user.PrivateMessagesReceived != null)
            {
                var toDelete = new List <PrivateMessage>();
                toDelete.AddRange(user.PrivateMessagesReceived);
                foreach (var obj in toDelete)
                {
                    _privateMessageService.DeleteMessage(obj);
                }
                user.PrivateMessagesReceived.Clear();
                _context.SaveChanges();
            }

            // User PM Sent
            if (user.PrivateMessagesSent != null)
            {
                var toDelete = new List <PrivateMessage>();
                toDelete.AddRange(user.PrivateMessagesSent);
                foreach (var obj in toDelete)
                {
                    _privateMessageService.DeleteMessage(obj);
                }
                user.PrivateMessagesSent.Clear();
                _context.SaveChanges();
            }

            // User Favourites
            if (user.Favourites != null)
            {
                var toDelete = new List <Favourite>();
                toDelete.AddRange(user.Favourites);
                foreach (var obj in toDelete)
                {
                    _favouriteService.Delete(obj);
                }
                user.Favourites.Clear();
                _context.SaveChanges();
            }

            if (user.TopicNotifications != null)
            {
                var notificationsToDelete = new List <TopicNotification>();
                notificationsToDelete.AddRange(user.TopicNotifications);
                foreach (var topicNotification in notificationsToDelete)
                {
                    _topicNotificationService.Delete(topicNotification);
                }
                user.TopicNotifications.Clear();
            }

            // Also clear their points
            var userPoints = user.Points;

            if (userPoints.Any())
            {
                var pointsList = new List <MembershipUserPoints>();
                pointsList.AddRange(userPoints);
                foreach (var point in pointsList)
                {
                    point.User = null;
                    _membershipUserPointsService.Delete(point);
                }
                user.Points.Clear();
            }

            // Now clear all activities for this user
            var usersActivities = _activityService.GetDataFieldByGuid(user.Id);

            _activityService.Delete(usersActivities.ToList());
            _context.SaveChanges();

            // Also clear their poll votes
            var userPollVotes = user.PollVotes;

            if (userPollVotes.Any())
            {
                var pollList = new List <PollVote>();
                pollList.AddRange(userPollVotes);
                foreach (var vote in pollList)
                {
                    vote.User = null;
                    _pollVoteService.Delete(vote);
                }
                user.PollVotes.Clear();
                _context.SaveChanges();
            }

            //// ######### POSTS TOPICS ########

            // Delete all topics first
            // This will get rid of everyone elses posts associated with this users topic too
            var topics = user.Topics;

            if (topics != null && topics.Any())
            {
                var topicList = new List <Topic>();
                topicList.AddRange(topics);
                foreach (var topic in topicList)
                {
                    _topicService.Delete(topic);
                }
                user.Topics.Clear();
                _context.SaveChanges();
            }

            // Now sorts Last Posts on topics and delete all the users posts
            var posts = user.Posts;

            if (posts != null && posts.Any())
            {
                var postIds = posts.Select(x => x.Id).ToList();

                // Get all categories
                var allCategories = _categoryService.GetAll();

                // Need to see if any of these are last posts on Topics
                // If so, need to swap out last post
                var lastPostTopics = _topicService.GetTopicsByLastPost(postIds, allCategories.ToList());
                foreach (var topic in lastPostTopics.Where(x => x.User.Id != user.Id))
                {
                    var lastPost = topic.Posts.Where(x => !postIds.Contains(x.Id)).OrderByDescending(x => x.DateCreated).FirstOrDefault();
                    topic.LastPost = lastPost;
                }

                _context.SaveChanges();

                // Delete all posts
                var postList = new List <Post>();
                postList.AddRange(posts);
                foreach (var post in postList)
                {
                    _postService.Delete(post, true);
                }

                user.UploadedFiles.Clear();
                user.Posts.Clear();

                _context.SaveChanges();
            }
        }
Esempio n. 6
0
        public void ScrubUsers(MembershipUser user, IUnitOfWork unitOfWork)
        {
            // PROFILE
            user.Website   = string.Empty;
            user.Twitter   = string.Empty;
            user.Facebook  = string.Empty;
            user.Avatar    = string.Empty;
            user.Signature = string.Empty;

            // User Votes
            if (user.Votes != null)
            {
                var votesToDelete = new List <Vote>();
                votesToDelete.AddRange(user.Votes);
                foreach (var d in votesToDelete)
                {
                    _voteService.Delete(d);
                }
                user.Votes.Clear();
            }

            // User Badges
            if (user.Badges != null)
            {
                var toDelete = new List <Badge>();
                toDelete.AddRange(user.Badges);
                foreach (var obj in toDelete)
                {
                    _badgeService.Delete(obj);
                }
                user.Badges.Clear();
            }

            // User badge time checks
            if (user.BadgeTypesTimeLastChecked != null)
            {
                var toDelete = new List <BadgeTypeTimeLastChecked>();
                toDelete.AddRange(user.BadgeTypesTimeLastChecked);
                foreach (var obj in toDelete)
                {
                    _badgeService.DeleteTimeLastChecked(obj);
                }
                user.BadgeTypesTimeLastChecked.Clear();
            }

            // User category notifications
            if (user.CategoryNotifications != null)
            {
                var toDelete = new List <CategoryNotification>();
                toDelete.AddRange(user.CategoryNotifications);
                foreach (var obj in toDelete)
                {
                    _categoryNotificationService.Delete(obj);
                }
                user.CategoryNotifications.Clear();
            }

            // User PM Received
            var pmUpdate = false;

            if (user.PrivateMessagesReceived != null)
            {
                pmUpdate = true;
                var toDelete = new List <PrivateMessage>();
                toDelete.AddRange(user.PrivateMessagesReceived);
                foreach (var obj in toDelete)
                {
                    _privateMessageService.DeleteMessage(obj);
                }
                user.PrivateMessagesReceived.Clear();
            }

            // User PM Sent
            if (user.PrivateMessagesSent != null)
            {
                pmUpdate = true;
                var toDelete = new List <PrivateMessage>();
                toDelete.AddRange(user.PrivateMessagesSent);
                foreach (var obj in toDelete)
                {
                    _privateMessageService.DeleteMessage(obj);
                }
                user.PrivateMessagesSent.Clear();
            }

            if (pmUpdate)
            {
                unitOfWork.SaveChanges();
            }

            // User Favourites
            if (user.Favourites != null)
            {
                var toDelete = new List <Favourite>();
                toDelete.AddRange(user.Favourites);
                foreach (var obj in toDelete)
                {
                    _favouriteRepository.Delete(obj);
                }
                user.Favourites.Clear();
            }

            if (user.TopicNotifications != null)
            {
                var notificationsToDelete = new List <TopicNotification>();
                notificationsToDelete.AddRange(user.TopicNotifications);
                foreach (var topicNotification in notificationsToDelete)
                {
                    _topicNotificationService.Delete(topicNotification);
                }
                user.TopicNotifications.Clear();
            }

            // Also clear their points
            var userPoints = user.Points;

            if (userPoints.Any())
            {
                var pointsList = new List <MembershipUserPoints>();
                pointsList.AddRange(userPoints);
                foreach (var point in pointsList)
                {
                    point.User = null;
                    _membershipUserPointsService.Delete(point);
                }
                user.Points.Clear();
            }

            // Now clear all activities for this user
            var usersActivities = _activityService.GetDataFieldByGuid(user.Id);

            _activityService.Delete(usersActivities.ToList());

            // Also clear their poll votes
            var userPollVotes = user.PollVotes;

            if (userPollVotes.Any())
            {
                var pollList = new List <PollVote>();
                pollList.AddRange(userPollVotes);
                foreach (var vote in pollList)
                {
                    vote.User = null;
                    _pollVoteRepository.Delete(vote);
                }
                user.PollVotes.Clear();
            }

            unitOfWork.SaveChanges();


            // Also clear their polls
            var userPolls = user.Polls;

            if (userPolls.Any())
            {
                var polls = new List <Poll>();
                polls.AddRange(userPolls);
                foreach (var poll in polls)
                {
                    //Delete the poll answers
                    var pollAnswers = poll.PollAnswers;
                    if (pollAnswers.Any())
                    {
                        var pollAnswersList = new List <PollAnswer>();
                        pollAnswersList.AddRange(pollAnswers);
                        foreach (var answer in pollAnswersList)
                        {
                            answer.Poll = null;
                            _pollAnswerRepository.Delete(answer);
                        }
                    }

                    poll.PollAnswers.Clear();
                    poll.User = null;
                    _pollRepository.Delete(poll);
                }
                user.Polls.Clear();
            }

            unitOfWork.SaveChanges();

            // ######### POSTS TOPICS ########

            // Delete all topics first
            var topics = user.Topics;

            if (topics != null && topics.Any())
            {
                var topicList = new List <Topic>();
                topicList.AddRange(topics);
                foreach (var topic in topicList)
                {
                    topic.LastPost = null;
                    topic.Posts.Clear();
                    topic.Tags.Clear();
                    _topicRepository.Delete(topic);
                }
                user.Topics.Clear();
                unitOfWork.SaveChanges();
            }

            // Now sorts Last Posts on topics and delete all the users posts
            var posts = user.Posts;

            if (posts != null && posts.Any())
            {
                var postIds = posts.Select(x => x.Id).ToList();

                // Get all categories
                var allCategories = _categoryService.GetAll();

                // Need to see if any of these are last posts on Topics
                // If so, need to swap out last post
                var lastPostTopics = _topicRepository.GetTopicsByLastPost(postIds, allCategories.ToList());
                foreach (var topic in lastPostTopics.Where(x => x.User.Id != user.Id))
                {
                    var lastPost = topic.Posts.Where(x => !postIds.Contains(x.Id)).OrderByDescending(x => x.DateCreated).FirstOrDefault();
                    topic.LastPost = lastPost;
                }

                unitOfWork.SaveChanges();

                user.UploadedFiles.Clear();

                // Delete all posts

                var postList = new List <Post>();
                postList.AddRange(posts);
                foreach (var post in postList)
                {
                    if (post.Files != null)
                    {
                        var files     = post.Files;
                        var filesList = new List <UploadedFile>();
                        filesList.AddRange(files);
                        foreach (var file in filesList)
                        {
                            // store the file path as we'll need it to delete on the file system
                            var filePath = file.FilePath;

                            // Now delete it
                            _uploadedFileService.Delete(file);

                            // And finally delete from the file system
                            System.IO.File.Delete(HostingEnvironment.MapPath(filePath));
                        }
                        post.Files.Clear();
                    }
                    _postRepository.Delete(post);
                }
                user.Posts.Clear();

                unitOfWork.SaveChanges();
            }
        }
Esempio n. 7
0
        /// <inheritdoc />
        public async Task <IPipelineProcess <MembershipUser> > Process(IPipelineProcess <MembershipUser> input,
                                                                       IMvcForumContext context)
        {
            _voteService.RefreshContext(context);
            _badgeService.RefreshContext(context);
            _notificationService.RefreshContext(context);
            _privateMessageService.RefreshContext(context);
            _favouriteService.RefreshContext(context);
            _membershipUserPointsService.RefreshContext(context);
            _activityService.RefreshContext(context);
            _pollService.RefreshContext(context);
            _topicService.RefreshContext(context);
            _categoryService.RefreshContext(context);
            _postService.RefreshContext(context);

            try
            {
                // PROFILE
                input.EntityToProcess.Website   = string.Empty;
                input.EntityToProcess.Twitter   = string.Empty;
                input.EntityToProcess.Facebook  = string.Empty;
                input.EntityToProcess.Avatar    = string.Empty;
                input.EntityToProcess.Signature = string.Empty;

                // Delete all topics
                var topics = input.EntityToProcess.Topics;
                if (topics != null && topics.Any())
                {
                    var topicList = new List <Topic>();
                    topicList.AddRange(topics);
                    foreach (var topic in topicList)
                    {
                        var topicDeleteResult = await _topicService.Delete(topic);

                        if (!topicDeleteResult.Successful)
                        {
                            input.AddError(topicDeleteResult.ProcessLog.FirstOrDefault());
                            return(input);
                        }
                    }
                    input.EntityToProcess.Topics.Clear();
                    await context.SaveChangesAsync();
                }

                // Now sorts Last Posts on topics and delete all the users posts
                var posts = input.EntityToProcess.Posts;
                if (posts != null && posts.Any())
                {
                    var postIds = posts.Select(x => x.Id).ToList();

                    // Get all categories
                    var allCategories = _categoryService.GetAll();

                    // Need to see if any of these are last posts on Topics
                    // If so, need to swap out last post
                    var lastPostTopics = _topicService.GetTopicsByLastPost(postIds, allCategories.ToList());
                    foreach (var topic in lastPostTopics.Where(x => x.User.Id != input.EntityToProcess.Id))
                    {
                        var lastPost = topic.Posts.Where(x => !postIds.Contains(x.Id))
                                       .OrderByDescending(x => x.DateCreated)
                                       .FirstOrDefault();
                        topic.LastPost = lastPost;
                    }

                    await context.SaveChangesAsync();

                    // Delete all posts
                    var postList = new List <Post>();
                    postList.AddRange(posts);
                    foreach (var post in postList)
                    {
                        // Delete post via pipeline
                        var postDeleteResult = await _postService.Delete(post, true);

                        if (!postDeleteResult.Successful)
                        {
                            input.AddError(postDeleteResult.ProcessLog.FirstOrDefault());
                            return(input);
                        }
                    }

                    input.EntityToProcess.UploadedFiles.Clear();
                    input.EntityToProcess.Posts.Clear();

                    await context.SaveChangesAsync();
                }

                // User Votes
                if (input.EntityToProcess.Votes != null)
                {
                    var votesToDelete = new List <Vote>();
                    votesToDelete.AddRange(input.EntityToProcess.Votes);
                    votesToDelete.AddRange(input.EntityToProcess.VotesGiven);
                    foreach (var d in votesToDelete)
                    {
                        _voteService.Delete(d);
                    }
                    input.EntityToProcess.Votes.Clear();
                    input.EntityToProcess.VotesGiven.Clear();
                    await context.SaveChangesAsync();
                }

                // User badge time checks
                if (input.EntityToProcess.BadgeTypesTimeLastChecked != null)
                {
                    var toDelete = new List <BadgeTypeTimeLastChecked>();
                    toDelete.AddRange(input.EntityToProcess.BadgeTypesTimeLastChecked);
                    foreach (var obj in toDelete)
                    {
                        _badgeService.DeleteTimeLastChecked(obj);
                    }
                    input.EntityToProcess.BadgeTypesTimeLastChecked.Clear();
                    await context.SaveChangesAsync();
                }

                // User Badges
                if (input.EntityToProcess.Badges != null)
                {
                    var toDelete = new List <Badge>();
                    toDelete.AddRange(input.EntityToProcess.Badges);
                    foreach (var obj in toDelete)
                    {
                        _badgeService.Delete(obj);
                    }
                    input.EntityToProcess.Badges.Clear();
                    await context.SaveChangesAsync();
                }

                // User category notifications
                if (input.EntityToProcess.CategoryNotifications != null)
                {
                    var toDelete = new List <CategoryNotification>();
                    toDelete.AddRange(input.EntityToProcess.CategoryNotifications);
                    foreach (var obj in toDelete)
                    {
                        _notificationService.Delete(obj);
                    }
                    input.EntityToProcess.CategoryNotifications.Clear();
                    await context.SaveChangesAsync();
                }

                // User PM Received
                if (input.EntityToProcess.PrivateMessagesReceived != null)
                {
                    var toDelete = new List <PrivateMessage>();
                    toDelete.AddRange(input.EntityToProcess.PrivateMessagesReceived);
                    foreach (var obj in toDelete)
                    {
                        _privateMessageService.DeleteMessage(obj);
                    }
                    input.EntityToProcess.PrivateMessagesReceived.Clear();
                    await context.SaveChangesAsync();
                }

                // User PM Sent
                if (input.EntityToProcess.PrivateMessagesSent != null)
                {
                    var toDelete = new List <PrivateMessage>();
                    toDelete.AddRange(input.EntityToProcess.PrivateMessagesSent);
                    foreach (var obj in toDelete)
                    {
                        _privateMessageService.DeleteMessage(obj);
                    }
                    input.EntityToProcess.PrivateMessagesSent.Clear();
                    await context.SaveChangesAsync();
                }

                // User Favourites
                if (input.EntityToProcess.Favourites != null)
                {
                    var toDelete = new List <Favourite>();
                    toDelete.AddRange(input.EntityToProcess.Favourites);
                    foreach (var obj in toDelete)
                    {
                        _favouriteService.Delete(obj);
                    }
                    input.EntityToProcess.Favourites.Clear();
                    await context.SaveChangesAsync();
                }

                if (input.EntityToProcess.TopicNotifications != null)
                {
                    var notificationsToDelete = new List <TopicNotification>();
                    notificationsToDelete.AddRange(input.EntityToProcess.TopicNotifications);
                    foreach (var topicNotification in notificationsToDelete)
                    {
                        _notificationService.Delete(topicNotification);
                    }
                    input.EntityToProcess.TopicNotifications.Clear();
                }

                // Also clear their points
                var userPoints = input.EntityToProcess.Points;
                if (userPoints.Any())
                {
                    var pointsList = new List <MembershipUserPoints>();
                    pointsList.AddRange(userPoints);
                    foreach (var point in pointsList)
                    {
                        point.User = null;
                        await _membershipUserPointsService.Delete(point);
                    }
                    input.EntityToProcess.Points.Clear();
                }

                // Now clear all activities for this user
                var usersActivities = _activityService.GetDataFieldByGuid(input.EntityToProcess.Id);
                _activityService.Delete(usersActivities.ToList());
                await context.SaveChangesAsync();

                // Also clear their poll votes
                var userPollVotes = input.EntityToProcess.PollVotes;
                if (userPollVotes.Any())
                {
                    var pollList = new List <PollVote>();
                    pollList.AddRange(userPollVotes);
                    foreach (var vote in pollList)
                    {
                        vote.User = null;
                        _pollService.Delete(vote);
                    }
                    input.EntityToProcess.PollVotes.Clear();
                    await context.SaveChangesAsync();
                }
            }
            catch (Exception ex)
            {
                input.AddError(ex.Message);
                _loggingService.Error(ex);
            }

            return(input);
        }
Esempio n. 8
0
        /// <summary>
        /// Delete a member
        /// </summary>
        /// <param name="user"></param>
        public bool Delete(MembershipUser user)
        {
            try
            {
                // Delete all private messages from this user
                var msgsToDelete = new List <PrivateMessage>();
                msgsToDelete.AddRange(user.PrivateMessagesSent);
                foreach (var msgToDelete in msgsToDelete)
                {
                    _privateMessageService.DeleteMessage(msgToDelete);
                }

                msgsToDelete.Clear();
                msgsToDelete.AddRange(user.PrivateMessagesReceived);
                foreach (var msgToDelete in msgsToDelete)
                {
                    _privateMessageService.DeleteMessage(msgToDelete);
                }

                // Delete all badge times last checked
                var badgeTypesTimeLastCheckedToDelete = new List <BadgeTypeTimeLastChecked>();
                badgeTypesTimeLastCheckedToDelete.AddRange(user.BadgeTypesTimeLastChecked);
                foreach (var badgeTypeTimeLastCheckedToDelete in badgeTypesTimeLastCheckedToDelete)
                {
                    _badgeService.DeleteTimeLastChecked(badgeTypeTimeLastCheckedToDelete);
                }

                // Delete all points from this user
                var pointsToDelete = new List <MembershipUserPoints>();
                pointsToDelete.AddRange(user.Points);
                foreach (var pointToDelete in pointsToDelete)
                {
                    _membershipUserPointsService.Delete(pointToDelete);
                }

                // Delete all topic notifications
                var topicNotificationsToDelete = new List <TopicNotification>();
                topicNotificationsToDelete.AddRange(user.TopicNotifications);
                foreach (var topicNotificationToDelete in topicNotificationsToDelete)
                {
                    _topicNotificationService.Delete(topicNotificationToDelete);
                }

                // Delete all user's votes
                var votesToDelete = new List <Vote>();
                votesToDelete.AddRange(user.Votes);
                foreach (var voteToDelete in votesToDelete)
                {
                    _voteService.Delete(voteToDelete);
                }

                // Delete all user's badges
                var badgesToDelete = new List <Badge>();
                badgesToDelete.AddRange(user.Badges);
                foreach (var badgeToDelete in badgesToDelete)
                {
                    _badgeService.Delete(badgeToDelete);
                }

                // Delete all user's category notifications
                var categoryNotificationsToDelete = new List <CategoryNotification>();
                categoryNotificationsToDelete.AddRange(user.CategoryNotifications);
                foreach (var categoryNotificationToDelete in categoryNotificationsToDelete)
                {
                    _categoryNotificationService.Delete(categoryNotificationToDelete);
                }

                // Just clear the roles, don't delete them
                user.Roles.Clear();

                _membershipRepository.Delete(user);

                return(true);
            }
            catch (Exception ex)
            {
                _loggingService.Error(ex);
            }
            return(false);
        }