public async Task Update(string commentId, string userId, CreateCommentRequestModel model)
        {
            await new CreateOrUpdateCommentValidator().ValidateRequestModelAndThrow(model);

            Comment registeredComment;
            string  commentRegisteredOnCacheJson = await _cacheDatabase.Get(commentId);

            if (commentRegisteredOnCacheJson != null)
            {
                registeredComment = _jsonUtils.Deserialize <Comment>(commentRegisteredOnCacheJson);
            }
            else
            {
                registeredComment = await _commentRepository.GetByIdIncludingUser(Guid.Parse(commentId));

                if (registeredComment == null)
                {
                    throw new ResourceNotFoundException("comment not found.");
                }
            }

            ThrowIfAuthenticatedUserNotIsCommentCreator(registeredComment, Guid.Parse(userId));
            registeredComment.UpdateText(model.Text);
            _commentRepository.Update(registeredComment);
            await _commentRepository.Save();

            await _cacheDatabase.Remove(commentId);
        }
        public async Task <ActionResult> Create(CreateCommentRequestModel model)
        {
            var userId = this.User.GetId();

            var commentId = await this.commentsService
                            .CreateAsync(model.Content, model.AdvertisementId, userId);

            return(Created(nameof(this.Create), commentId));
        }
        public async Task <ResultModel <string> > CreateCommentAsync(CreateCommentRequestModel model, string userId)
        {
            var user = await this.dbContext
                       .Users
                       .Where(u => u.Id == userId && !u.IsDeleted)
                       .FirstOrDefaultAsync();

            if (user == null)
            {
                return(new ResultModel <string>
                {
                    Errors = { UserErrors.InvalidUserId }
                });
            }

            var story = await this.dbContext
                        .Stories
                        .Where(s => s.Id == model.StoryId && !s.IsDeleted)
                        .FirstOrDefaultAsync();

            if (story == null)
            {
                return(new ResultModel <string>
                {
                    Errors = { StoryErrors.NotFoundOrDeletedStory }
                });
            }
            var isBanned = await this.userService.IsBanned(userId);

            if (isBanned)
            {
                return(new ResultModel <string>
                {
                    Errors = { CommentErrors.BannedUserCreateComment }
                });
            }

            var comment = new Comment
            {
                Content  = model.Content,
                StoryId  = model.StoryId,
                UserId   = userId,
                Likes    = 0,
                Dislikes = 0,
            };

            await this.dbContext.AddAsync(comment);

            await this.dbContext.SaveChangesAsync();

            return(new ResultModel <string>
            {
                Result = comment.Id,
                Success = true,
            });
        }
        public async Task <ActionResult <CommentListingModel> > CreateComment(
            [FromBody] CreateCommentRequestModel inputModel)
        {
            var commentId = await this.commentsService.CreateAsync(
                inputModel.ArticleId,
                inputModel.ParentId,
                inputModel.Content,
                this.User.GetId());

            return(await this.commentsService.GetByIdAsync <CommentListingModel>(commentId));
        }
        public async Task <ActionResult> Create(CreateCommentRequestModel model)
        {
            var loggedUser = this.User.GetId();
            var result     = await this.commentService.CreateCommentAsync(model, loggedUser);

            if (!result.Success)
            {
                return(BadRequest(result.Errors));
            }

            return(Created(nameof(Create), result.Result));
        }
Beispiel #6
0
        public async Task <IActionResult> Update(string commentId, CreateCommentRequestModel model)
        {
            try
            {
                await _commentService.Update(commentId, this.GetUserIdFromToken(), model);

                return(Ok());
            }
            catch (Exception exception)
            {
                return(this.HandleExceptionToUserAndLogIfExceptionIsUnexpected(exception));
            }
        }
        public async Task ShouldThrowResourceNotFoundExceptionOnCreateCommentWithNotExistsReview()
        {
            _cacheDatabaseMock.Get(Arg.Any <string>()).Returns(null as string);
            _reviewRepositoryMock.AlreadyExists(Arg.Any <Guid>()).Returns(false);
            CreateCommentRequestModel requestModel = new CreateCommentRequestModel()
            {
                Text = "TEXT"
            };

            Exception exception = await Record.ExceptionAsync(() => _commentService.Create(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), requestModel));

            Assert.IsType <ResourceNotFoundException>(exception);
        }
Beispiel #8
0
        public async Task <IActionResult> Create(string reviewId, CreateCommentRequestModel model)
        {
            try
            {
                IdResponseModel responseModel = await _commentService.Create(reviewId, this.GetUserIdFromToken(), model);

                return(CreatedAtRoute("", model, responseModel));
            }
            catch (Exception exception)
            {
                return(this.HandleExceptionToUserAndLogIfExceptionIsUnexpected(exception));
            }
        }
Beispiel #9
0
        public IHttpActionResult Post(CreateCommentRequestModel model)
        {
            var userId = this.User.Identity.GetUserId();

            var result = this.comments
                         .CreateComment(model.RealEstateId, model.Content, userId);

            var resultingComment = this.comments.GetCommentById(result.Id)
                                   .ProjectTo <CommentsResponseModel>()
                                   .FirstOrDefault();

            return(this.Ok(resultingComment));
        }
        public async Task ShouldThrowForbiddenExceptionOnUpdate()
        {
            CreateCommentRequestModel requestModel = new CreateCommentRequestModel()
            {
                Text = "TEXT"
            };

            _cacheDatabaseMock.Get(Arg.Any <string>()).Returns(null as string);
            _commentRepositoryMock.GetByIdIncludingUser(Arg.Any <Guid>()).Returns(new Comment("TEXT", Guid.NewGuid(), Guid.NewGuid()));

            Exception exception = await Record.ExceptionAsync(() => _commentService.Update(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), requestModel));

            Assert.IsType <ForbiddenException>(exception);
        }
        public async Task ShouldCreateComment()
        {
            _cacheDatabaseMock.Get(Arg.Any <string>()).Returns(null as string);
            _reviewRepositoryMock.AlreadyExists(Arg.Any <Guid>()).Returns(true);
            CreateCommentRequestModel requestModel = new CreateCommentRequestModel()
            {
                Text = "TEXT"
            };

            Exception exception = await Record.ExceptionAsync(() => _commentService.Create(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), requestModel));

            Assert.Null(exception);
            await _commentRepositoryMock.Received(1).Create(Arg.Any <Comment>());

            await _commentRepositoryMock.Received(1).Save();
        }
        public async Task ShouldGetAllComments()
        {
            User insertedUser = await InsertUserOnDatabase();

            Review insertedReview = await InsertReviewOnDatabase(insertedUser.Id);

            _httpClient.InsertAuthorizationTokenOnRequestHeader(_authorizationTokenHelper.CreateToken(insertedUser.Id));

            CreateCommentRequestModel requestModel = new CreateCommentRequestModel()
            {
                Text = "TEXT"
            };
            HttpResponseMessage response = await _httpClient.GetAsync($"../reviews/{insertedReview.Id.ToString()}/comments");

            Assert.Equal((int)HttpStatusCode.OK, (int)response.StatusCode);
        }
Beispiel #13
0
        public IHttpActionResult Post(CreateCommentRequestModel model)
        {
            if (realEstatesServices.GetById(model.RealEstateId).FirstOrDefault() == null)
            {
                return(this.NotFound());
            }

            int commentId = this.commentServices.Create(
                model.RealEstateId,
                model.Content,
                this.User.Identity.GetUserId());

            var response = this.commentServices.GetById(commentId)
                           .ProjectTo <CommentResponseModel>()
                           .FirstOrDefault();

            return(this.Created("", response));
        }
        public async Task <IdResponseModel> Create(string reviewId, string userId, CreateCommentRequestModel model)
        {
            await new CreateOrUpdateCommentValidator().ValidateRequestModelAndThrow(model);

            Guid reviewIdGuid = Guid.Parse(reviewId);

            await ThrowIfReviewNotExists(reviewIdGuid);

            Comment comment = new Comment(model.Text, Guid.Parse(userId), reviewIdGuid);
            await _commentRepository.Create(comment);

            await _commentRepository.Save();

            return(new IdResponseModel()
            {
                Id = comment.Id
            });
        }
        public async Task ShouldUpdateCommentFromDatabase()
        {
            Guid userId = Guid.NewGuid();
            CreateCommentRequestModel requestModel = new CreateCommentRequestModel()
            {
                Text = "TEXT"
            };

            _cacheDatabaseMock.Get(Arg.Any <string>()).Returns(null as string);
            _commentRepositoryMock.GetByIdIncludingUser(Arg.Any <Guid>()).Returns(new Comment("TEXT", userId, Guid.NewGuid()));

            Exception exception = await Record.ExceptionAsync(() => _commentService.Update(Guid.NewGuid().ToString(), userId.ToString(), requestModel));

            Assert.Null(exception);
            _commentRepositoryMock.Received(1).Update(Arg.Any <Comment>());
            await _commentRepositoryMock.Received(1).Save();

            await _cacheDatabaseMock.Received(1).Remove(Arg.Any <string>());
        }
        public async Task <IActionResult> CreateComment(CreateCommentRequestModel createCommentRequest)
        {
            var funfic = _appDbContext.Funfics.FirstOrDefault(f => f.Id == createCommentRequest.Id);
            var user   = await _userManager.FindByNameAsync(User.Identity.Name);

            if (funfic == null)
            {
                return(StatusCode(404, "No such funfic"));
            }

            var date = DateTime.Now;

            await _appDbContext.Comments.AddAsync(new Comment
            {
                FunficId = createCommentRequest.Id,
                UserId   = user.Id,
                Text     = createCommentRequest.Text,
                Date     = date
            });

            try
            {
                _appDbContext.SaveChanges();
            }
            catch
            {
                return(StatusCode(409));
            }

            return(StatusCode(200, new
            {
                author = user.UserName,
                text = createCommentRequest.Text,
                createdAt = date
            }));
        }
        public IHttpActionResult Post(CreateCommentRequestModel model)
        {
            string username = this.User.Identity.Name;
            string userId = this.User.Identity.GetUserId();

            var createdComment = this.comments.CreateComment(model.RealEstateId, model.Content, username, userId);

            return this.Created
                (
                    string.Format("api/Comment/{0}", createdComment.Id),
                    Mapper.Map<CreatedCommentResponseModel>(createdComment)
                );
        }
        public IHttpActionResult Post(CreateCommentRequestModel model)
        {
            if (realEstatesServices.GetById(model.RealEstateId).FirstOrDefault() == null)
            {
                return this.NotFound();
            }

            int commentId = this.commentServices.Create(
                model.RealEstateId,
                model.Content,
                this.User.Identity.GetUserId());

            var response = this.commentServices.GetById(commentId)
                .ProjectTo<CommentResponseModel>()
                .FirstOrDefault();

            return this.Created("", response);
        }
Beispiel #19
0
        public async Task <ActionResult> Create(CreateCommentRequestModel model)
        {
            var commentId = await this.commentService.Create(model.Content, this.UserId, model.ProjectId);

            return(Created(nameof(this.Create), commentId));
        }