public async Task <Response <UpdateReceipt> > UpdateMessageAsync <TData>(UpdateMessageModel <TData> message)
where TData : class
{
await GetQueueClient(message.QueueName);
return(await _queueClient.UpdateMessageAsync(message.Message.MessageId, message.Message.PopReceipt, message.Data.ToJson(IgnoredProperties)));
}
public async Task <MessageModel> Put(int id, [FromBody] UpdateMessageModel requestModel)
{
var item = await _query.Update(id, requestModel);
var model = _mapper.Map <MessageModel>(item);
return(model);
}
public void UpdateMessageTest_ShouldReturnForbidden()
{
var controller = GetControllerInstance();
var messageId = new Guid(MessageId2);
var testUpdateMessage = new UpdateMessageModel
{
Message = "New updated message"
};
var result = controller.UpdateMessage(messageId, testUpdateMessage) as ForbidResult;
Assert.IsNotNull(result);
}
public void UpdateMessageTest_ShouldReturnNotFound()
{
var controller = GetControllerInstance();
var messageId = new Guid(FakeMessageId);
var testUpdateMessage = new UpdateMessageModel
{
Message = "New updated message"
};
var message = controller.UpdateMessage(messageId, testUpdateMessage) as NotFoundResult;
Assert.IsNotNull(message);
Assert.AreEqual(StatusCodes.Status404NotFound, message.StatusCode);
}
public async Task <Message> Update(int id, UpdateMessageModel model)
{
var message = GetQuery().FirstOrDefault(x => x.Id == id);
if (message == null)
{
throw new NotFoundException("Expense is not found");
}
message.Description = model.Description;
message.Sticker = model.Sticker;
await _uow.CommitAsync();
return(message);
}
public void UpdateMessageTest_ShouldUpdateAndReturnMessage()
{
var controller = GetControllerInstance();
var testUpdateMessage = new UpdateMessageModel
{
Message = "New updated message"
};
var result = controller.UpdateMessage(new Guid(MessageId1), testUpdateMessage) as OkObjectResult;
Assert.IsNotNull(result);
Assert.AreEqual(StatusCodes.Status200OK, result.StatusCode);
var message = result.Value as Message;
Assert.IsNotNull(message);
Assert.AreEqual(testUpdateMessage.Message, message.Content);
}
public Task <Result <MessageCoreModel> > Edit(UpdateMessageModel model)
=> Result <MessageCoreModel> .TryAsync(async() =>
{
var message = (await _repository.FirstOrDefaultAsync <Message>(i => i.Id == model.Id)).Data;
if (message == null)
{
return(Result <MessageCoreModel> .Failed(Error.WithData(1000, new[] { "Message not found " })));
}
message.Body = model.Body;
message.Title = model.Title;
message.Priority = (byte)model.Priority;
message.Enabled = model.Enabled;
await _repository.CommitAsync();
return(Result <MessageCoreModel> .Successful(_autoMapper.Map <MessageCoreModel>(message)));
});
public async Task <IActionResult> Update(int messageId, [FromBody] UpdateMessageModel model)
{
var currentUser = await GetCurrentUserAsync();
if (currentUser is null ||
currentUser is default(User))
{
return(Unauthorized("No authorized user found.\nPlease log in by using your credentials."));
}
if (messageId < 0)
{
return(BadRequest("Message id must bigger than zero."));
}
if (model is null)
{
return(BadRequest("Model is required."));
}
var message = await _messageService.GetMessageBySenderUserIdAsync(messageId, currentUser.Id);
if (message is null ||
message is default(Message))
{
return(NotFound("No message found."));
}
try
{
//map model to message entity
message = _mapper.Map <Message>(model);
// update message
await _messageService.UpdateMessageAsync(message);
return(Ok("Message updated ✔"));
}
catch (Exception ex)
{
// return error message if there was an exception
return(BadRequest(ex.Message));
}
}
public async Task <Result <MessageCoreModel> > Edit(UpdateMessageModel model) => await _messageBiz.Edit(model);