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