public OperationResponse SendMessage(string title, string content, string senderLoginName, string receiverDisplayName) { Contact sender = contactRepository.GetContactByLoginName(senderLoginName); if (sender == null) { return(OperationResponse.Error("未获取到发件人信息")); } Contact receiver = contactRepository.GetContactByDisplayName(receiverDisplayName); if (receiver == null) { return(OperationResponse.Error("未获取到收件人信息")); } Message message = new Message(title, content, sender, receiver); if (sendMessageService.SendMessage(message)) { messageRepository.AddMessage(message); return(OperationResponse.Success("发送成功")); //return Context.Commit(); } else { return(OperationResponse.Error("发送失败")); } }
public void GetMessagesOnlyForSubscriptions() { _MessageRepository = new MessageRepository(_Clock.Object); var alice = new User { Name = "Alice" }; var bob = new User { Name = "Bob" }; var charlie = new User { Name = "Charlie" }; _Clock.Setup(a => a.CurrentDateAndTime).Returns(_CNow); _MessageRepository.AddMessage(alice, "I love the weather today"); _Clock.Setup(a => a.CurrentDateAndTime).Returns(_CNow); _MessageRepository.AddMessage(bob, "Damn! We lost!"); _Clock.Setup(a => a.CurrentDateAndTime).Returns(_CNow); _MessageRepository.AddMessage(charlie, "I’m in New York today! Anyone want to have a coffee?"); var wall = _MessageRepository.MessagesOfSubscribedUsers(new List<User> { charlie, alice }); Assert.AreEqual(wall.Count, 2); Assert.AreEqual( wall[0], new Message { Author = alice, Text = "I love the weather today", Time = _CNow }); Assert.AreEqual( wall[1], new Message { Author = charlie, Text = "I’m in New York today! Anyone want to have a coffee?", Time = _CNow }); }
public void Handle(TestNotificationSuccess message) { if (message != null) { _repository.AddMessage(message); } }
public bool Send([FromBody, Required] Message msg) { if (msg.to_id != null && msg.to_id.Trim().Length > 1 && !_clientRepository.Has(msg.to_id)) { return(false); } return(_msgService.AddMessage(msg)); }
public Task RunJob(Guid workerId, string jobName, string jobPayload) { return(_messageRepository.AddMessage(new JobAddedMessage { JobId = Guid.NewGuid(), WorkerId = workerId, Name = jobName, Payload = JObject.Parse(jobPayload) })); }
public async Task CreateThreadAndMessage(MessageDetails details) { var userEmail = await _userService.GetCurrentUserEmail(); var recievedBy = _userService.GetUserEmailById(details.RecievedBy.ToString()); var thread = await _threadRepository.AddThread(MessageDetails.FormThread(details, recievedBy), userEmail); await _messageRepository.AddMessage(MessageDetails.FormMessage(details, thread.Id), userEmail); }
public async Task <ActionResult <MessageDTO> > AddMessage(CreateMessageDTO createMessageDTO) { var senderUsername = User.GetUsername(); var sender = await _userRepository.GetUserByUsernameAsync(senderUsername); var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUsername); if (senderUsername == createMessageDTO.RecipientUsername) { return(BadRequest("You can't send a message to yourself")); } if (recipient == null) { return(NotFound()); } var message = new Message() { Sender = sender, SenderUsername = sender.UserName, Recipient = recipient, RecipientUsername = recipient.UserName, Content = createMessageDTO.Content }; _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { return(Ok(_mapper.Map <MessageDTO>(message))); } return(BadRequest("An error occurred sending the message")); }
public void Send(dynamic message, long from, long to) { var chats = _chatRepository.GetChats(to); var myChats = _chatRepository.GetChats(from); var Message = new ChatSendResult(); var MyMessage = new ChatSendResult(); var profile = _profileRepository.Profiles.FirstOrDefault(m => m.ProfileId == from); var DT = DateTime.Now; long messageId = _messageRepository.AddMessage(from, to, message, DT); Message.Message = CreateHtmlMessage(profile, message, DT, false, messageId); Message.MessageId = messageId; Message.From = new ChatSendProfile { FromId = @from }; MyMessage.Message = CreateHtmlMessage(profile, message, DT, true, messageId); MyMessage.MessageId = 0; foreach (var chat in myChats) { Clients.Client(chat.ConnectionId).SendMessage(MyMessage); } foreach (var chat in chats) { Clients.Client(chat.ConnectionId).SendMessage(Message); } }
public async Task SendMessage(CreateMessageDto createMessageDto) { var useremail = Context.User.GetUseremail(); if (useremail == createMessageDto.Recipientemail) { throw new HubException("You cannot send messages to yourself"); } var sender = await _userRepository.GetUserByEmailAsync(useremail); var recipient = await _userRepository.GetUserByEmailAsync(createMessageDto.Recipientemail); if (recipient == null) { throw new HubException("Not found User"); } var message = new Message { Sender = sender, Recipient = recipient, SenderName = sender.userFirstName, RecipientName = recipient.userFirstName, SenderEmail = sender.email, RecipientEmail = recipient.email, Content = createMessageDto.Content }; var groupName = GetGroupName(sender.email, recipient.email); var group = await _messageRepository.GetMessageGroup(groupName); if (group.Connections.Any(x => x.Useremail == recipient.email)) { } else { var connections = await _tracker.GetConnectionsForUser(recipient.email); if (connections != null) { await _prescenceHub.Clients.Clients(connections).SendAsync ( "NewMessageReceived", new { username = sender.userFirstName, useremail = sender.email } ); } } _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); } }
public IActionResult Messages(string to, string emailAddress, string message, string subject, bool isPriority) { // then show result // if failed Message msg = new Message(); msg.To = contactsRepo.GetUserByEmail(emailAddress); // If contact doesn't exist - add it if (msg.To == null) { contactsRepo.AddUser(new Models.User() { Name = to, EmailAddress = emailAddress }); msg.To = contactsRepo.GetUserByEmail(emailAddress); } msg.From = CurrentUser; msg.Subject = subject; msg.Msge = message; msg.IsPriority = isPriority; // Do message send here messagesRepo.AddMessage(msg); return(View("MessageSent", msg)); }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { var username = User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { return(BadRequest("You cannot send messages to yourself")); } var sender = await _userRepository.GetUserByUsernameAsync(username); var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername.ToLower()); if (recipient == null) { return(NotFound()); } var message = new Message { Sender = sender, Recipient = recipient, SenderUsername = sender.UserName, RecipientUsername = recipient.UserName, Content = createMessageDto.Content }; _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { return(Ok(_mapper.Map <MessageDto>(message))); } return(BadRequest("Failed to send message")); }
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 void AddMessageToRepeat(IMessage message, EndPoint receiver) { if (!_messageRepository.Exists(message.Receipt)) { _messageRepository.AddMessage(message, receiver); } }
public async Task CreateNewMessageForUser(string userToId, string userFromId, string content, TEAM team = null, string messageTypeName = null) { USER userFrom = null; MESSAGE_TYPE messageType = null; USER userTo = await _userRepository.GetUserById(userToId); if (userFromId != null) { userFrom = await _userRepository.GetUserById(userFromId); } if (messageTypeName != null) { messageType = _messageRepository.GetMessageTypeByName(messageTypeName); } MESSAGE message = new MESSAGE(); if (userTo != null) { message.USER_TO = userTo; message.TEXT = content; message.MESSAGE_TYPE = messageType ?? _messageRepository.GetMessageTypeByName(MessageTypeNames.INFO); message.USER_FROM = userFrom; message.SEND_DATE = DateTime.Now; message.TEAM = team; _messageRepository.AddMessage(message); } }
public async Task MarkDisconnectedWorkers() { try { var pastTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - (long)TimeSpan.FromMinutes(DeclareDisconnectedAfterMinutes).TotalMilliseconds; var oldMessages = await _messageRepository.GetMessagesBefore(pastTimestamp); var newMessages = await _messageRepository.GetMessagesAfter(pastTimestamp); var previouslyActiveWorkers = RceMessageHelpers.GetActiveWorkerIds(oldMessages).ToList(); var currentlyActiveWorkers = RceMessageHelpers.GetActiveWorkerIds(newMessages).ToList(); foreach (var disconnectedWorkerId in previouslyActiveWorkers.Except(currentlyActiveWorkers)) { if (await _messageRepository.IsDisconnected(disconnectedWorkerId)) { continue; } await _messageRepository.AddMessage(new WorkerRemovedMessage { WorkerId = disconnectedWorkerId, ConnectionStatus = WorkerRemovedMessage.Statuses.ConnectionLost }); } } catch (Exception e) { // ignore } }
public async Task <IActionResult> SendMessage() { MessageModel msg = new MessageModel(); byte[] file = null; //geting form data to model if (Request.Form["type"] == "file") { var ms = new MemoryStream(); Request.Form.Files.FirstOrDefault().CopyTo(ms); file = ms.ToArray(); } msg.ChannelId = Convert.ToInt32(Request.Form["channelId"]); msg.Type = Request.Form["type"]; msg.ContentText = Request.Form["contentText"]; msg.Color = Request.Form["color"]; msg.CreationTime = Request.Form["creationTime"]; msg.SenderId = Convert.ToInt32(Request.Cookies["userId"]); messageRep.AddMessage(msg, file); await _messageHub.Clients.All.SendAsync("newMsg", messageRep.GetMessageByDateAndSenderId(msg.CreationTime, msg.SenderId)); _logger.LogInformation("Message in channel with id " + msg.ChannelId.ToString() + " sended "); return(Ok()); }
public void Handle(TestEvent message) { if (message != null) { _repository.AddMessage(message); } }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { var username = User.GetUsername(); if (username == createMessageDto.RecipientUsername) { return(BadRequest("Không thể tự gữi tin nhắn cho bản thân")); } var sender = await _userRepository.GetUserByUsernameAsync(username); var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { return(NotFound()); } var message = new Message { Sender = sender, Recipient = recipient, Content = createMessageDto.Content, SenderUsername = sender.UserName, RecipientUsername = recipient.UserName, }; _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllChanges()) { return(_mapper.Map <MessageDto>(message)); } return(BadRequest("Tin nhắn chưa được gữi")); }
public async Task <ActionResult <Message> > PostMessage(Message message) { _messageRepo.AddMessage(message); await _messageRepo.SaveChangesAsync(); return(CreatedAtAction("GetMessage", new { id = message.MessageId }, message)); }
public async Task <IActionResult> Send(String userId, [FromBody] ContactMessageDto messageDto) { if (!_validationHelper.ValidateUserPermissions(User, userId)) { throw new AuthenticationException(); } if (messageDto == null) { throw new Exception("Something went wrong..."); } try { var message = AutoMapper.Mapper.Map <ContactMessageDoc>(messageDto); message.UserId = userId; message.Id = Guid.NewGuid(); await _messageRepository.AddMessage(message); await _emailHelper.SendMessage(message); } catch (Exception e) { throw; } return(Ok()); }
public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessg) { var userName = User.FindFirst(ClaimTypes.NameIdentifier)?.Value; if (userName == createMessg.recipientUsername.ToLower()) { return(BadRequest("Can not send message to yourself")); } var sender = await userRepository.GetUserByNameAsync(userName); var recipient = await userRepository.GetUserByNameAsync(createMessg.recipientUsername); if (recipient == null) { return(NotFound("Could not find the user")); } var messg = new Message { sender = sender, recipient = recipient, content = createMessg.content }; messageRepository.AddMessage(messg); if (await messageRepository.SaveAllAsync()) { return(Ok(this.mapper.Map <MessageDTO>(messg))); } return(BadRequest("Could not send the message")); }
public async Task SendMessage(CreateMessageDto createMessageDto) { var username = Context.User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send messsages to yourself"); } var sender = await _userRepository.GetUserByUsername(username); var recipient = await _userRepository.GetUserByUsername(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("User not found"); } var message = new Message { Sender = sender, Recipient = recipient, SenderUsername = sender.UserName, RecipientUsername = recipient.UserName, Content = createMessageDto.Content }; var groupName = GetGroupName(sender.UserName, recipient.UserName); var group = await _messageRepository.GetMessageGroup(groupName); if (group.Connection.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs }); } // var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName); // if (connections != null) // { // await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", // new {username = sender.UserName, knownAs = sender.KnownAs}); // } } _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); } ; }
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 async Task Send(string messageText) { AppUser u = await _userManager.GetUserAsync(Context.User); Message m = new Message(u.UserName, messageText, u.AvatarPath); await Clients.All.SendAsync("Send", m); messageRepository.AddMessage(m); }
public async Task <IActionResult> AddMessage(MessageMessage message) { if (IsLoginValid(message)) { await repo.AddMessage(message.Message); return(Ok()); } return(BadRequest()); }
public IActionResult Index(Message message) { if (ModelState.IsValid) { _messageRepository.AddMessage(message); return(RedirectToAction("TakForBesked")); } return(View(message)); }
public async Task <ActionResult <MessageDto> > CreateMessage([FromForm] CreateMessageDto createMessageDto) { var senderId = User.GetUserId(); if (senderId != createMessageDto.SenderId) { return(BadRequest()); } if (senderId.ToString().ToLower() == createMessageDto.RecipientId.ToString().ToLower()) { return(BadRequest("You cannot sent messages to yourself")); } var classifiedAdId = _classifiedAdsRepository.GetClassifiedAdDetail(createMessageDto.ClassifiedAdsId); if (classifiedAdId != null) { return(BadRequest("ClassifiedAd not exist")); } var sender = await _userManager.FindByIdAsync(senderId.ToLower()); var recipent = await _userManager.FindByIdAsync(createMessageDto.RecipientId.ToLower()); if (recipent == null) { return(NotFound()); } var message = new Message { Sender = sender, Recipient = recipent, SenderUsername = sender.UserName, RecipientUsername = recipent.UserName, SenderId = sender.Id, RecipientId = recipent.Id, Deleted = false, SenderDeleted = false, RecipientDeleted = false, Content = createMessageDto.Content, ClassifiedAdsId = createMessageDto.ClassifiedAdsId }; _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { return(Ok(_mapper.Map <MessageDto>(message))); } return(BadRequest("Failed to send message")); }
public MaintenanceServiceTests() { MessageList = MessageListStub.Get(); _messageRepositoryMock = Substitute.For <IMessageRepository>(); _messageRepositoryMock.AddMessage(Arg.Any <IRceMessage>()) .Returns(Task.CompletedTask) .AndDoes(e => MessageList.AddRange(e.Args().Cast <IRceMessage>())); _messageRepositoryMock.RemoveMessages(Arg.Any <IEnumerable <Guid> >()) .Returns(Task.CompletedTask) .AndDoes(e => MessageList.RemoveAll(f => ((IEnumerable <Guid>)e.Args().First()).Contains(f.MessageId))); _maintenanceService = new MaintenanceService(_messageRepositoryMock); }
public bool AddMessage(MessageDTO message) { try { _repository.AddMessage(message); } catch { return(false); } return(true); }
public RedirectToActionResult Contact(string message, string name) { userMessage = new UserMessage(); userMessage.MessageKey = Guid.NewGuid(); userMessage.Message = message; userMessage.Users.Add(new User() { UserName = name }); repo.AddMessage(userMessage); return(RedirectToAction("MessageResponses")); }
/// <summary> /// Creates a messaage /// </summary> /// <param name="message">The message to create</param> /// <returns>Whether the message was created</returns> public bool CreateMessage(AppMessage message) { bool created = false; if (message != null) { message.CreatedDate = new DateAndTime(TimeAndDateUtility.GetCurrentDate(), TimeAndDateUtility.GetCurrentTime()); created = _messageRepo.AddMessage(message); } return(created); }
public void CreateAndStoreAMessage() { _MessageRepository = new MessageRepository(_Clock.Object); _Clock.Setup(a => a.CurrentDateAndTime).Returns(_CNow); var alice = new User {Name = "Alice"}; _MessageRepository.AddMessage(alice, "I love the weather today"); var messagesOfUser = _MessageRepository.AllMessages(); Assert.AreEqual(messagesOfUser.Count, 1); Assert.AreEqual( messagesOfUser[0], new Message { Author = alice, Text = "I love the weather today", Time = _CNow }); }