示例#1
0
        public async Task <IActionResult> RemovePoll([FromRoute] string pollId, [FromQuery] string secretCode)
        {
            if (!Guid.TryParse(pollId, out var id))
            {
                ModelState.TryAddModelError("ParsingError", $"Poll ID {pollId} is not valid.");
                return(BadRequest(ModelState));
            }

            var poll = await _pollRepository.GetById(id);

            if (poll == null)
            {
                return(NotFound());
            }

            var isAuthorized = _pollService.IsCodeValid(secretCode, poll.SecretCodeHash);

            if (!isAuthorized)
            {
                return(Unauthorized());
            }

            await _pollRepository.Delete(poll);

            return(Ok());
        }
示例#2
0
        public async Task <IActionResult> DeleteConfirmed(int pollid)
        {
            Poll p = _pollRepo.GetPoll(pollid);
            await _pollRepo.Delete(p.PollId);

            return(RedirectToAction("PollDetails"));
        }
示例#3
0
        public async Task <IActionResult> DeleteConfirmed(int pollid)
        {
            Poll p = _pollRepo.GetPoll(pollid);

            if (p.UserId != context.ApplicationUsers.Single(au => au.Email == User.Identity.Name).Id)
            {
                return(NotFound());
            }
            await _pollRepo.Delete(p.PollId);

            return(RedirectToAction("MyPolls"));
        }
示例#4
0
 public bool DeletePoll(int id)
 {
     try
     {
         _pollRepository.Delete(id);
     }
     catch (Exception)
     {
         return(false);
     }
     return(true);
 }
示例#5
0
        public ActionResult DeleteConfirmed(int Id)
        {
            var question = _pollRepository.Find(Id);

            if (question != null)
            {
                _pollRepository.Delete(Id);
                _pollRepository.Save();
                return(Json(new { success = true, questionid = Id }));
            }
            else
            {
                return(Json(new { success = false, content = "Không tồn tại bình chọn này !" }));
            }
        }
示例#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();
            }
        }
示例#7
0
 public void Delete(Poll item)
 {
     _pollRepository.Delete(item);
 }
示例#8
0
 public void Delete(int id)
 {
     _pollRepository.Delete(id);
 }