예제 #1
0
 /// <inheritdoc />
 public void RefreshContext(IMvcForumContext context)
 {
     _context = context;
     _membershipUserPointsService.RefreshContext(context);
     _settingsService.RefreshContext(context);
     _notificationService.RefreshContext(context);
     _favouriteService.RefreshContext(context);
     _postService.RefreshContext(context);
     _roleService.RefreshContext(context);
     _pollService.RefreshContext(context);
 }
예제 #2
0
 /// <inheritdoc />
 public void RefreshContext(ICoreForumContext context)
 {
     _context = context;
     _roleService.RefreshContext(context);
     _membershipUserPointsService.RefreshContext(context);
     _settingsService.RefreshContext(context);
     _voteService.RefreshContext(context);
     _uploadedFileService.RefreshContext(context);
     _favouriteService.RefreshContext(context);
     _postEditService.RefreshContext(context);
 }
예제 #3
0
 /// <inheritdoc />
 public void RefreshContext(IMvcForumContext context)
 {
     _context = context;
     _settingsService.RefreshContext(context);
     _localizationService.RefreshContext(context);
     _activityService.RefreshContext(context);
     _voteService.RefreshContext(context);
     _favouriteService.RefreshContext(context);
     _membershipUserPointsService.RefreshContext(context);
     _topicService.RefreshContext(context);
     _groupService.RefreshContext(context);
     _postService.RefreshContext(context);
     _notificationService.RefreshContext(context);
     _pollService.RefreshContext(context);
 }
예제 #4
0
 /// <inheritdoc />
 public void RefreshContext(ICoreForumContext context)
 {
     _context = context;
     _settingsService.RefreshContext(context);
     _localizationService.RefreshContext(context);
     _activityService.RefreshContext(context);
     _voteService.RefreshContext(context);
     _badgeService.RefreshContext(context);
     _privateMessageService.RefreshContext(context);
     _favouriteService.RefreshContext(context);
     _membershipUserPointsService.RefreshContext(context);
     _topicService.RefreshContext(context);
     _categoryService.RefreshContext(context);
     _postService.RefreshContext(context);
     _notificationService.RefreshContext(context);
     _pollService.RefreshContext(context);
 }
예제 #5
0
        /// <inheritdoc />
        public async Task <IPipelineProcess <MembershipUser> > Process(IPipelineProcess <MembershipUser> input,
                                                                       IMvcForumContext context)
        {
            _voteService.RefreshContext(context);
            _notificationService.RefreshContext(context);
            _favouriteService.RefreshContext(context);
            _membershipUserPointsService.RefreshContext(context);
            _activityService.RefreshContext(context);
            _pollService.RefreshContext(context);
            _topicService.RefreshContext(context);
            _groupService.RefreshContext(context);
            _postService.RefreshContext(context);

            try
            {
                // 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 Groups
                    var allGroups = _groupService.GetAll(input.EntityToProcess.Id);

                    // 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, allGroups.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 Group notifications
                if (input.EntityToProcess.GroupNotifications != null)
                {
                    var toDelete = new List <GroupNotification>();
                    toDelete.AddRange(input.EntityToProcess.GroupNotifications);
                    foreach (var obj in toDelete)
                    {
                        _notificationService.Delete(obj);
                    }
                    input.EntityToProcess.GroupNotifications.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);
        }
예제 #6
0
        /// <inheritdoc />
        public async Task <IPipelineProcess <Post> > Process(IPipelineProcess <Post> input, IMvcForumContext context)
        {
            // Refresh the context in each of these services
            _voteService.RefreshContext(context);
            _membershipUserPointsService.RefreshContext(context);
            _uploadedFileService.RefreshContext(context);
            _favouriteService.RefreshContext(context);
            _postEditService.RefreshContext(context);
            _roleService.RefreshContext(context);
            _localizationService.RefreshContext(context);

            try
            {
                // Get the Current user from ExtendedData
                var username     = input.ExtendedData[Constants.ExtendedDataKeys.Username] as string;
                var loggedOnUser = await context.MembershipUser.FirstOrDefaultAsync(x => x.UserName == username);

                var loggedOnUsersRole = loggedOnUser.GetRole(_roleService);
                var permissions       = _roleService.GetPermissions(input.EntityToProcess.Topic.Category, loggedOnUsersRole);

                if (input.EntityToProcess.User.Id == loggedOnUser.Id ||
                    permissions[ForumConfiguration.Instance.PermissionDeletePosts].IsTicked)
                {
                    // Get the topic
                    var topic = input.EntityToProcess.Topic;

                    var votes = _voteService.GetVotesByPost(input.EntityToProcess.Id);

                    #region Deleting Points

                    // Remove the points the user got for this post
                    await _membershipUserPointsService.Delete(input.EntityToProcess.User, PointsFor.Post, input.EntityToProcess.Id);

                    // Also get all the votes and delete anything to do with those
                    foreach (var postVote in votes)
                    {
                        await _membershipUserPointsService.Delete(PointsFor.Vote, postVote.Id);
                    }

                    // Also the mark as solution
                    await _membershipUserPointsService.Delete(PointsFor.Solution, input.EntityToProcess.Id);

                    #endregion

                    await context.SaveChangesAsync();

                    #region Deleting Votes

                    var votesToDelete = new List <Vote>();
                    votesToDelete.AddRange(votes);
                    foreach (var vote in votesToDelete)
                    {
                        input.EntityToProcess.Votes.Remove(vote);
                        _voteService.Delete(vote);
                    }
                    input.EntityToProcess.Votes.Clear();

                    #endregion

                    #region Files

                    // Clear files attached to post
                    var filesToDelete = new List <UploadedFile>();
                    filesToDelete.AddRange(input.EntityToProcess.Files);
                    foreach (var uploadedFile in filesToDelete)
                    {
                        // store the file path as we'll need it to delete on the file system
                        var filePath = uploadedFile.FilePath;

                        input.EntityToProcess.Files.Remove(uploadedFile);
                        _uploadedFileService.Delete(uploadedFile);

                        // And finally delete from the file system
                        if (!string.IsNullOrWhiteSpace(filePath))
                        {
                            var mapped = HostingEnvironment.MapPath(filePath);
                            if (mapped != null)
                            {
                                File.Delete(mapped);
                            }
                        }
                    }
                    input.EntityToProcess.Files.Clear();

                    #endregion

                    #region Favourites

                    var postFavourites = new List <Favourite>();
                    postFavourites.AddRange(input.EntityToProcess.Favourites);
                    foreach (var postFavourite in postFavourites)
                    {
                        input.EntityToProcess.Favourites.Remove(postFavourite);
                        _favouriteService.Delete(postFavourite);
                    }
                    input.EntityToProcess.Favourites.Clear();

                    #endregion

                    #region Post Edits

                    var postEdits = new List <PostEdit>();
                    postEdits.AddRange(input.EntityToProcess.PostEdits);
                    foreach (var postEdit in postEdits)
                    {
                        input.EntityToProcess.PostEdits.Remove(postEdit);
                        _postEditService.Delete(postEdit);
                    }
                    input.EntityToProcess.PostEdits.Clear();

                    #endregion

                    await context.SaveChangesAsync();

                    // Before we delete the post, we need to check if this is the last post in the topic
                    // and if so update the topic

                    if (input.ExtendedData.ContainsKey(Constants.ExtendedDataKeys.IgnoreLastPost))
                    {
                        var ignoreLastPost = input.ExtendedData[Constants.ExtendedDataKeys.IgnoreLastPost] as bool?;
                        if (ignoreLastPost == false)
                        {
                            var lastPost = topic.Posts.OrderByDescending(x => x.DateCreated).FirstOrDefault();

                            if (lastPost != null && lastPost.Id == input.EntityToProcess.Id)
                            {
                                // Get the new last post and update the topic
                                topic.LastPost = topic.Posts.Where(x => x.Id != input.EntityToProcess.Id).OrderByDescending(x => x.DateCreated).FirstOrDefault();
                            }

                            if (topic.Solved && input.EntityToProcess.IsSolution)
                            {
                                topic.Solved = false;
                            }

                            // Save the topic
                            await context.SaveChangesAsync();
                        }
                    }

                    // Remove from the topic
                    topic.Posts.Remove(input.EntityToProcess);

                    // now delete the post
                    context.Post.Remove(input.EntityToProcess);

                    // Save changes
                    await context.SaveChangesAsync();
                }
                else
                {
                    input.AddError(_localizationService.GetResourceString("Errors.NoPermission"));
                }
            }
            catch (System.Exception ex)
            {
                input.AddError(ex.Message);
                _loggingService.Error(ex);
            }

            return(input);
        }
예제 #7
0
        /// <inheritdoc />
        public async Task <IPipelineProcess <Topic> > Process(IPipelineProcess <Topic> input, IMvcForumContext context)
        {
            _favouriteService.RefreshContext(context);
            _pollService.RefreshContext(context);
            _postService.RefreshContext(context);
            _notificationService.RefreshContext(context);

            try
            {
                // Remove all notifications on this topic too
                if (input.EntityToProcess.TopicNotifications != null)
                {
                    var notificationsToDelete = new List <TopicNotification>();
                    notificationsToDelete.AddRange(input.EntityToProcess.TopicNotifications);
                    foreach (var topicNotification in notificationsToDelete)
                    {
                        input.EntityToProcess.TopicNotifications.Remove(topicNotification);
                        _notificationService.Delete(topicNotification);
                    }

                    // Final Clear
                    input.EntityToProcess.TopicNotifications.Clear();
                }

                // Remove all favourites on this topic too
                if (input.EntityToProcess.Favourites != null)
                {
                    var toDelete = new List <Favourite>();
                    toDelete.AddRange(input.EntityToProcess.Favourites);
                    foreach (var entity in toDelete)
                    {
                        input.EntityToProcess.Favourites.Remove(entity);
                        _favouriteService.Delete(entity);
                    }

                    // Final Clear
                    input.EntityToProcess.Favourites.Clear();
                }

                // Poll
                if (input.EntityToProcess.Poll != null)
                {
                    var pollToDelete = input.EntityToProcess.Poll;

                    // Final Clear
                    input.EntityToProcess.Poll = null;

                    // Delete the poll
                    _pollService.Delete(pollToDelete);
                }

                // First thing - Set the last post as null and clear tags
                //input.EntityToProcess.Tags.Clear();
                input.EntityToProcess.Tags = null;

                // Save here to clear the last post
                await context.SaveChangesAsync();

                // Loop through all the posts and clear the associated entities
                // then delete the posts
                if (input.EntityToProcess.Posts != null)
                {
                    var postsToDelete = new List <Post>();
                    postsToDelete.AddRange(input.EntityToProcess.Posts);

                    foreach (var post in postsToDelete)
                    {
                        // Posts should only be deleted from this method as it clears
                        // associated data
                        var postDeleteResult = await _postService.Delete(post, true);

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

                    input.EntityToProcess.Posts.Clear();

                    // Clear last post
                    input.EntityToProcess.LastPost = null;
                }

                // Finally delete the topic
                context.Topic.Remove(input.EntityToProcess);

                // Save here to clear the last post
                await context.SaveChangesAsync();

                // Clear some caches
                _cacheService.ClearStartsWith("HotTopics");
            }
            catch (Exception ex)
            {
                input.AddError(ex.Message);
                _loggingService.Error(ex);
            }

            return(input);
        }