public override MessageDto Send(MessageDto messageDto, Current current)
{
var message = MessageMapper.Map(messageDto);
var response = messageReceiver.Send(message);
return MessageMapper.Map(response).As<MessageDto>();
}
public void Add(MessageDto messageDto)
{
var doc = XDocument.Load(_messageDtosPath);
doc.Root.Add(new XElement("MessageDto",
new XElement("Username", messageDto.Username),
new XElement("Message", messageDto.Message),
new XElement("Sent", messageDto.Sent)));
doc.Save(_messageDtosPath);
}
public async Task <IActionResult> CreateMessage(Guid queuId, [FromBody] MessageCrateReqDto message)
{
this.logger.LogTrace("Call post with message label={0}", message.Label);
Guid newMessageId = await this.messageRepository.CreateAsync(queuId, message).ConfigureAwait(false);
await this.notificationSender.SendNotificationAsync(queuId, newMessageId).ConfigureAwait(false);
MessageDto createdMessage = await this.messageRepository.ReadById(newMessageId).ConfigureAwait(false);
return(this.CreatedAtAction(nameof(this.Read), new { queuId = queuId, messageId = newMessageId }, createdMessage));
}
public void ReturnBadRequestWhenCreateMessageCalledWithInvalidData(string title, string body)
{
var messageToCreate = new MessageDto
{
Title = title,
Body = body
};
IActionResult result = _controller.CreateMessage(messageToCreate);
Assert.IsType <BadRequestObjectResult>(result);
}
public User AddMessage(Guid userId, MessageDto messageDto)
{
var user = GetOne(u => u.Id.Equals(userId), nameof(User.Messages));
var message = _mapper.Map <Message>(messageDto);
user.Messages ??= new List <Message>();
user.Messages.Add(message);
Update(user);
Save();
return(user);
}
public void AddMessages(MessageDto messageDto)
{
_dbContext.Messages.Add(new Message
{
MessageId = messageDto.MessageId,
FromId = messageDto.FromId,
ToId = messageDto.ToId,
MessageText = messageDto.MessageText
});
_dbContext.SaveChanges();
}
public async Task DeleteUserMessage(MessageDto message)
{
using (var userRepository = _unitOfWork.Repository <User>())
{
var receiver = await userRepository.GetAsync(message.ReceiverId);
if (receiver != null && !string.IsNullOrEmpty(receiver.ConnectionId))
{
await _hubContext.Clients.Client(receiver.ConnectionId).onDeleteMessage(message.Id);
}
}
}
public async Task <MessageForSendDto <InlineKeyboardMarkup> > DefaultView(MessageDto messageDto)
{
var languageCode = messageDto.From.LanguageCode;
var inlineKeyboardMarkup = await CategoriesMenu(languageCode);
inlineKeyboardMarkup.AddLineButtons(await GetMainButtons());
var messageForSend = await CreateMessageForSend(messageDto, inlineKeyboardMarkup);
messageForSend.Text = messageForSend.Text = $"Вы ввели: {messageDto.Text}, выберите пункт меню.";
return(messageForSend);
}
public async Task HandleEventAsync(HookEventToPublish <PipelineRunStateChangedPayload> eventData)
{
var payload = eventData.Payload;
var message = new MessageDto
{
Text = payload.Message.Markdown,
Channel = "@nm"
};
await RocketChatWebHookClient.SendMessage(message);
}
public static Message ConvertToMessage(MessageDto message)
{
Message newMessage = new Message();
newMessage.Dest_Date = message.Dest_Date;
newMessage.Id = message.Id;
newMessage.Title = message.Title;
newMessage.UserID = message.UserID;
newMessage.Body = message.Body;
newMessage.EventId = message.EventId;
return(newMessage);
}
public IActionResult Create([FromBody] MessageDto item)
{
var model = _mapper.Map <MessageDto, Message>(item);
if (model == null)
{
return(BadRequest());
}
_repository.Insert(model);
return(CreatedAtRoute("GetMessage", new { id = item.Id }, item));
}
PeerClientChannelFactory_Pipeline_Should_Produce_Request_Object_PeerClientChannelFactory_Can_Process()
{
var recipient = PeerIdHelper.GetPeerId("recipient");
var sender = PeerIdHelper.GetPeerId("sender");
_peerIdValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);
_serverKeySigner.Sign(Arg.Any <byte[]>(), default).ReturnsForAnyArgs(_signature);
var correlationId = CorrelationId.GenerateCorrelationId();
var protocolMessage = new PingRequest().ToProtocolMessage(sender, correlationId);
var dto = new MessageDto(protocolMessage, recipient);
_clientCorrelationManager.TryMatchResponse(Arg.Any <ProtocolMessage>()).Returns(true);
_serverChannel.WriteOutbound(dto);
var sentBytes = _serverChannel.ReadOutbound <DatagramPacket>();
_serverCorrelationManager.ReceivedWithAnyArgs(1)
.AddPendingRequest(Arg.Any <CorrelatableMessage <ProtocolMessage> >());
_serverKeySigner.ReceivedWithAnyArgs(1).Sign(Arg.Any <byte[]>(), default);
_clientKeySigner.Verify(
Arg.Any <ISignature>(),
Arg.Any <byte[]>(),
default
)
.ReturnsForAnyArgs(true);
var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());
var messageStream = _clientFactory.InheritedHandlers.OfType <ObservableServiceHandler>().Single().MessageStream;
using (messageStream.Subscribe(observer))
{
_clientChannel.WriteInbound(sentBytes);
_clientChannel.ReadInbound <ProtocolMessage>();
_clientCorrelationManager.DidNotReceiveWithAnyArgs().TryMatchResponse(Arg.Any <ProtocolMessage>());
_clientKeySigner.ReceivedWithAnyArgs(1).Verify(null, null, null);
_testScheduler.Start();
observer.Received.Count.Should().Be(1);
observer.Received.Single().Payload.CorrelationId.ToCorrelationId().Id.Should().Be(correlationId.Id);
}
await _serverChannel.DisconnectAsync();
await _clientChannel.DisconnectAsync();
}
/// <summary>
/// Message from user
/// </summary>
/// <param name="message"></param>
public void SendMessage(MessageDto message)
{
if (authorized)
{
Log.Trace("Отправка сообщения на сервер");
MainServer.Current.SendMessage(this, message);
}
else
{
Log.Trace("Отправка сообщения не удалась, пользователь не авторизован");
}
}
public ActionResult <MessageDto> AddMessage(string chatId, [FromBody] MessageDto message)
{
var chat = _chatService.GetChat(chatId);
if (!(HttpContext.User.HasClaim("UserId", chat.ParticipantA) || HttpContext.User.HasClaim("UserId", chat.ParticipantB)))
{
return(StatusCode(403));
}
var sentMessage = _chatService.AddMessage(chatId, _mapper.Map <Message>(message));
return(Ok(_mapper.Map <MessageDto>(sentMessage)));
}
public void ReturnNoContentWhenUpdateMessageCalled()
{
var updatedMessage = new MessageDto
{
Title = "updatedMessageTitle",
Body = "updatedMessageBody"
};
IActionResult result = _controller.UpdateMessage(1, updatedMessage);
Assert.IsType <NoContentResult>(result);
}
public void ReturnCreatedAtRouteWhenCreateMessageCalled()
{
var messageToCreate = new MessageDto
{
Title = "createMessageTitle",
Body = "createMessageBody"
};
IActionResult result = _controller.CreateMessage(messageToCreate);
Assert.IsType <CreatedAtRouteResult>(result);
}
public async Task Delete(MessageDto messageDto)
{
if (messageDto != null)
{
// send id to hub
await Client.Delete(messageDto.Id);
Messages.Remove(messageDto);
StateHasChanged();
}
}
public MessageEntity MapFromDtoToEntity(MessageDto dto)
{
return(new MessageEntity()
{
MessageId = dto.MessageId,
Content = dto.Content,
Date = dto.Date,
ChatroomId = dto.ChatroomId,
UserSender = dto.UserSender,
IsBot = dto.IsBot
});
}
public async Task <bool> UpdateAsync(MessageDto message)
{
if (!await MessageExist(message.Id))
{
return(false);
}
_context.MessageDto.Update(message);
await _context.SaveChangesAsync();
return(true);
}
public async Task <MessageForSendDto <InlineKeyboardMarkup> > StartView(MessageDto messageDto)
{
var languageCode = messageDto.From.LanguageCode;
var inlineKeyboardMarkup = await CategoriesMenu(languageCode);
inlineKeyboardMarkup.AddLineButtons(await GetMainButtons());
var messageForSend = await CreateMessageForSend(messageDto, inlineKeyboardMarkup);
messageForSend.Text = $"All categories";
return(messageForSend);
}
private async Task SendToUser(MessageDto message)
{
using (var userRepository = _unitOfWork.Repository <User>())
{
var receiver = await userRepository.GetAsync(message.ReceiverId);
if (receiver != null && !string.IsNullOrEmpty(receiver.ConnectionId))
{
await Clients.Client(receiver.ConnectionId).onAddMessage(message);
}
}
}
public async Task <IActionResult> AddMessage([Required][FromBody] MessageModel message)
{
if (ModelState.IsValid)
{
MessageDto messageDto = await GetFullInfoMessageDto(message);
messageDto = await _messageService.Create(messageDto);
return(Ok(_mapper.Map <MessageDto, MessageModel>(messageDto)));
}
return(BadRequest(ModelState));
}
public void InsertMessage_ValidProperty_ShouldAddMessageAnd_2Notifications_If_Consultant()
{
_controller.MockCurrentUserAndRole("5", _userName, UserRoles.Consultant);
var orderId = "1";
Order order = new Order()
{
Id = orderId
};
var consultant = new Consultant()
{
SeContactUid = 1
};
var tEmail = "*****@*****.**";
var transferee = new Transferee()
{
Id = "1", Email = tEmail
};
_mockConsultantsRepository.Setup(c => c.GetConsultantBySeContactUid(1)).Returns(consultant);
_mockTransfereesRepository.Setup(t => t.GetTransfereeByEmail(tEmail)).Returns(transferee);
_mockRepository.Setup(o => o.GetOrderById(orderId)).Returns(order);
order.Consultant = consultant;
order.Transferee = transferee;
var propId = "1";
HomeFindingProperty prop = new HomeFindingProperty()
{
Id = propId
};
_mockHFPRepository.Setup(r => r.GetHomeFindingPropertyById(propId)).Returns(prop);
Message mess = new Message()
{
HomeFindingPropertyId = propId
};
MessageDto dto = new MessageDto()
{
HomeFindingPropertyId = propId, OrderId = orderId
};
var result = _controller.UpsertPropertyMessage(dto);
prop.Messages.Count.Should().Be(1);
var rl = _controller.User.IsInRole(UserRoles.Consultant);
rl.Should().BeTrue();
transferee.UserNotifications.Count().Should().Be(1);
result.Should().BeOfType <System.Web.Http.Results.OkResult>();
}
public async Task <MessageDto> CreateChannelMessageAsync(MessageDto message)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
ChannelUser senderChannelUser = await context.ChannelUsers
.Include(opt => opt.Channel)
.FirstOrDefaultAsync(opt =>
opt.ChannelId == message.ConversationId &&
opt.UserId == message.SenderId &&
opt.ChannelUserRole >= ChannelUserRole.Administrator)
.ConfigureAwait(false);
if (senderChannelUser == null)
{
UserVm user = await LoadUsersService.GetUserAsync(message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
if (user == null)
{
throw new UserNotFoundException(message.SenderId.GetValueOrDefault());
}
ChannelVm channel = await LoadChannelsService.GetChannelByIdAsync(message.ConversationId).ConfigureAwait(false);
if (channel == null)
{
throw new ConversationNotFoundException(message.ConversationId);
}
throw new PermissionDeniedException();
}
if (senderChannelUser.ChannelUserRole == ChannelUserRole.Administrator && (senderChannelUser.Banned || senderChannelUser.Deleted))
{
throw new PermissionDeniedException();
}
message.NodesIds = senderChannelUser.Channel.NodesId?.ToList();
SaveMessageAsync(message);
return(message);
}
}
catch (PostgresException ex)
{
if (ex.ConstraintName == "FK_Messages_Channels_ChannelId")
{
throw new ConversationNotFoundException(message.ConversationId);
}
else if (ex.ConstraintName == "Messages_SenderId_fkey")
{
throw new UserNotFoundException(message.SenderId.GetValueOrDefault());
}
throw new MessageException("Database error.", ex);
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
if (request.Message.Attachments != null && request.Message.Attachments.Any())
{
var isValid = await attachmentsService.CheckEditedMessageAttachmentsAsync(
request.Message, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
if (!isValid)
{
throw new InvalidAttachmentsException();
}
}
MessageDto edited = await updateMessagesService.EditMessageAsync(
MessageConverter.GetMessageDto(request.Message),
clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
conversationsNoticeService.SendMessagesUpdatedNoticeAsync(
request.Message.ConversationId.GetValueOrDefault(),
request.Message.ConversationType,
new List <MessageDto> {
edited
},
clientConnection.UserId.GetValueOrDefault(),
false,
clientConnection);
nodeNoticeService.SendMessagesUpdateNodeNoticeAsync(
new List <MessageDto> {
edited
},
edited.ConversationId,
edited.ConversationType,
clientConnection.UserId.GetValueOrDefault());
UsersConversationsCacheService.Instance.MessageEditedUpdateConversations(edited);
return(new MessagesResponse(request.RequestId,
new List <MessageVm>
{
MessageConverter.GetMessageVm(edited, clientConnection.UserId)
}));
}
catch (InvalidAttachmentsException ex)
{
Logger.WriteLog(ex);
return(new ResultResponse(request.RequestId, "Invalid attachments.", ErrorCode.InvalidAttachment));
}
catch (ObjectDoesNotExistsException ex)
{
Logger.WriteLog(ex);
return(new ResultResponse(request.RequestId, "Message not found.", ErrorCode.ObjectDoesNotExists));
}
}
public void SendMessage(IContract userContract, MessageDto message)
{
message.Date = DateTime.Now;
message.Room = Room.ToRoomDto(Room);
using (Context db = new Context(ServerHost.Settings.Ef))
{
User existUser = SearchUser(db, userContract.User.Name);
var existRoom = db.Rooms.Where(_ => _.Id == Room.Id).FirstOrDefault();
if (message is FileMessageDto fileMessage)
{
FileMessage userMessage = new FileMessage
{
Date = fileMessage.Date,
FileName = fileMessage.FileName,
FileWeight = fileMessage.FileWeight,
Text = fileMessage.MessageText,
User = existUser,
//UserName = existUser.Name,
Room = existRoom,
//RoomId = existRoom.Id
};
userMessage.Content = new BinaryContent {
Content = userContract.GetUserFile(), Message = userMessage
};
if (userMessage.Content.Content != null && fileMessage.Hash == GetMd5Hash(userMessage.Content.Content))
{
db.FileMessages.Add(userMessage);
db.Messages.Add(userMessage);
}
else
{
db.Messages.Add(new Message(existRoom, existUser, message));
}
}
else
{
//existUser.Messages.Add(new Message(Room, existUser, message));
//var u = db.Users.Where(_ => _.Name == userContract.User.Name).FirstOrDefault();
db.Messages.Add(new Message(existRoom, existUser, message));
}
db.SaveChanges();
}
UserContracts.ToList().ForEach(user =>
{
try
{
user.SendReply(Room.ToRoomDto(Room), message);
}
catch { }
});
}
public async void CreateMessage()
{
var newMessage = new MessageDto()
{
MessageText = "New MessageDto",
SenderFirstName = "First",
SenderLastName = "CoachDto"
};
var result = await _service.CreateMessage(newMessage);
Assert.NotEqual(0, result);
}
public static ContactFormViewModel ToContactFormViewModel(this MessageDto entity)
{
return(new ContactFormViewModel()
{
Id = entity.Id,
Name = entity.Name,
Email = entity.Email,
Message = entity.Message,
Subject = entity.Subject,
Phone = entity.Phone,
MessageStatus = (SmtpStatusCode)entity.MessageStatus
});
}
private void OnMessageReceived(MessageDto message)
{
lock (_lock)
{
if (_response == null)
{
_response = NewResponse();
}
_response.Messages.Add(message);
}
_responseEvent.Set();
}
public IActionResult Index(string errorMessage = null, MessageDto message = null)
{
if (errorMessage != null)
{
ViewBag.ErrorMessage = errorMessage;
if (message != null)
{
return(View(message));
}
}
return(View());
}
public async Task Enqueue(ConversationDto conversation, MessageDto message)
{
var queue = await StateManager.GetOrAddAsync <IReliableQueue <SmsModel> >("SMSQueue");
using var tx = StateManager.CreateTransaction();
await queue.EnqueueAsync(tx, new SmsModel
{
Conversation = conversation,
Message = message
});
await tx.CommitAsync();
}
public async Task <IActionResult> AddMessage(int id, MessageDto message)
{
UserConversation conversation = _conversationService.GetUserConversation(id);
if (conversation == null)
{
return(Forbid());
}
Message messageResult = await _conversationService.AddMessageAsync(conversation, new Message { Text = message.Text });
return(Ok(_mapper.Map <MessageDto>(messageResult)));
}
private void SendSystemMessage(Guid sessionId, string message)
{
if (sessionId == Guid.Empty)
throw new ArgumentNullException("sessionId");
if (string.IsNullOrWhiteSpace(message))
throw new ArgumentNullException("message");
var m = new MessageDto
{
MessageId = Guid.NewGuid(),
PostDateTime = DateTime.Now,
MessageText = message,
ParticipantId = null, // DAL will handle this
SessionId = sessionId,
};
SaveMessageAsync(m, null); // sys message
Clients.Group(sessionId.ToString("N")).broadcastMessage(null, message);
}
public SimplePosologyAlertDto(ServicePoso.simplePosologyAlert alert)
{
this.Indication = alert.indication!=null?new IndicationDto(alert.indication):null;
this.PosologyAlert = alert.posologyAlert!=null?new MessageDto(alert.posologyAlert.messageType, alert.posologyAlert.text):null;
}
private static void SaveMessageAsync(MessageDto m, Guid? clientId)
{
Task.Run(() =>
{
using (var db = new Db())
{
db.SaveMessage(m, clientId);
}
});
}
public SimplePosologyAlertDto(VidalAPI.Domain.SimplePosologyAlert alert)
{
this.Indication = alert.Indication!=null?new IndicationDto(alert.Indication):null;
this.PosologyAlert = alert.PosologyAlert!=null?new MessageDto(alert.PosologyAlert.MessageType, alert.PosologyAlert.Text):null;
}
public void SpamEveryone(MessageDto message)
{
// Call the addMessage method on all clients
Clients.All.addMessage(message.Message, message.Name, message.Color ?? "#FFF");
}
public void SendMessage(Guid sessionId, Guid clientId, string message)
{
if (sessionId == Guid.Empty)
throw new ArgumentNullException("sessionId");
if (clientId == Guid.Empty)
throw new ArgumentNullException("clientId");
if (string.IsNullOrWhiteSpace(message))
throw new ArgumentNullException("message");
var user = GetUser(Context.ConnectionId);
if (user == null) return;
var m = new MessageDto
{
MessageId = Guid.NewGuid(),
PostDateTime = DateTime.Now,
MessageText = message,
ParticipantId = null, // DAL will handle this
SessionId = sessionId,
};
SaveMessageAsync(m, clientId); // user message
Clients.Group(sessionId.ToString("N")).broadcastMessage(user.Name, message);
}
private void _dbSave(string message, int toUserDbId)
{
var msg = new MessageDto();
msg.FromUserId = _authProvider.CurrentUserId;
msg.ToUserId = toUserDbId;
msg.DateSent = DateTime.Now;
msg.MsgText = message;
_messageService.Add(msg);
}
