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); }