public async Task IssueConversationTest()
{
using var helper = await new SimpleTestHelperBuilderMessage().Build();
var newItem = new IssueConversationDTO()
{
Type = IssueConversation.MessageType,
Data = "TestConversation",
};
var issueId = helper.Issue.Id;
var uri = $"/api/issues/{issueId}/conversations/";
var response = await helper.client.PostAsync(uri, newItem.ToStringContent());
Assert.IsTrue(response.IsSuccessStatusCode);
var issue = await helper.Helper.GetIssueAsync(issueId);
var latestConversationItem = issue.ConversationItems.Last();
Assert.AreEqual(latestConversationItem.CreatorUserId, helper.User.Id);
Assert.AreEqual(latestConversationItem.Type, IssueConversation.MessageType);
Assert.AreEqual(latestConversationItem.Data, "TestConversation");
uri = $"/api/messages/{helper.User.Id}";
response = await helper.client.GetAsync(uri);
Assert.IsTrue(response.IsSuccessStatusCode);
var messageList = await response.Parse <IList <MessageDTO> >();
Assert.AreEqual(1, messageList.Count);
}
public async Task WriteMessageAsCustomer()
{
using var helper = await new SimpleTestHelperBuilderIssueRights().Build();
var user = await helper.Helper.GenerateUserAndSetToProject(helper.Company.Id, helper.Project.Id, Role.CustomerRole);
var newItem = new IssueConversationDTO()
{
Type = IssueConversation.MessageType,
Data = "TestConversation",
};
var uri = $"/api/issues/{helper.Issue.Id}/conversations/";
var response = await helper.client.PostAsync(uri, newItem.ToStringContent());
Assert.IsTrue(response.IsSuccessStatusCode);
var issue = await helper.GetIssueAsync(helper.Issue.Id);
var latestConversationItem = issue.ConversationItems.Last();
Assert.AreEqual(latestConversationItem.CreatorUserId, user.Id);
Assert.AreEqual(latestConversationItem.Type, IssueConversation.MessageType);
Assert.AreEqual(latestConversationItem.Data, "TestConversation");
}
public async Task <IActionResult> Post([FromRoute] string issueId, [FromBody] IssueConversationDTO conversationItem)
{
if (conversationItem.Type != IssueConversation.MessageType)
{
throw new HttpStatusException(400, $"Invalid conversation type, only \"{IssueConversation.MessageType}\" allowed");
}
var newIssueConversation = await _issueConversationService.CreateNewIssueConversationAsync(issueId, conversationItem);
return(CreatedAtAction(nameof(GetById), new { issueId, id = newIssueConversation.Id }, newIssueConversation));
}
public async Task CustomerCanWriteMessageTestAsync()
{
using var helper = await new SimpleTestHelperBuilderIssueAuthorization(Role.CustomerRole).Build();
var uri = $"/api/issues/{helper.Issue.Id}/conversations/";
var newItem = new IssueConversationDTO()
{
Type = IssueConversation.MessageType,
Data = "Client was able to write a message.",
};
var response = await helper.client.PostAsync(uri, newItem.ToStringContent());
Assert.IsTrue(response.IsSuccessStatusCode);
}
public async Task WriteMessageAsReadOnlyEmployee()
{
using var helper = await new SimpleTestHelperBuilderIssueRights().Build();
await helper.Helper.GenerateUserAndSetToProject(helper.Company.Id, helper.Project.Id, Role.ReadonlyEmployeeRole);
var newItem = new IssueConversationDTO()
{
Type = IssueConversation.MessageType,
Data = "TestConversation",
};
var uri = $"/api/issues/{helper.Issue.Id}/conversations/";
var response = await helper.client.PostAsync(uri, newItem.ToStringContent());
Assert.IsFalse(response.IsSuccessStatusCode);
}
public async Task PostConversationWrongType()
{
using var helper = await new SimpleTestHelperBuilder().Build();
var newItem = new IssueConversationDTO()
{
Type = IssueConversation.StateChangeType,
Data = "TestConversation",
};
var uri = $"/api/issues/{helper.Issue.Id}/conversations/";
var response = await helper.client.PostAsync(uri, newItem.ToStringContent());
Assert.IsFalse(response.IsSuccessStatusCode);
var issue = await helper.Helper.GetIssueAsync(helper.Issue.Id);
Assert.AreEqual(0, issue.ConversationItems.Count);
}
public async Task <IActionResult> Put([FromRoute] string issueId, [FromRoute] string id, [FromBody] IssueConversationDTO conversationItem)
{
if (conversationItem.Type != IssueConversation.MessageType)
{
throw new HttpStatusException(400, $"Invalid conversation type, only \"{IssueConversation.MessageType}\" allowed");
}
await _issueConversationService.CreateOrReplaceConversationItemAsync(issueId, id, conversationItem);
return(NoContent());
}
/// <summary>
/// Creates or replaces the provided conversation item, based on the id.
/// </summary>
/// <param name="issueId">The issue on which the operation will be executed at.</param>
/// <param name="conversationItemId">The id of the conversation.</param>
/// <param name="conversationItem">The conversation that will be created or replaced if already existing.</param>
public async Task CreateOrReplaceConversationItemAsync(string issueId, string conversationItemId, IssueConversationDTO conversationItem)
{
ObjectId conversationItemOid = Validators.ValidateObjectId(conversationItemId, "Provided conversation id is no valid ObjectId.");
var issue = await _issueRepository.GetIssueByIdAsync(issueId);
await AssertUserCanWriteConversation(issue);
if (conversationItemOid.Equals(conversationItem.Id) is false)
{
throw new HttpStatusException(StatusCodes.Status400BadRequest, "Id missmatch.");
}
var issueConversationModel = new IssueConversation()
{
Id = conversationItem.Id,
CreatorUserId = Validators.ValidateObjectId(conversationItem.Creator?.Id.ToString(), "The conversation item is missing a valid userId."),
Data = conversationItem.Data,
// Conversation from the outside is always a message and
// can therefore not contain requirements
Requirements = null,
Type = IssueConversation.MessageType,
};
await _issueRepository.CreateOrUpdateConversationItemAsync(issueId, issueConversationModel);
}
/// <summary>
/// Creates a new conversation for the provided issueId.
/// </summary>
/// <param name="issueId">The issue which will gets appended with the provided conversation.</param>
/// <param name="conversationItem">The new conversation item.</param>
/// <returns>The inserted conversation item.</returns>
public async Task <IssueConversationDTO> CreateNewIssueConversationAsync(string issueId, IssueConversationDTO conversationItem)
{
var issue = await _issueRepository.GetIssueByIdAsync(issueId);
await AssertUserCanWriteConversation(issue);
await _issueService.AssertNotArchived(issue);
var conversationItems = issue.ConversationItems;
// if ConversationItems are null = empty, create a new list, which will gets appended.
if (conversationItems is null)
{
conversationItems = new List <IssueConversation>();
}
// TODO: after auth code impl. check if the user who creating this request is identical to the "conversationItem.Creator.Id" -> a client cannot create a conversation for other than himself.
IssueConversation newConversation = new IssueConversation()
{
Id = ObjectId.GenerateNewId(),
CreatorUserId = _httpContextAccessor.HttpContext.User.GetUserId(),
Data = conversationItem.Data,
Requirements = new List <string>(),
Type = conversationItem.Type
};
// append the conversationItems with the new conversation item.
conversationItems.Add(newConversation);
// send Message to Author
await CreateMessageForAuthor(issue);
// update the issue and the conversationItems withit.
await _issueRepository.UpdateAsync(issue);
return(await MapIssueConversationDTOAsync(issue.Id, newConversation));
}
