public async Task <IActionResult> AddComment([FromRoute] Guid organizationId, [FromRoute] Guid contractId,
[FromBody] CommentInput input)
{
var result = await _commentService.CreateContractComment(_ao, contractId, input);
return(Ok(result));
}
// POST /Api/v1/LogBooks/33/Entries/1/Comments
public HttpResponseMessage Post([FromUri]int? logBookId, [FromUri]int? entryId, CommentInput commentInput)
{
var logBook = base.RavenSession.Load<LogBook>(logBookId);
if (logBook == null)
return NotFound();
if (logBook.IsOwnedBy(base.User.Identity.Name) == false)
return Forbidden();
var entry = logBook.GetEntries()
.SingleOrDefault(x => x.Id == entryId);
if (entry == null)
return NotFound();
var comment = new Comment<Entry>();
commentInput.MapToInstance(comment);
entry.AddComment(comment);
base.RavenSession.Store(logBook);
var commentView = comment.MapTo<LogBookView.CommentView>();
return Created(commentView);
}
public async Task <DiscussionDto> AddComment(CommentInput input)
{
var todo = _todoManager.GetTodo(input.TodoId);
var discussion = Discussion.CreateDiscussionMessage(input.Comment, todo);
var id = _todoManager.SendDiscussionMessage(discussion);
var message = _todoManager.GetMessage(id);
var model = message.MapTo <DiscussionDto>();
model.Day = message.CreationTime.Day;
model.Month = GetNameFromMonth(message.CreationTime.Month);
if (message.CreatorUserId == null)
{
return(model);
}
var member = await _userManager.GetUserByIdAsync((long)message.CreatorUserId);
var todoList = _todoManager.GetTodoListId(todo);
var projectId = _toDoListManager.GetProjectIdFromList(todoList);
var project = _projectManager.GetProject(projectId);
model.Member = member.MapTo <MemberDto>();
await _todoNotificationsService.SilentChatNotification(model, project);
return(model);
}
public async Task <IActionResult> AddComment([FromRoute] Guid organizationId, [FromRoute] Guid candidateId,
[FromBody] CommentInput input)
{
var result = await _commentService.CreateCandidateComment(_recruiter, candidateId, input);
return(Ok(result));
}
public async Task <IActionResult> AddComment([FromRoute] Guid organizationId, [FromRoute] Guid projectId,
[FromBody] CommentInput input)
{
var result = await _commentService.CreateProjectComment(_agencyOwner, projectId, input);
return(Ok(result));
}
private static string ParseImpl(PageInfo pageInfo, int pageNum, bool isAnonymous)
{
pageInfo.AddPageScriptsIfNotExists(PageInfo.Components.Vue);
pageInfo.AddPageScriptsIfNotExists(PageInfo.Components.JsCookie);
pageInfo.AddPageScriptsIfNotExists(PageInfo.Components.StlClient);
var commentInput = new CommentInput
{
ApiUrl = pageInfo.ApiUrl,
IsAnonymous = isAnonymous,
PageNum = pageNum,
ApiActionsAddUrl =
Controllers.Comments.ActionsAdd.GetUrl(pageInfo.ApiUrl, pageInfo.PublishmentSystemId, pageInfo.PageNodeId, pageInfo.PageContentId),
ApiActionsDeleteUrl =
Controllers.Comments.ActionsDelete.GetUrl(pageInfo.ApiUrl, pageInfo.PublishmentSystemId, pageInfo.PageNodeId, pageInfo.PageContentId),
ApiActionsGoodUrl =
Controllers.Comments.ActionsGood.GetUrl(pageInfo.ApiUrl, pageInfo.PublishmentSystemId, pageInfo.PageNodeId, pageInfo.PageContentId),
ApiGetUrl =
Controllers.Comments.Get.GetUrl(pageInfo.ApiUrl, pageInfo.PublishmentSystemId, pageInfo.PageNodeId, pageInfo.PageContentId),
ApiActionsLogoutUrl = Controllers.Users.ActionsLogout.GetUrl(pageInfo.ApiUrl),
HomeUrl = pageInfo.HomeUrl,
IsDelete = false
};
return(ControlUtils.GetControlRenderHtml(commentInput));
}
public TestBlankFormPage FillComment(string comment)
{
CustomTestContext.WriteLine($"Fill comment - '{comment}'");
CommentInput.SendKeys(comment);
return(this);
}
public ActionResult Create(CommentInput comment)
{
if (Request.IsAjaxRequest())
{
if (ModelState.IsValid)
{
var userId = CurrentUser.Id;
Comment newComment = Mapper.Map <Comment>(comment);
newComment.AuthorId = userId;
Data.Comments.Add(newComment);
CurrentUser.Points++;
Data.SaveChanges();
var commentModel = Mapper.Map <CommentInTicket>(newComment);
commentModel.Author = CurrentUser.UserName;
return(PartialView("_CommentInTicket", commentModel));
}
}
return(RedirectToAction("Details", "Home", new { id = comment.TicketId }));
}
public async Task <IActionResult> AddComment([FromRoute] Guid organizationId, [FromRoute] Guid leadId,
[FromBody] CommentInput input)
{
var result = await _commentService.CreateLeadComment(_marketer, leadId, input);
return(Ok(result));
}
public async Task <IActionResult> AddComment([FromRoute] Guid organizationId, [FromRoute] Guid storyId,
[FromBody] CommentInput input)
{
var result = await _commentService.CreateStoryComment(_accountManager, storyId, input);
return(Ok(result));
}
public Comment(CommentInput input)
{
Text = input.Text;
Author = (input.Author.Length < 1) ? _anonymousUsername : input.Author;
PostId = input.PostId;
Time = DateTime.Now;
}
public ValidationStateDictionary ValidateCommentInput(CommentInput commentInput)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(CommentInput), validator.Validate(commentInput));
return(validationState);
}
public async Task <bool> CreateStoryComment(IOrganizationProjectManager projectManager, Guid storyId,
CommentInput input)
{
var story = await _storyRepository.Queryable().ForOrganizationProjectManager(projectManager)
.FindById(storyId).FirstAsync();
return(await CreateStoryComment(story, input, projectManager.OrganizationId));
}
public async Task <ActionResult <Comment> > Post(CommentInput input)
{
var comment = new Comment(input);
_repo.AddAsync(comment);
await _repo.SaveAsync();
return(comment);
}
public async Task <bool> CreateCandidateComment(IOrganizationRecruiter recruiter, Guid candidateId,
CommentInput input)
{
var candidate = await _candidateRepository.Queryable().ForOrganizationRecruiter(recruiter)
.Where(x => x.Id == candidateId)
.FirstAsync();
return(await CreateCandidateComment(candidate, input, recruiter.OrganizationId));
}
public IActionResult CommentInput()
{
CommentInput model = new CommentInput
{
FavoriteFood = null
};
return(View(model));
}
public async Task <IActionResult> CreateComment(
[FromRoute] Guid organizationId,
[FromRoute] int number,
[FromBody] CommentInput input)
{
var result = await _commentService.CreateAccountComment(_customer, number, input);
return(Ok(result));
}
public void UpdateLikes(CommentInput entity)
{
object value = Expressions.UnsafeLiteral($"Likes + {entity.Likes}");
this.DbHelper.Execute(this.Table, proc =>
proc.AsUpdate(new[] { "Likes" }, new[] { value })
.Where("Id", entity.Id)
);
}
public async Task <IActionResult> AddComment([FromRoute] Guid organizationId, [FromRoute] Guid leadId,
[FromBody] CommentInput input)
{
var ao = _agencyOwner.Value;
var result = await _commentService.CreateLeadComment(ao, leadId, input);
return(Ok(result));
}
public void Delete(CommentInput entity)
{
entity.IsDeleted = 1;
this.DbHelper.Execute(this.Table, proc =>
proc.AsUpdate(entity, "IsDeleted", "Modifier", "ModifyTime")
.Where("Id", entity.Id)
);
}
public async Task <bool> CreateLeadComment(IOrganizationAccountManager accountManager, Guid leadId,
CommentInput input)
{
var lead = await _leadRepository.Queryable().ForOrganizationAccountManager(accountManager)
.Where(x => x.Id == leadId)
.FirstAsync();
return(await CreateLeadComment(lead, input, accountManager.OrganizationId));
}
public async Task <bool> CreateAccountComment(IOrganizationAccountManager accountManager, int accountId,
CommentInput input)
{
var account = await _accountRepository.Queryable().ForOrganizationAccountManager(accountManager)
.Where(x => x.Number == accountId)
.FirstAsync();
return(await CreateAccountComment(account, input, accountManager.OrganizationId));
}
private async Task <bool> CreateStoryComment(Story s, CommentInput input, Guid organizationId)
{
var comment = new Comment()
{
StoryId = s.Id,
OrganizationId = organizationId
};
return(await CreateComment(comment, input));
}
private async Task <bool> CreateCandidateComment(Candidate candidate, CommentInput input, Guid organizationId)
{
var comment = new Comment()
{
CandidateId = candidate.Id,
OrganizationId = organizationId
};
return(await CreateComment(comment, input));
}
private async Task <bool> CreateLeadComment(Lead lead, CommentInput input, Guid organizationId)
{
var comment = new Comment()
{
LeadId = lead.Id,
OrganizationId = organizationId
};
return(await CreateComment(comment, input));
}
private async Task <bool> CreateContractComment(Contract c, CommentInput input, Guid organizationId)
{
var comment = new Comment()
{
ContractId = c.Id,
OrganizationId = organizationId
};
return(await CreateComment(comment, input));
}
public override async Task <Int32Value> AddComment(CommentInput request, ServerCallContext context)
{
var commentId = await _dataAccess.AddCommentDataAccessAsync(request.TaskId,
request.SenderId,
request.Message);
return(new Int32Value {
Value = commentId
});
}
private async Task ValidateCaptcha(CommentInput input, Commenter commenter)
{
if (Request.IsAuthenticated ||
(commenter != null && commenter.IsTrustedCommenter == true))
{
return;
}
await Recaptcha2Helper.Validate(ModelState).ConfigureAwait(false);
}
private async Task <bool> CreateProjectComment(Project p, CommentInput input, Guid organizationId)
{
var comment = new Comment()
{
ProjectId = p.Id,
OrganizationId = organizationId
};
return(await CreateComment(comment, input));
}
private void ReplyButton_Click(object sender, RoutedEventArgs e)
{
if (sender is HyperlinkButton button)
{
if (button.Tag is WordPressPCL.Models.CommentThreaded comment)
{
ViewModel.CommentReply = comment;
CommentInput.Focus(FocusState.Pointer);
}
}
}
public static PostComment ToComment(this CommentInput commentInput, User creatorAuthenticated, long creatorIP, string creatorUserAgent, Language language, string slug, EntityState state)
{
if (creatorAuthenticated != null)
{
return(new PostComment(commentInput.Body, creatorAuthenticated.ID, null, null, null, null, creatorIP, creatorUserAgent, language, new PostCommentSmall(commentInput.ParentID), null, slug, state));
}
else
{
return(new PostComment(commentInput.Body, Guid.Empty, commentInput.Creator.Name, commentInput.Creator.Email, commentInput.Creator.EmailHash, commentInput.Creator.Url, creatorIP, creatorUserAgent, language, new PostCommentSmall(commentInput.ParentID), null, slug, state));
}
}
