public CreateResultDTO Create(MessageEditDTO DTO, UserDTO userDTO)
{
using (var Data = DataFactory.Get())
{
var user = GetUserService.Get(userDTO, Data);
var theme = Data.ThemeRepository.Get().FirstOrDefault(x => x.Id == DTO.ThemeId);
if (theme == null)
{
return(CreateResultDTO.NotFound);
}
if (MessageRules.CanCreate(user, theme))
{
var message = new Message();
EditMessage(message, DTO, user, false);
message.Theme = theme;
Data.MessageRepository.Add(message);
Data.SaveChanges();
return(new CreateResultDTO(message.Id, AccessCode.Succsess));
}
else
{
return(CreateResultDTO.NoPremision);
}
}
}
public void Should_UpdateMessageMockFunction_With_Return_SuccessWithNoContent()
{
//Arrange
var editedMessage = new MessageEditDTO()
{
Text = "Update new Message",
};
var message = new Message()
{
Id = 1,
Text = "Message",
UserId = 1,
};
var _mockRepo = new Mock <IRepositoryWrapper>();
var _mockPrincipal = new Mock <IUserClaimsPrincipal>();
var _mockLogger = new Mock <ILoggerManager>();
_mockRepo.Setup(x => x.Message.UpdateMessageAsync(message));
_mockRepo.Setup(x => x.Message.GetMessageByIdAsync(1)).ReturnsAsync(message);
_mockPrincipal.Setup(x => x.GetUserName(It.IsAny <ClaimsPrincipal>())).Returns("admin");
_mockRepo.Setup(x => x.User.GetUserByUserNameAsync("admin")).ReturnsAsync(1);
var controller = new MessageController(_mockRepo.Object, _mockLogger.Object, _mockPrincipal.Object);
//Act
var actual = controller.Put(1, editedMessage);
var actualResult = ((NoContentResult)actual.Result);
//Assert
Assert.Same(typeof(NoContentResult), actualResult.GetType());
}
public ActionResult Edit(MessageEditModel model)
{
bool success = true;
string html = "";
if (!ModelState.IsValid)
{
success = false;
}
else
{
MessageEditDTO messageDTO = Mapper.Map <MessageEditModel, MessageEditDTO>(model);
ServiceMessage serviceMessage = service.Edit(messageDTO);
if (!serviceMessage.Succeeded)
{
success = false;
foreach (string error in serviceMessage.Errors)
{
ModelState.AddModelError("", error);
}
}
}
if (!success)
{
html = RenderHelper.PartialView(this, "~/Views/Message/Edit.cshtml", model);
}
return(Json(new { success = success, html = html }));
}
public ServiceMessage Edit(MessageEditDTO messageDTO)
{
List <string> errors = new List <string>();
bool succeeded = Validate(messageDTO, errors);
if (succeeded)
{
try
{
MessageEntity messageEntity = unitOfWork.Messages.Get(messageDTO.Id);
messageEntity.Text = messageDTO.Text;
messageEntity.DateLastModified = DateTime.Now;
messageEntity.Topic.DateOfLastMessage = DateTime.Now;
unitOfWork.Commit();
}
catch (Exception ex)
{
ExceptionMessageBuilder.FillErrors(ex, errors);
succeeded = false;
}
}
return(new ServiceMessage
{
Errors = errors,
Succeeded = succeeded
});
}
public void Should_UpdateEmptyMessageMockFunction_With_Return_BadRequest()
{
//Arrange
var editedMessage = new MessageEditDTO()
{
Text = "",
};
var message = new Message()
{
Id = 1,
Text = "Message",
UserId = 1,
};
var _mockRepo = new Mock <IRepositoryWrapper>();
var _mockPrincipal = new Mock <IUserClaimsPrincipal>();
var _mockLogger = new Mock <ILoggerManager>();
_mockRepo.Setup(x => x.Message.UpdateMessageAsync(message));
_mockPrincipal.Setup(x => x.GetUserName(It.IsAny <ClaimsPrincipal>())).Returns("admin");
_mockRepo.Setup(x => x.User.GetUserByUserNameAsync("admin")).ReturnsAsync(1);
var controller = new MessageController(_mockRepo.Object, _mockLogger.Object, _mockPrincipal.Object);
//Act
var actual = controller.Put(1, editedMessage);
var actualResult = ((BadRequestObjectResult)actual.Result);
//Assert
Assert.Same(typeof(BadRequestObjectResult), actualResult.GetType());
Assert.Equal("Message object is not filled correct", (((ResponseVM)actualResult.Value).Title));
}
private void EditMessage(Message message, MessageEditDTO messageDTO, User user, bool edit = true)
{
message.Text = messageDTO.Text;
if (edit)
{
message.LastEditor = user;
message.LastEditTime = DateTime.Now;
}
else
{
message.Owner = user;
message.Time = DateTime.Now;
}
}
private bool Validate(MessageEditDTO messageDTO, ICollection <string> errors)
{
bool validated = true;
if (String.IsNullOrEmpty(messageDTO.Text))
{
validated = false;
errors.Add("Text cannot be empty");
}
if (messageDTO.Text.Length > 200)
{
validated = false;
errors.Add("Text cannot contain more than 200 characters");
}
return(validated);
}
public AccessCode Update(MessageEditDTO DTO, UserDTO userDTO)
{
using (var Data = DataFactory.Get())
{
var check = CheckMessage(userDTO, DTO.Id, MessageRules.CanRead, Data);
if (check.Code == AccessCode.Succsess)
{
if (IsFirstMessage(check.Message))
{
return(AccessCode.NoPremision);
}
EditMessage(check.Message, DTO, check.User);
Data.MessageRepository.Edited(check.Message);
Data.SaveChanges();
}
return(check.Code);
}
}
public async Task <IActionResult> Put([FromRoute] int id, [FromBody] MessageEditDTO message)
{
try
{
int userId = _repoWrapper.User.GetUserByUserNameAsync(_userClaimsPrincipal.GetUserName(HttpContext?.User)).Result;
if (message == null || message.Text == null || message.Text == "")
{
return(BadRequest(new ResponseVM("Message object is not filled correct")));
}
if (!ModelState.IsValid)
{
return(BadRequest(new ResponseVM("Invalid message object")));
}
var dbMessage = await _repoWrapper.Message.GetMessageByIdAsync(id);
if (dbMessage == null || dbMessage.Id == 0)
{
return(NotFound(new ResponseVM("Message not found.")));
}
else if (userId != dbMessage.UserId)
{
return(Forbid());
}
await _repoWrapper.Message.UpdateMessageAsync(dbMessage, message);
_repoWrapper.Save();
return(NoContent());
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside UpdateMessage action: {ex.Message}");
return(StatusCode(500, new ResponseVM("Internal server error")));
}
}
public DataServiceMessage <MessageEditDTO> Get(int id)
{
List <string> errors = new List <string>();
bool succeeded = true;
MessageEditDTO messageDTO = null;
try
{
MessageEntity messageEntity = unitOfWork.Messages.Get(id);
if (messageEntity != null)
{
messageDTO = new MessageEditDTO
{
Id = id,
Text = messageEntity.Text
};
}
else
{
succeeded = false;
errors.Add("Message not found");
}
}
catch (Exception ex)
{
ExceptionMessageBuilder.FillErrors(ex, errors);
succeeded = false;
}
return(new DataServiceMessage <MessageEditDTO>
{
Errors = errors,
Succeeded = succeeded,
Data = messageDTO
});
}
public static void MapForEdit(this Message dbMessage, MessageEditDTO message)
{
dbMessage.Text = message.Text;
dbMessage.EditDate = DateTime.Now;
}
public async Task UpdateMessageAsync(Message dbMessage, MessageEditDTO message)
{
dbMessage.MapForEdit(message);
Update(dbMessage);
await SaveAsync();
}
