public void MessageReadStateChanged(ChatUser mentionedUser, ChatMessage message, Notification notification)
{
foreach (var client in mentionedUser.ConnectedClients)
{
HubContext.Clients.Client(client.Id).messageReadStateChanged(message.Id, notification.Read);
}
}
public MessageViewModel(ChatMessage message)
{
Id = message.Id;
Content = message.Content;
User = new UserViewModel(message.User);
When = message.When;
}
private async void NotifyMyAndroid(ChatUser user, ChatMessage message)
{
var preferences = user.Preferences.PushNotifications.NMA;
// Check preferences validity
if (preferences == null || !preferences.Enabled || preferences.APIKey == null)
return;
var apikey = preferences.APIKey.Replace(" ", "");
if (apikey.Length != 48)
return;
// Create event and description content values and add ellipsis if over limits
var descriptionContent = message.Content;
if (descriptionContent.Length > 10000)
descriptionContent = descriptionContent.Substring(0, 10000 - 3) + "...";
var request = new Dictionary<string, string>
{
{"apikey", apikey},
{"application", "vox"},
{"event", GetTitle(message, 100)},
{"description", descriptionContent}
};
var result = await _httpClient.PostAsync("https://www.notifymyandroid.com/publicapi/notify", new FormUrlEncodedContent(request));
_logger.Log("Send NotifyMyAndroid: {0}", result.StatusCode);
}
public void Add(ChatMessage message)
{
RoomCache roomCache;
if (_cache.TryGetValue(message.Room.Name, out roomCache))
{
// Only cache if there's been a store created for this room already
roomCache.Add(message);
}
}
private string GetTitle(ChatMessage message, int lengthLimit = 0)
{
var title = string.Format("Message from {0} in #{1}", message.User.Name, message.Room.Name);
if (lengthLimit > 0 && title.Length > lengthLimit)
title = title.Substring(0, lengthLimit - 3) + "...";
return title;
}
public MessageViewModel(ChatMessage message)
{
Id = message.Id;
Content = message.Content;
HtmlContent = message.HtmlContent;
User = new UserViewModel(message.User);
When = message.When;
HtmlEncoded = message.HtmlEncoded;
MessageType = message.MessageType;
Source = message.Source;
ImageUrl = message.ImageUrl;
}
public MessageViewModel(ChatMessage message)
{
Id = message.Id;
Content = message.Content;
HtmlContent = message.HtmlContent;
User = new UserViewModel(message.User);
UserRoomPresence = ChatService.GetUserRoomPresence(message.User, message.Room);
When = message.When;
HtmlEncoded = message.HtmlEncoded;
MessageType = message.MessageType;
Source = message.Source;
ImageUrl = message.ImageUrl;
}
public ChatMessage AddMessage(ChatUser user, ChatRoom room, string content)
{
var chatMessage = new ChatMessage
{
Id = Guid.NewGuid().ToString("d"),
User = user,
Content = content,
When = DateTimeOffset.UtcNow,
Room = room
};
_repository.Add(chatMessage);
return chatMessage;
}
public void Send(ChatUser user, ChatMessage message)
{
if (user.Preferences == null || user.Preferences.PushNotifications == null)
return;
_logger.Log("Send user: {0}, message: {1}", user.Id, message.Id);
try
{
NotifyMyAndroid(user, message);
Pushover(user, message);
Pushbullet(user, message);
}
catch (Exception ex)
{
_logger.Log("Send error: {0}", ex.ToString());
}
}
public void PostNotification(ClientNotification notification, bool executeContentProviders)
{
string userId = Context.User.GetUserId();
ChatUser user = _repository.GetUserById(userId);
ChatRoom room = _repository.VerifyUserRoom(_cache, user, notification.Room);
// User must be an owner
if (room == null ||
!room.Owners.Contains(user) ||
(room.Private && !user.AllowedRooms.Contains(room)))
{
throw new HubException(LanguageResources.PostNotification_NotAllowed);
}
var chatMessage = new ChatMessage
{
Id = Guid.NewGuid().ToString("d"),
Content = notification.Content,
User = user,
Room = room,
HtmlEncoded = false,
ImageUrl = notification.ImageUrl,
Source = notification.Source,
When = DateTimeOffset.UtcNow,
MessageType = (int)MessageType.Notification
};
_repository.Add(chatMessage);
_repository.CommitChanges();
Clients.Group(room.Name).addMessage(new MessageViewModel(chatMessage), room.Name);
if (executeContentProviders)
{
var urls = UrlExtractor.ExtractUrls(chatMessage.Content);
if (urls.Count > 0)
{
_resourceProcessor.ProcessUrls(urls, Clients, room.Name, chatMessage.Id);
}
}
}
private void AddMentions(ChatMessage message)
{
var mentionedUsers = new List<ChatUser>();
foreach (var userName in MentionExtractor.ExtractMentions(message.Content))
{
ChatUser mentionedUser = _repository.GetUserByName(userName);
// Don't create a mention if
// 1. If the mentioned user doesn't exist.
// 2. If you mention yourself
// 3. If you're mentioned in a private room that you don't have access to
// 4. You've already been mentioned in this message
if (mentionedUser == null ||
mentionedUser == message.User ||
(message.Room.Private && !mentionedUser.AllowedRooms.Contains(message.Room)) ||
mentionedUsers.Contains(mentionedUser))
{
continue;
}
// mark as read if ALL of the following
// 1. user is not offline
// 2. user is not AFK
// 3. user has been active within the last 10 minutes
// 4. user is currently in the room
bool markAsRead = mentionedUser.Status != (int)UserStatus.Offline
&& !mentionedUser.IsAfk
&& (DateTimeOffset.UtcNow - mentionedUser.LastActivity) < TimeSpan.FromMinutes(10)
&& _repository.IsUserInRoom(_cache, mentionedUser, message.Room);
_service.AddNotification(mentionedUser, message, message.Room, markAsRead);
mentionedUsers.Add(mentionedUser);
}
if (mentionedUsers.Count > 0)
{
_repository.CommitChanges();
}
foreach (var user in mentionedUsers)
{
UpdateUnreadMentions(user);
}
}
public void Update(ChatMessage message)
{
ChatMessage updateMessage = _db.Messages.Where(p => p.Id == message.Id).FirstOrDefault();
if (updateMessage != null)
{
_db.Entry(updateMessage).CurrentValues.SetValues(message);
}
_db.SaveChanges();
}
public Notification GetNotificationByMessage(ChatMessage message, ChatUser user)
{
return _db.Notifications.SingleOrDefault(n => n.MessageKey == message.Key && n.UserKey == user.Key);
}
public void Add(ChatMessage message)
{
// We need to block here so that we always a
_populateHandle.Wait();
lock (_store)
{
if (_store.Count >= _size)
{
_store.RemoveFirst();
}
_store.AddLast(new MessageViewModel(message));
}
}
public Notification AddNotification(ChatUser mentionedUser, ChatMessage message, ChatRoom room, bool markAsRead)
{
var notification = _repository.GetNotificationByMessage(message, mentionedUser);
if (notification != null)
{
notification.Read = markAsRead;
return notification;
}
// We need to use the key here since messages might be a new entity
notification = new Notification
{
User = mentionedUser,
Message = message,
Read = markAsRead,
Room = room
};
_repository.Add(notification);
return notification;
}
public void Add(ChatMessage message)
{
}
private void ProcessUrls(IEnumerable<string> links, ChatRoom room, ChatMessage chatMessage)
{
// REVIEW: is this safe to do? We're holding on to this instance
// when this should really be a fire and forget.
var contentTasks = links.Select(_resourceProcessor.ExtractResource).ToArray();
Task.Factory.ContinueWhenAll(contentTasks, tasks =>
{
foreach (var task in tasks)
{
if (task.IsFaulted)
{
Trace.TraceError(task.Exception.GetBaseException().Message);
continue;
}
if (task.Result == null || String.IsNullOrEmpty(task.Result.Content))
{
continue;
}
// Try to get content from each url we're resolved in the query
string extractedContent = "<p>" + task.Result.Content + "</p>";
// If we did get something, update the message and notify all clients
chatMessage.Content += extractedContent;
// Notify the room
Clients[room.Name].addMessageContent(chatMessage.Id, extractedContent, room.Name);
// Commit the changes
_repository.CommitChanges();
}
});
}
public ChatMessage AddMessage(ChatUser user, ChatRoom room, string id, string content)
{
var chatMessage = new ChatMessage
{
Id = id,
User = user,
Content = content,
When = DateTimeOffset.UtcNow,
Room = room,
HtmlEncoded = false
};
_recentMessageCache.Add(chatMessage);
_repository.Add(chatMessage);
return chatMessage;
}
public void Add(ChatMessage message)
{
// There's no need to keep a collection of messages outside of a room
var room = _rooms.First(r => r == message.Room);
room.Messages.Add(message);
}
public void Update(ChatMessage message)
{
var room = _rooms.First(r => r == message.Room);
var updateMessage = room.Messages.Where(p => p.Id == message.Id).FirstOrDefault();
if (updateMessage != null)
{
room.Messages.Remove(updateMessage);
room.Messages.Add(message);
}
}
private void AddMentions(ChatMessage message)
{
foreach (var userName in MentionExtractor.ExtractMentions(message.Content))
{
ChatUser mentionedUser = _repository.GetUserByName(userName);
if (mentionedUser == null || mentionedUser == message.User)
{
continue;
}
_service.AddNotification(mentionedUser, message);
}
}
public void SendAsync(ChatUser user, ChatMessage message)
{
Task.Run(() => Send(user, message));
}
private async void Pushbullet(ChatUser user, ChatMessage message)
{
// Check preferences validity
var preferences = user.Preferences.PushNotifications.Pushbullet;
if (preferences == null || !preferences.Enabled || preferences.APIKey.IsNullOrWhiteSpace())
return;
// Get a list of all devices for user from pushbullet
var devices = await PushbulletRequest(preferences.APIKey, "devices", HttpMethod.Get);
if (devices.Item1.StatusCode != HttpStatusCode.OK)
{
_logger.Log("Pushbullet /api/devices request failed, StatusCode: {0}", devices.Item1.StatusCode);
return;
}
var deviceIdentifiers = devices.Item2["devices"]
.Select(d =>
{
var name = d["extras"]["nickname"].Value<string>();
if (name.Length < 1)
name = d["extras"]["model"].Value<string>();
return new Tuple<string, string>(d["id"].Value<string>(), name);
})
.ToList();
// Filter devices from stored names
if (!preferences.Devices.IsNullOrWhiteSpace())
{
// Parse devices from input
var names = PushbulletParseDevices(preferences.Devices).ToList();
// Filter devices based on names
deviceIdentifiers = deviceIdentifiers.Where(d => names.Contains(d.Item2)).ToList();
}
foreach (var device in deviceIdentifiers)
{
var request = new Dictionary<string, string>
{
{"device_id", device.Item1},
{"type", "note"},
{"title", GetTitle(message)},
{"body", message.Content}
};
var result = await PushbulletRequest(preferences.APIKey, "pushes", HttpMethod.Post, request);
_logger.Log("Send Pushbullet: {0}", result.Item1.StatusCode);
}
}
private void AddMentions(ChatMessage message)
{
bool anyMentions = false;
foreach (var userName in MentionExtractor.ExtractMentions(message.Content))
{
ChatUser mentionedUser = _repository.GetUserByName(userName);
// Don't create a mention if
// 1. If the mentioned user doesn't exist.
// 2. If you mention yourself
// 3. If you're mentioned in a private room that you don't have access to
if (mentionedUser == null ||
mentionedUser == message.User ||
(message.Room.Private && !mentionedUser.AllowedRooms.Contains(message.Room)))
{
continue;
}
anyMentions = true;
// Mark the notification as read if the user is online
bool markAsRead = mentionedUser.Status == (int)UserStatus.Active;
_service.AddNotification(mentionedUser, message, markAsRead);
}
if (anyMentions)
{
_repository.CommitChanges();
}
}
private async void Pushover(ChatUser user, ChatMessage message)
{
if (_settings.PushoverAPIKey.IsNullOrWhiteSpace())
return;
// Check preferences validity
var preferences = user.Preferences.PushNotifications.Pushover;
if (preferences == null || !preferences.Enabled || preferences.UserKey.IsNullOrWhiteSpace())
return;
var request = new Dictionary<string, string>
{
{"token", _settings.PushoverAPIKey},
{"user", preferences.UserKey},
{"title", GetTitle(message)},
{"message", message.Content}
};
if (!preferences.DeviceName.IsNullOrWhiteSpace())
request["device"] = preferences.DeviceName;
var result = await _httpClient.PostAsync("https://api.pushover.net/1/messages.json", new FormUrlEncodedContent(request));
_logger.Log("Send Pushover: {0}", result.StatusCode);
}
public void AddAttachment(ChatMessage message, string fileName, string contentType, long size, UploadResult result)
{
var attachment = new Attachment
{
Id = result.Identifier,
Url = result.Url,
FileName = fileName,
ContentType = contentType,
Size = size,
Room = message.Room,
Owner = message.User,
When = DateTimeOffset.UtcNow
};
_repository.Add(attachment);
}
public void AddNotification(ChatUser mentionedUser, ChatMessage message)
{
// We need to use the key here since messages might be a new entity
var notification = new Notification
{
User = mentionedUser,
Message = message
};
_repository.Add(notification);
}
public void AddNotification(ChatUser mentionedUser, ChatMessage message, ChatRoom room, bool markAsRead)
{
// We need to use the key here since messages might be a new entity
var notification = new Notification
{
User = mentionedUser,
Message = message,
Read = markAsRead,
Room = room
};
_repository.Add(notification);
}
public void Add(ChatMessage message)
{
PurgeMessagesIfNecessary();
_db.Messages.Add(message);
}
public void Add(ChatMessage message)
{
_db.Messages.Add(message);
}
public void Add(ChatMessage message)
{
_db.Messages.Add(message);
}
