public FubuContinuation Post(AddCommentRequest request)
{
request.Comment.Video = new Video(){Id = request.VideoId};
_repository.Save(request.Comment);
return FubuContinuation.RedirectTo(new GetVideoRequest{Id = request.VideoId});
}
public static Comment mapFormAddCommentRequestToComment(AddCommentRequest commentRequest)
{
Comment result = new Comment();
result.Message = commentRequest.Message;
return(result);
}
public AddCommentResponse AddComment(AddCommentRequest addCommentRequest)
{
return(new AddCommentResponse
{
Comment = _addCommentsModule.AddComment(addCommentRequest)
});
}
public QuestionResponse AddComment([FromBody] AddCommentRequest request)
{
var userId = User.Claims
.Where <Claim>(c => c.Type == ClaimTypes.NameIdentifier)
.Select(s => s.Value).First();
if (userId == null)
{
return(new QuestionResponse {
Data = null, Message = "اطلاعات کاربری یافت نشد"
});
}
var comment = new Comment
{
UserId = userId,
QuestionId = request.QuestionId,
Description = request.Description,
CreateTime = DateTime.Now
};
context.Comments.Add(comment);
context.SaveChanges();
return(new QuestionResponse {
});
}
public async Task <CommentViewModel> AddComment(AddCommentRequest request)
{
var currentUser = Feature.CurrentUser(httpContextAccessor, userRepository);
var currentPost = await postRepository.GetByIdAsync(ObjectId.Parse(request.PostId));
if (currentPost is { Status : ItemStatus.Active })
public bool AddComment(int eventId, string comment)
{
try
{
if (string.IsNullOrEmpty(comment))
{
return(false);
}
int userId = (int)Session["UserId"];
AddCommentRequest request = new AddCommentRequest()
{
UserId = userId,
EventId = eventId,
Comment = comment
};
EventConnection conn = new EventConnection();
conn.AddComment(request);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public IActionResult AddComment(NewCommentModel model)
{
if (ModelState.IsValid)
{
var coach = GetCoach();
var request = new AddCommentRequest {
ClubId = club.Guid,
Comment = model.Comment,
FeedbackId = model.FeedbackId,
PostedBy = $"{coach.FirstName} {coach.LastName}",
PosterId = coach.Guid,
Membership = Membership.Coach
};
feedbackRepository.AddComment(request);
}
var feedbackChain = feedbackQuery.GetFeedbackChain(
new FeedbackChainRequest {
ClubId = club.Guid, FeedbackId = model.FeedbackId
}
);
var viewModel = new FeedbackChainModel {
FeedbackChain = feedbackChain, IsMember = GetCoach() != null
};
return(View("FeedbackChain", viewModel));
}
public Response AddComment(AddCommentRequest request)
{
var sql = $@"INSERT INTO FeedbackComments(FeedbackId, CreatedOn, PostedBy, PosterId, Comments, MembershipId)
VALUES(
(SELECT FeedbackId FROM Feedback WHERE Guid = @FeedbackGuid),
GetDate(),
@PostedBy,
{(request.Membership == Core.Membership.Coach ? "(SELECT CoachId FROM Coaches WHERE Guid = @PosterGuid)" : "(SELECT PlayerId FROM Players WHERE Guid = @PosterGuid)")},
@Comments,
@MembershipId
);";
var parameters = new DynamicParameters();
parameters.Add("@FeedbackGuid", request.FeedbackId);
parameters.Add("@PostedBy", request.PostedBy);
parameters.Add("@PosterGuid", request.PosterId);
parameters.Add("@Comments", request.Comment);
parameters.Add("@MembershipId", request.Membership);
using (var connection = connectionFactory.Connect())
{
connection.Open();
connection.Execute(sql, parameters);
}
return(Response.CreateSuccessResponse());
}
private void ValidateComment(AddCommentRequest request)
{
_validation.NotValidId(request.UserId, $"{nameof(request.UserId)}");
_validation.NotValidId(request.CourseId, $"{nameof(request.CourseId)}");
_validation.NotValidField(request.Comment, 500, $"{nameof(request.Comment)}");
}
public async Task AddCommentTest()
{
var comment = new AddCommentRequest(0, "mikke", "Ei vttu, et o tosissas?!");
await _service.AddComment(comment);
Assert.AreEqual(1, _blog.Comments.Count);
}
public void PostComment(AddCommentRequest addComment, ICommentsDataBaseSettings settings)
{
ConnectToDB(settings);
addComment.ToUserID = addComment.ToUserID.Length > 0 ? addComment.ToUserID : String.Empty;
addComment.ToUserName = addComment.ToUserName.Length > 0 ? addComment.ToUserName : String.Empty;
AddComment comment = new AddComment(addComment.ParentID, addComment.FromUserID, addComment.ToUserID,
addComment.FromUserName, addComment.ToUserName, addComment.Comment, addComment.PostID, addComment.RootID, DateTime.Parse(addComment.CreatedDate));
_mongoDatabase.GetCollection <AddComment>("messagethreads").InsertOne(comment);
}
public async Task <IActionResult> AddComment([FromBody] AddCommentRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _forumService.AddComment(request);
return(Ok());
}
public async Task AddComment(AddCommentRequest request)
{
DateTime now = DateTime.Now;
User user = _userRepository.GetUserByName(request.Author);
string avatar = user.UserAvatar;
Comment comment = new Comment {
PostId = request.PostId, Body = request.Body, Author = user.Login, AuthorAvatar = avatar, CreateDate = now
};
await _repository.AddComment(comment);
}
private void btn_comment_Click(object sender, RoutedEventArgs e)
{
if (!edit_content.Text.Equals(""))
{
AddCommentRequest request = new AddCommentRequest(calendarId, edit_content.Text);
RestfulClient <String> detailRestful = new RestfulClient <String>(request);
detailRestful.GetResponse();
initCommentViewAsync();
}
}
public async Task AddComment(AddCommentRequest request)
{
var blog = await _repository.Find(request.BlogId);
var comment = new Comment(request.Author, request.Comment);
blog.AddComment(comment);
await _repository.Update(blog);
}
public FubuContinuation Post(AddCommentRequest request)
{
var video = _repository.Get(request.VideoId);
video.AddComment(request.Comment);
_repository.Save(video);
return FubuContinuation.RedirectTo(new GetVideoRequest{Id = request.VideoId});
}
static async Task Main(string[] args)
{
var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Service.ServiceClient(channel);
var req = new AddCommentRequest {
Postid = 1, Text = "un tesxt"
};
var res = await client.AddCommentAsync(req);
Console.WriteLine(res.BResult);
}
/*
* public static Subtask AddSubtask(AddSubtaskRequest request)
* {
* var temp = subtaskDaoManager.Find(request.taskId, request.subTaskId);
* if (temp != null) return temp;
*
* var result = subtaskDaoManager.SaveOrUpdate(new Subtask()
* {
* Id = 0,
* TaskId = request.taskId,
* SubtaskId = request.subTaskId,
* Registration = DateTime.Now
* });
* return result;
* }
*
* public static bool DeleteSubtask(AddSubtaskRequest request)
* {
* var temp = subtaskDaoManager.Find(request.taskId, request.subTaskId);
* if (temp == null) return true;
*
* subtaskDaoManager.Delete(temp);
*
* return true;
* }*/
public static Comment AddComment(AddCommentRequest request, long userId)
{
return(commentDaoManager.Save(new Comment()
{
Id = 0,
UserId = userId,
TaskId = request.taskId,
Text = request.text,
LastUpdate = DateTime.Now
}));
}
public async Task <ActionResult> AddComment(AddCommentRequest comment)
{
await this.blogCommandService.CreatComment(new AddCommentModel
{
ArticleId = comment.ArticleId,
Body = comment.Body,
AuthorId = this.User.Identity.GetUserId()
});
return(RedirectToAction("Article", new { articleId = comment.ArticleId }));
}
public bool AddComment(AddCommentRequest request)
{
var userName = HttpContext.Session.GetString("username");
var userId = _userService.GetUserIdByUserName(userName);
var model = AutoMapper.Mapper.Map <CommentModel>(request);
model.CommentTime = DateTime.Now.Date;
model.UserId = userId;
_articleService.UpdateArticleCommentCount(request.ArticleId);
return(_commentService.AddComment(model));
}
public async Task AddComment(AddCommentRequest request)
{
var response = await this.requestPipelineMediator.Handle <AddCommentRequest, OperationResult <CommentDTO> >(request);
var payload = new { comment = response.Value, groupId = request.GroupId };
await this.Clients.Caller.SendAsync("CommentAdded", payload);
payload.comment.IsOwner = false;
await this.Clients.OthersInGroup(request.RetroId.ToString())
.SendAsync("CommentAdded", payload);
}
public CommentDto AddComment(AddCommentRequest addCommentRequest)
{
var comment = _newCommentMapper.Map(addCommentRequest);
_commentRepository.AddComment(comment);
var user = _userRepository.GetUserById(comment.User.Id);
comment.User = user;
return(_masterCommentMapper.Map(comment));
}
public bool AddComment(AddCommentRequest request)
{
string sql = @"UPDATE enrolls SET Comment = @Comment WHERE UserId = @UserId AND CourseId = @CourseId";
int result;
var parameters = new { request.Comment, request.UserId, request.CourseId };
using (var con = GetSqlConnection())
{
result = con.Execute(sql, parameters);
}
return(result == 1);
}
public static Comment FromRequest(AddCommentRequest request, string UserId)
{
return(new Comment()
{
AuthorId = UserId,
PostId = request.PostId,
Content = request.Content,
Status = ItemStatus.Active,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now,
Image = request.Image
});
}
public async Task <IActionResult> AddAsync([FromBody] AddCommentRequest addCommentRequest)
{
var response = await _commentService.AddAsync(addCommentRequest);
if (response.Success)
{
return(Ok());
}
else
{
return(BadRequest(response.Message));
}
}
public override async Task <CommentReply> AddComment(AddCommentRequest request, ServerCallContext context)
{
var userId = int.Parse(context.GetHttpContext().User.Identity.Name);
var comment = new Comment
{
IdiomId = request.IdiomId,
Text = request.Text,
UserId = userId
};
await _actions.AddComment(comment);
return(await _actions.GetCommentReply(comment.CommentId, userId));
}
public HttpResponseMessage AddComment([FromBody] AddCommentRequest request)
{
var response = _service.Comment(request);
if (response)
{
return(Request.CreateResponse <bool>(HttpStatusCode.OK, response));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Cannot add comment,something went wrong.."));
}
}
public void AddComment(AddCommentRequest request)
{
ConnectionHelper conn = new ConnectionHelper();
SqlParameter[] sqlParams = new SqlParameter[]
{
new SqlParameter("@UserId", request.UserId),
new SqlParameter("@EventId", request.EventId),
new SqlParameter("@Comment", request.Comment)
};
conn.ExecuteNonQuery("AddComment", sqlParams);
}
public void AddComment()
{
var request = new AddCommentRequest
{
UserId = 1,
CourseId = 1,
Comment = "Excellent course!!"
};
var res = service.AddComment(request);
Xunit.Assert.True(res);
}
public IActionResult AddComment(AddCommentRequest request)
{
var user = _userService.Current;
if (user == null)
{
return(Forbid());
}
_commentService.Add(user, request.Category, request.Content);
return(Ok());
}
public IActionResult AddComment([FromBody] AddCommentRequest request)
{
try
{
var post = _postRepository.FindById(request.PostId);
if (post == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Post not found"
}));
}
var user = _userRepository.FindById(request.UserId);
if (post == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "User not found"
}));
}
var comment = new Comment
{
Context = request.Context,
UserId = request.UserId,
PostId = request.PostId,
TimeStamp = DateTime.UtcNow
};
var response = _commentServices.AddComment(comment);
if (response != "OK")
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Can not execute. Plz contact admin"
}));
}
return(Ok());
}
catch (Exception e)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = $"Server Error: {e.Message}"
}));
}
}
public void AddComment_ReceivesAddCommentRequest_ExpectsCommentModel()
{
var username = "******";
var title = "My Article 1";
var content = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
var thumbnail = new byte[] { 72, 101, 108, 108, 111 };
var article = new Article(
username,
title,
content,
thumbnail);
var comment = new Comment(3, username, "Blahblhablah");
var mockArticlesRepo = new Mock <IArticlesRepository>();
var mockCommentsRepo = new Mock <ICommentsRepository>();
mockCommentsRepo
.Setup(x => x.CreateAsync(It.IsAny <Comment>()))
.ReturnsAsync(comment);
var mockLogger = new Mock <ILogger <ArticlesService> >();
var mockValidationFactory = new Mock <IValidatorFactory>();
mockValidationFactory.Setup(x =>
x.GetValidator <AddCommentRequest>()).Returns(new AddCommentRequestValidator());
var mockContext = GetServerCallContext("AddComment");
var service = new ArticlesService(
mockLogger.Object,
mockArticlesRepo.Object,
mockCommentsRepo.Object,
mockValidationFactory.Object);
var request = new AddCommentRequest
{
ArticleId = 3,
Content = comment.Content,
User = comment.Username,
};
var result = service.AddComment(request, mockContext).Result;
Assert.Equal(result.ArticleId, request.ArticleId);
Assert.Equal(result.User, request.User);
Assert.Equal(result.Content, request.Content);
}
