public IActionResult CreateMessage([FromBody] MessageCreateDto createMessage)
{
if (!ModelState.IsValid)
{
return(BadRequest(new TransActionResponse(ModelState.ToString())));
}
var newMessage = _mapper.Map <TraTopicMessage>(createMessage);
string userGuid = UserHelper.GetUserGuid(_httpContextAccessor);
var getUser = _unitOfWork.User.GetByGuid(userGuid);
newMessage.UserId = getUser.UserId;
_unitOfWork.Message.Create(newMessage);
if (!_unitOfWork.Save())
{
return(StatusCode(500, new TransActionResponse("A problem happened while handling your request")));
}
var topic = _unitOfWork.Topic.GetTopicById(newMessage.TopicId);
topic.DbLastUpdateTimestamp = DateTime.Now;
topic.LastMessageTimestamp = DateTime.Now;
if (!_unitOfWork.Save())
{
return(StatusCode(500, new TransActionResponse("A problem happened while handling your request")));
}
var createMessageResult = _mapper.Map <MessageDto>(newMessage);
return(CreatedAtRoute("GetMessage", new { id = createMessageResult.TopicMessageId }, new TransActionResponse(createMessageResult)));
}
public async Task <IActionResult> CreateMessage(int userId, [FromBody] MessageCreateDto messageDto)
{
var sender = await _repo.GetUser(userId);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageDto.SenderId = userId;
var recipient = await _repo.GetUser(messageDto.RecipientId);
if (recipient == null)
{
return(BadRequest("Could not find user."));
}
var message = _mapper.Map <Message>(messageDto);
_repo.Add(message);
if (await _repo.SaveAll())
{
var messageToReturn = _mapper.Map <MessageReturnDto>(message);
return(CreatedAtRoute(nameof(GetMessage), new { id = message.Id }, messageToReturn));
}
throw new Exception("Creating the message faied on save.");
}
public MessageConfirmationDto Create(MessageCreateDto dto)
{
User sender = UserData.Users.FirstOrDefault(e => e.Id == dto.SenderId);
if (sender == null)
{
throw new Exception("User does not exit");
}
User reciver = UserData.Users.FirstOrDefault(e => e.Id == dto.ReciverId);
if (reciver == null)
{
throw new Exception("User does not exit");
}
Message message = new Message()
{
Id = Guid.NewGuid(),
Content = dto.Content,
IsSeen = dto.IsSeen,
ReciverId = dto.ReciverId,
SenderId = dto.SenderId
};
_context.Messages.Add(message);
_context.SaveChanges();
_logger.Log("Message created");
return(_mapper.Map <MessageConfirmationDto>(message));
}
public async Task <MessageDto> CreateMessage(MessageCreateDto messageCreateDto)
{
var userId = (await _authenticateService.GetAuthUser()).Id;
var message = new Message
{
ChatId = messageCreateDto.ChatId,
Text = messageCreateDto.Text,
PosterId = userId,
Timestamp = DateTime.Now
};
_unitOfWork.Repository <Message>().Add(message);
await _unitOfWork.SaveChangesAsync();
var posterName = (await _unitOfWork.Repository <User>().GetAll()
.Include(u => u.Details)
.SingleOrDefaultAsync(u => u.Id == userId)).Details.FirstName;
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <Message, MessageDto>()
.ForMember(m => m.PosterName, opt => opt.MapFrom(sm => posterName)))
.CreateMapper();
var messageDto = mapper.Map <Message, MessageDto>(message);
return(messageDto);
}
public async Task <IActionResult> CreateMessage(int userId, MessageCreateDto messageCreateDto)
{
var sender = await _repo.GetUser(userId);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageCreateDto.SenderId = userId;
var receipient = await _repo.GetUser(messageCreateDto.RecipientId);
if (receipient == null)
{
return(BadRequest("receipient not found"));
}
var message = _mapper.Map <Message>(messageCreateDto);
_repo.Add(message);
var messageToReturn = _mapper.Map <MessageReturnDto>(message);
if (await _repo.SaveAll())
{
return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToReturn));
}
throw new Exception("fail to creat message");
}
public MessageConfirmationDto Update(Guid id, MessageCreateDto dto)
{
var message = _context.Messages.FirstOrDefault(e => e.Id == id);
if (message == null)
{
throw new Exception("Message with provided id does not exist");
}
User sender = UserData.Users.FirstOrDefault(e => e.Id == dto.SenderId);
if (sender == null)
{
throw new Exception("User does not exit");
}
User reciver = UserData.Users.FirstOrDefault(e => e.Id == dto.ReciverId);
if (reciver == null)
{
throw new Exception("User does not exit");
}
message.Content = dto.Content;
message.IsSeen = dto.IsSeen;
message.ReciverId = dto.ReciverId;
message.SenderId = dto.SenderId;
_context.SaveChanges();
_logger.Log("Message updated");
return(_mapper.Map <MessageConfirmationDto>(message));
}
public MessageReadDto Update(int id, MessageCreateDto dto)
{
var user = UserData.Users.FirstOrDefault(e => e.Id == dto.SenderId);
if (user == null)
{
throw new BusinessException("User does not exist", 400);
}
var message = _context.Messages.FirstOrDefault(e => e.Id == id);
if (message == null)
{
throw new BusinessException("Message does not exist");
}
message.Content = dto.Content;
message.SenderId = dto.SenderId;
message.ConversationId = dto.ConversationId;
message.CreatedAt = dto.CreatedAt;
message.UpdatedAt = dto.UpdatedAt;
message.IsRead = dto.IsRead;
_context.SaveChanges();
_logger.Log("Message updated!");
return(_mapper.Map <MessageReadDto>(message));
}
public async Task <IActionResult> CreateMessage(int userId, MessageCreateDto messageCreateDto)
{
var sender = await _unitOfWork.userRepository.GetEntityWithInclude(u => u.Photos, u => u.ID == userId);
if (sender.ID != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageCreateDto.SenderId = userId;
var receiver = await _unitOfWork.userRepository.GetEntityWithInclude(u => u.Photos, u => u.ID == messageCreateDto.ReceiverId);
if (receiver == null)
{
return(BadRequest("Could not find receiver"));
}
var message = _mapper.Map <Message>(messageCreateDto);
_unitOfWork.messageRepository.Add(message);
if (await _unitOfWork.Commit())
{
var messageToReturn = _mapper.Map <MessageDetailsDto>(message);
return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToReturn));
}
throw new Exception("Creating new message failed on save");
}
public async Task <IActionResult> CreateMessage(int userId, MessageCreateDto messageToCreate)
{
if (userId != int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)))
{
return(Unauthorized());
}
var recipient = await _repo.GetUserAsync(userId);
if (recipient == null)
{
return(BadRequest("Could not find user"));
}
var message = _mapper.Map <Message>(messageToCreate);
_repo.Add(message);
if (await _repo.SaveChangesAsync())
{
return(CreatedAtRoute(nameof(GetMessage), new { id = message.Id }, messageToCreate));
}
throw new Exception("Creating message failed on save");
}
public async Task <CreatedResult> Post([FromBody] MessageCreateDto dto)
{
_logger.LogInformation("POST to {} {}", "/messages", dto.ToJson());
var result = await _messageService.CreateMessage(dto);
return(Created($"/messages/{result.Id}", result));
}
public static Message CreateMessage(this Message u, MessageCreateDto model)
{
u.Id = Guid.NewGuid().ToString();
u.Content = model.Content;
u.SenderId = model.SenderId;
u.ChannelId = model.ChannelId;
return(u);
}
public ActionResult <MessageReadDto> AddMessage(MessageCreateDto messageCreateDto)
{
var messageModel = _mapper.Map <Message>(messageCreateDto);
_repository.CreateMessage(messageModel);
_repository.SaveChanges();
var messageReadDto = _mapper.Map <MessageReadDto>(messageModel);
return(CreatedAtRoute(nameof(GetMessageById), new { Id = messageReadDto.Id }, messageReadDto));
}
/// <summary>
/// Sends the message asynchronous.
/// </summary>
/// <param name="messageDto">The message dto.</param>
/// <returns>Void result.</returns>
public async Task SendMessage(MessageCreateDto messageDto)
{
var message = this.mapper.Map <Message>(messageDto);
message.Id = Guid.NewGuid();
message.PlayerId = this.Context.User.Identity.Name;
message.Time = DateTimeOffset.UtcNow;
await this.chatRepostitory.SaveMessageAsync(message);
await this.Clients.Group(message.GameId.ToString()).ReceiveMessage(this.mapper.Map <MessageDto>(message));
}
public async Task <IActionResult> AddMessage([FromBody] MessageCreateDto messageDto)
{
Channel selectedChannel = _messageRepositories.GetChannels().FirstOrDefault(x => x.Name == messageDto.Channel);
if (selectedChannel == null)
{
selectedChannel = new Channel
{
Id = Guid.NewGuid(),
Name = messageDto.Channel
};
_messageRepositories.AddChannel(selectedChannel);
}
User chatUser = _messageRepositories.GetUser(messageDto.User);
if (chatUser == null)
{
chatUser = new User
{
Id = Guid.NewGuid(),
Name = messageDto.User
};
_messageRepositories.AddUser(chatUser);
}
Message newMessage = new Message
{
Id = Guid.NewGuid(),
Value = messageDto.Value,
User = chatUser,
UserId = chatUser.Id,
Channel = selectedChannel,
ChannelId = selectedChannel.Id,
TimeStamp = DateTime.UtcNow
};
_messageRepositories.AddMessage(newMessage);
bool result = _messageRepositories.Save();
if (!result)
{
return(new StatusCodeResult(500));
}
var chatMessage = MapMessageToDto(newMessage);
await _messageHub.Clients.All.SendAsync("NewMessage", chatMessage);
return(Ok(newMessage));
}
public async Task <int> Update(MotorUpdateDto dto, int id, string userId)
{
var oldMotor = await _dbContext.Motors
.Include(x => x.Client)
.Include(x => x.MaintenanceCycles)
.Include(x => x.MaintenanceContracts)
.Include(x => x.MaintenanceServices)
.Include(x => x.SaleContracts)
.Include(x => x.SparePartsSold)
.SingleOrDefaultAsync(x => x.Id == id);
var updatedMotor = _mapper.Map(dto, oldMotor);
updatedMotor.UpdateAt = DateTime.Now;
updatedMotor.UpdatedBy = userId;
_dbContext.Motors.Update(updatedMotor);
await _dbContext.SaveChangesAsync();
// Check Motor if Need to Change Oli
var hoursDifference = updatedMotor.CurrentCounterReading - updatedMotor.PreviousCounterReading;
if (hoursDifference >= updatedMotor.OliCounter)
{
// Motor Need to Change Oli , Then Push Notification To All Users
var usersFcmToken = await _dbContext.Users
.Where(x => x.FcmToken != null)
.Select(x => x.FcmToken).ToListAsync();
var message = new MessageCreateDto()
{
Title = "اشعار صيانة",
Body = "هناك مولد يحتاج الى تغيير زيت للمحرك",
Action = "Motor",
ActionId = updatedMotor.Id
};
var notifications = _service.CreateNotifications(message, usersFcmToken);
await _service.PushNotifications(notifications);
}
return(updatedMotor.Id);
}
public IActionResult CreateMessage([FromBody] MessageCreateDto createTopic)
{
if (createTopic == null)
{
return(BadRequest());
}
if (createTopic.Body == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newMessage = _mapper.Map <TraTopicMessage>(createTopic);
string userGuid = UserHelper.GetUserGuid(_httpContextAccessor);
var getUser = _transActionRepo.GetUsers().FirstOrDefault(c => c.Guid == userGuid);
newMessage.UserId = getUser.UserId;
_transActionRepo.CreateTopicMessage(newMessage);
if (!_transActionRepo.Save())
{
return(StatusCode(500, "A problem happened while handling your request."));
}
var topic = _transActionRepo.GetTopic(newMessage.TopicId);
topic.DbLastUpdateTimestamp = DateTime.Now;
if (!_transActionRepo.Save())
{
return(StatusCode(500, "A problem happened while handling your request."));
}
var createdPointOfInterestToReturn = _mapper.Map <MessageDto>(newMessage);
return(CreatedAtRoute("GetMessage", new { messageId = createdPointOfInterestToReturn.TopicMessageId }, createdPointOfInterestToReturn));
}
public MessageReadDto Create(MessageCreateDto dto)
{
var user = UserData.Users.FirstOrDefault(e => e.Id == dto.SenderId);
if (user == null)
{
throw new BusinessException("User does not exist", 400);
}
var message = _mapper.Map <Message>(dto);
_context.Messages.Add(message);
_context.SaveChanges();
_logger.Log("Message created!");
return(_mapper.Map <MessageReadDto>(message));
}
public async Task <ActionResult <MessageReadDto> > PostMessages(MessageCreateDto message)
{
try
{
var messageModel = _mapper.Map <Message>(message);
messageModel.CreatedDate = DateTime.Now;
_repository.CreateMessage(messageModel);
await _repository.SaveChangesAsync();
var messageDto = _mapper.Map <MessageReadDto>(messageModel);
_logger.LogInfo("Message created");
return(CreatedAtRoute(nameof(GetMessageById), new { id = messageDto.Id }, messageDto));
}
catch (Exception ex)
{
_logger.LogError(ex);
return(Problem("An error has ocurred, please try again later." + ex.Message));
}
}
public ActionResult Create(MessageCreateDto msgCreateDto)
{
if (msgCreateDto == null)
{
return(Problem());
}
var msg = _mapper.Map <Message>(msgCreateDto);
//check if the user has permission
var user = HttpContext.User;
int userId = int.Parse(user.Claims.FirstOrDefault(c => c.Type == "Id").Value);
if (userId != msgCreateDto.FromUserId)
{
return(Forbid());
}
_unitOfWork.Messages.Add(msg);
_unitOfWork.SaveChanges();
return(NoContent());
}
public async Task NewMessage(MessageCreateDto msg)
{
var mesaj = new Message();
try
{
mesaj.CreateMessage(msg);
_context.Messages.Add(mesaj);
await _context.SaveChangesAsync();
mesaj = await _context.Messages.Include(x => x.Sender).FirstOrDefaultAsync(x => x.Id == mesaj.Id);
}
catch (Exception ex)
{
}
if (Clients != null)
{
await Clients.All.SendAsync("MessageReceived", mesaj);
}
}
public ActionResult <MessageReadDto> CreateMessage(MessageCreateDto messageCreateDto)
{
messageCreateDto.Text = _htmlSanitizer.Sanitize(_profanityFilter.CensorString(messageCreateDto.Text));
if (messageCreateDto.Text == "")
{
messageCreateDto.Text = "<prázdna po vyfiltrovaní>";
messageCreateDto.Deleted = true;
}
var messageModel = _mapper.Map <Message>(messageCreateDto);
_onlineDOD.CreateMessage(messageModel);
_onlineDOD.SaveChanges();
var messageReadDto = _mapper.Map <MessageReadDto>(messageModel);
//Serilog.Log.Information($"[{this.Request.Host.Host}] POST /api/messages -> ID - {messageReadDto.Id}");
return(CreatedAtRoute(nameof(GetMessageById), new { Id = messageReadDto.Id }, messageReadDto));
}
public async Task <MessageDto> CreateMessage(MessageCreateDto dto)
{
_logger.LogInformation("Clear cache");
var removeCacheTask = _cacheService.RemoveAsync();
var client = _clientFactory.CreateClient();
var response = await client.PostAsync(GetMicroserviceUri(),
new StringContent(dto.ToJson(), Encoding.Default, "application/json"));
if (!response.IsSuccessStatusCode)
{
throw new Exception("Something went wrong");
}
var content = await response.Content.ReadAsStringAsync();
await removeCacheTask;
return(JsonConvert.DeserializeObject <MessageDto>(content));
}
public List <Message> CreateNotifications(MessageCreateDto dto, List <string> tokens)
{
var messages = new List <Message>();
foreach (var token in tokens)
{
var message = new Message()
{
Token = token,
Data = new Dictionary <string, string>()
{
{ "Title", dto.Title },
{ "Body", dto.Body },
{ "Action", dto.Action },
{ "ActionId", dto.ActionId.ToString() },
},
};
messages.Add(message);
}
return(messages);
}
public async Task <IActionResult> CreateMessage(int userid, MessageCreateDto messageParams)
{
try
{
var sender = await _datingrepo.GetUser(userid);
if (sender.UserID != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageParams.SenderID = userid;
var receiver = await _datingrepo.GetUser(messageParams.ReceiverID);
if (receiver == null)
{
return(BadRequest("Receiving user does not exists"));
}
var message = _mapper.Map <Messages>(messageParams);
_datingrepo.Add(message);
if (await _datingrepo.SaveAll())
{
var returnMessage = _mapper.Map <MessageReturnDto>(message);
return(CreatedAtRoute("GetMessage", new { userid = userid, messageid = message.MessageID }, returnMessage));
}
throw new Exception("Error while creating message");
}
catch (Exception ex)
{
throw new Exception("Error while creating message");
}
}
public ActionResult <MessageReadDto> Create([FromBody] MessageCreateDto request)
{
if (_userRepository.Get(request.SenderId) == null || _userRepository.Get(request.ReceiverId) == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, "User doesn't exist."));
}
Conversation conversation = _conversationRepository.Get(request.ConversationId);
if (conversation == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Conversation doesn't exist."));
}
if (conversation.CreatorId != conversation.ParticipantId && request.SenderId == request.ReceiverId)
{
return(StatusCode(StatusCodes.Status400BadRequest, "You can't send message to yourself in Conversation with someone else."));
}
if ((conversation.CreatorId != request.SenderId &&
conversation.CreatorId != request.ReceiverId) ||
(conversation.ParticipantId != request.SenderId &&
conversation.ParticipantId != request.ReceiverId))
{
return(StatusCode(StatusCodes.Status403Forbidden, "Cannot create Message for Conversation you're not a part of."));
}
Message newEntity = _mapper.Map <Message>(request);
newEntity.DateTime = DateTime.UtcNow;
newEntity.StatusRead = false;
newEntity = _messageRepository.Create(newEntity);
return(StatusCode(StatusCodes.Status201Created, _mapper.Map <MessageReadDto>(newEntity)));
}
public async Task <MessageCreateDto> AddMessage(CreateMessagDto dto)
{
MessageCreateDto input = new MessageCreateDto()
{
Message = dto.Message, CreateTime = DateTime.Now
};
if (User.Identity.IsAuthenticated)
{
var nameClaim = User.Claims.FirstOrDefault(c => c.Type == "name");
input.UserName = nameClaim == null ? "佚名" : nameClaim.Value;
}
else
{
input.UserName = "******";
}
var result = await _articleClient.AddMessage(input);
if (result.State == 1)
{
return(input);
}
return(null);
}
public IActionResult CreateMessage([FromBody] MessageCreateDto msgToCreate)
{
return(Ok("Not Implemented Yet"));
}
public async Task <MessageDto> CreateMessage(MessageCreateDto dto) => _mapper.Map <MessageDto>(await _repository.Create(_mapper.Map <Message>(dto)));
public ActionResult PutMessage(int id, MessageCreateDto dto)
{
var entity = _repository.Update(id, dto);
return(Ok(entity));
}
public ActionResult PostMessage([FromBody] MessageCreateDto dto)
{
var entity = _repository.Create(dto);
return(Ok(entity));
}
