public ActionResult Create(MessageCreateModel model)
{
bool success = true;
string html = "";
if (!ModelState.IsValid)
{
success = false;
}
else
{
MessageCreateDTO messageDTO = Mapper.Map <MessageCreateModel, MessageCreateDTO>(model);
ServiceMessage serviceMessage = service.Create(messageDTO);
if (!serviceMessage.Succeeded)
{
foreach (string error in serviceMessage.Errors)
{
ModelState.AddModelError("", error);
}
success = false;
}
}
if (!success)
{
html = RenderHelper.PartialView(this, "~/Views/Message/Create.cshtml", model);
}
return(Json(new { success = success, html = html }));
}
public async Task <ActionResult <MessageDTO> > MessageCreate(MessageCreateDTO messageCreateDto)
{
var username = User.GetUsername();
if (username == messageCreateDto.ReceiverUsername.ToLower())
{
return(BadRequest("You cannot message yourself!"));
}
var sender = await _userRepository.GetUserByUsernameAsync(username);
var receiver = await _userRepository.GetUserByUsernameAsync(messageCreateDto.ReceiverUsername);
if (receiver == null)
{
return(NotFound()); //if we dont have the receiver
}
var message = new Message
{
Sender = sender,
Receiver = receiver,
SenderUsername = sender.UserName,
ReceiverUsername = receiver.UserName,
Content = messageCreateDto.Content
};
_messageRepository.AddMessage(message);
if (await _messageRepository.SaveAllAsync())
{
return(Ok(_mapper.Map <MessageDTO>(message)));
}
return(BadRequest("The message was not sent"));
}
public async Task <IActionResult> Createmessage(string senderId, MessageCreateDTO messageCreateDTO)
{
var a = User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (senderId != User.FindFirst(ClaimTypes.NameIdentifier).Value)
{
return(Unauthorized());
}
var receiver = await _unitofWork.PartnerFinder.GetUser(messageCreateDTO.ReceiverId);
if (receiver == null)
{
return(BadRequest("receiver not found"));
}
var message = _mapper.Map <Message>(messageCreateDTO);
_unitofWork.MessageRepository.Add(message);
var result = await _unitofWork.Save();
if (result == 0)
{
return(StatusCode(500, "saving probem"));
}
return(Ok());
}
public async Task <IActionResult> PostUserMessages([FromBody] MessageCreateDTO request, string username, int latest = 0)
{
_memoryCache.Set(CacheFields.Latest, latest);
await _messageRepository.AddMessage(request, username);
//AverageMessages.IncTo(_userRepository.AverageMessagesPostedByUser());
//TotalMessages.Inc();
return(NoContent());
}
public ServiceMessage Create(MessageCreateDTO messageDTO)
{
List <string> errors = new List <string>();
bool succeeded = Validate(messageDTO, errors);
if (succeeded)
{
try
{
UserEntity userEntity = unitOfWork.Users.Get(messageDTO.SenderLogin);
if (userEntity != null)
{
TopicEntity topicEntity = unitOfWork.Topics.Get(messageDTO.TopicId);
if (topicEntity != null)
{
MessageEntity messageEntity = new MessageEntity
{
Text = messageDTO.Text,
Sender = userEntity,
Topic = topicEntity,
DateCreated = DateTime.Now,
DateLastModified = DateTime.Now
};
topicEntity.DateOfLastMessage = DateTime.Now;
unitOfWork.Messages.Add(messageEntity);
unitOfWork.Commit();
}
else
{
succeeded = false;
errors.Add("Topic was not found");
}
}
else
{
succeeded = false;
errors.Add("User was not found");
}
}
catch (Exception ex)
{
ExceptionMessageBuilder.FillErrors(ex, errors);
succeeded = false;
}
}
return(new ServiceMessage
{
Errors = errors,
Succeeded = succeeded
});
}
private bool Validate(MessageCreateDTO messageDTO, ICollection <string> errors)
{
bool validated = true;
if (String.IsNullOrEmpty(messageDTO.Text))
{
validated = false;
errors.Add("Text cannot be empty");
}
if (String.IsNullOrEmpty(messageDTO.SenderLogin))
{
validated = false;
errors.Add("Message must have an author");
}
return(validated);
}
public ActionResult RegisterMessage([FromBody] MessageCreateDTO messageData)
{
if (!ModelState.IsValid)
{
return(BadRequest(new
{
Message = "La informacion de registro de skills de usuario invalidos.",
ErrorsCount = ModelState.ErrorCount,
Errors = ModelState.Select(x => x.Value.Errors)
}));
}
var newMessage = this._mapper.Map <Message>(messageData);
if (newMessage == null)
{
return(BadRequest(new { Error = "No se enviaron los datos esperados." }));
}
var tempMessage = this._appDBContext.Messages.Add(newMessage);
this._appDBContext.SaveChanges();
var messageModel = this._mapper.Map <MessageResponseDTO>(tempMessage.Entity);
var userInfo = this._appDBContext.Users.FirstOrDefault(x => x.Id == messageModel.FromUserId);
if (userInfo != null)
{
messageModel.User = this._mapper.Map <UserResponseDTO>(userInfo);
}
return(Ok(new
{
Message = "Ok",
Result = messageModel
}));
}
public MessageDTO CreateMessage(MessageCreateDTO newMessage, int senderID)
{
var user = _userMockRepository.GetUserByID(senderID);
if (user == null)
{
throw new NotFoundException("User with passed ID is not found...");
}
Message entity = mapper.Map <Message>(newMessage);
entity.SenderID = senderID;
if (_messageRepository.CheckDidIBlockUser(senderID, entity.ReceiverID))
{
throw new BlockingException("You have blocked this user and you can not send him message.");
}
if (!_messageRepository.CheckDoIFollowUser(senderID, entity.ReceiverID))
{
throw new BlockingException("You are not following this user and you can not send him message.");
}
try
{
entity.IsSent = true;
var message = _messageRepository.CreateMessage(entity);
_messageRepository.SaveChanges();
return(mapper.Map <MessageDTO>(message));
}
catch (Exception ex)
{
throw new ErrorOccurException(ex.Message);
}
}
public Guid SendMessage(Guid session, Guid sendTo, MessageCreateDTO message)
{
throw new NotImplementedException();
}
