/// <summary>
/// Inserts a chat user.
/// </summary>
/// <param name="chatRoom">The chat room which contains the user.</param>
/// <param name="chatUser">The chat user to add.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task AddUserAsync(ChatRoomInfo chatRoom, ChatUserInfo chatUser, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
if (chatUser == null)
{
throw new ArgumentNullException("chatUser");
}
chatUser.RoomId = chatRoom.Id;
var users = s_users.Get(chatRoom.Id) as ConcurrentDictionary <string, ChatUserInfo>;
if (users == null)
{
users = new ConcurrentDictionary <string, ChatUserInfo>();
}
if (users.TryAdd(chatUser.UserName, chatUser))
{
s_users.Set(chatRoom.Id, users, DateTimeOffset.MaxValue);
}
return(Task.FromResult(0));
}
/// <summary>
/// Gets all the users for the given chat room.
/// </summary>
/// <param name="chatRoom">The chat room which contains the chat users.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// The chat users.
/// </returns>
public virtual async Task <ContactItem> GetContactByUserNameAsync(ChatRoomInfo chatRoom, string userName, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (ProjectManagerFactory == null)
{
throw new InvalidOperationException("ProjectManagerFactory is not supported.");
}
var projectManager = ProjectManagerFactory();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
if (chatRoom.ProjectId == null)
{
return(null);
}
var project = await projectManager.FindByIdAsync((int)chatRoom.ProjectId, cancellationToken);
if (project == null)
{
throw new InvalidOperationException("The project was not found.");
}
return(await projectManager.GetContactByMailAsync(project, userName, ContactField.None, cancellationToken));
}
/// <summary>
/// Inserts a chat message.
/// </summary>
/// <param name="chatRoom">The chat room which contains the chat message.</param>
/// <param name="chatMessage">The chat message to add.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
protected virtual async Task LogMessageAsync(ChatRoomInfo chatRoom, ChatMessageInfo chatMessage, CancellationToken cancellationToken)
{
ThrowIfDisposed();
var logManager = GetLogManager();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
if (chatMessage == null)
{
throw new ArgumentNullException("chatMessage");
}
if (chatMessage.From == null)
{
throw new InvalidOperationException("The user 'from' is unspecified.");
}
if (chatMessage.To == null)
{
throw new InvalidOperationException("The user 'to' is unspecified.");
}
if (chatMessage.From.Admin)
{
await logManager.LogAsync(new EventItem
{
AnonymId = GuidUtility.NewSequentialGuid(),
ObjectType = ObjectType.Message,
ObjectId = chatRoom.PageId,
Contact = chatMessage.From.ContactId != null ? new AccountItem {
Id = (int)chatMessage.From.ContactId
} : null,
Project = chatRoom.ProjectId != null ? new UniqueItem {
Id = (int)chatRoom.ProjectId
} : null,
ClientId = chatMessage.To.IPAddress,
CustomUri = chatMessage.To.NickName + " >>",
Message = chatMessage.Message
}, chatRoom.Users.Values, cancellationToken);
}
if (chatMessage.To.Admin)
{
await logManager.LogAsync(new EventItem
{
AnonymId = GuidUtility.NewSequentialGuid(),
ObjectType = ObjectType.Message,
ObjectId = chatRoom.PageId,
Contact = chatMessage.From.ContactId != null ? new AccountItem {
Id = (int)chatMessage.From.ContactId
} : null,
Project = chatRoom.ProjectId != null ? new UniqueItem {
Id = (int)chatRoom.ProjectId
} : null,
ClientId = chatMessage.From.IPAddress,
CustomUri = "<< " + chatMessage.From.NickName,
Message = chatMessage.Message
}, chatRoom.Users.Values, cancellationToken);
}
}
/// <summary>
/// Returns true if the given user is an administrator.
/// </summary>
/// <param name="chatRoom">The chat room.</param>
/// <returns>
/// A value indicating whether the user is an administator.
/// </returns>
public virtual bool IsAdmin(ChatRoomInfo chatRoom, string userName)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
return(chatRoom.Users.ContainsKey(userName));
}
/// <summary>
/// Removes a chat room.
/// </summary>
/// <param name="chatRoom">The chat room to remove.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task DeleteAsync(ChatRoomInfo chatRoom, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
return(Store.DeleteAsync(chatRoom, cancellationToken));
}
/// <summary>
/// Removes a chat room.
/// </summary>
/// <param name="chatRoom">The chat room to remove.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task DeleteAsync(ChatRoomInfo chatRoom, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
s_rooms.Remove(chatRoom.Id);
return(Task.FromResult(0));
}
/// <summary>
/// Updates a chat room.
/// </summary>
/// <param name="chatRoom">The chat room to update.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task UpdateAsync(ChatRoomInfo chatRoom, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
//Rooms.Set(chatRoom.Id, chatRoom, DateTimeOffset.MaxValue);
return(Task.FromResult(0));
}
/// <summary>
/// Gets all the Connection IDs for the given chat room.
/// </summary>
/// <param name="chatRoom">The chat room.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task <IList <string> > GetConnectionsAsync(ChatRoomInfo chatRoom, CancellationToken cancellationToken)
{
ThrowIfDisposed();
var userConnectionStore = GetUserConnectionStore();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
return(userConnectionStore.GetConnectionsAsync(chatRoom, cancellationToken));
}
/// <summary>
/// Removes a chat message.
/// </summary>
/// <param name="chatRoom">The chat room which contains the chat message.</param>
/// <param name="chatMessage">The chat message to remove.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task RemoveMessageAsync(ChatRoomInfo chatRoom, ChatMessageInfo chatMessage, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
if (chatMessage == null)
{
throw new ArgumentNullException("chatMessage");
}
return(Task.FromResult(0));
}
/// <summary>
/// Gets the information from the cache for the chat user associated with the specified unique identifier.
/// </summary>
/// <param name="chatRoom">The chat site which owns the user.</param>
/// <param name="userName">The user name for the item to be found.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task <ChatUserInfo> GetUserByUserNameAsync(ChatRoomInfo chatRoom, string userName, CancellationToken cancellationToken)
{
ThrowIfDisposed();
var userStore = GetUserStore();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
if (string.IsNullOrEmpty(userName))
{
throw new ArgumentNullException("userName");
}
return(userStore.GetUserByUserNameAsync(chatRoom, userName, cancellationToken));
}
//
// IChatRoomUserStore
//
/// <summary>
/// Gets all the users for the given chat room.
/// </summary>
/// <param name="chatRoom">The chat room which contains the chat users.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task <IList <ChatUserInfo> > GetUsersAsync(ChatRoomInfo chatRoom, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
var users = s_users.Get(chatRoom.Id) as ConcurrentDictionary <string, ChatUserInfo>;
if (users != null)
{
return(Task.FromResult <IList <ChatUserInfo> >(users.Values.ToList()));
}
return(Task.FromResult <IList <ChatUserInfo> >(new List <ChatUserInfo>()));
}
//
// IChatRoomConnectionStore
//
/// <summary>
/// Gets all the connections for the given chat room.
/// </summary>
/// <param name="chatRoom">The chat room.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task <IList <string> > GetConnectionsAsync(ChatRoomInfo chatRoom, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
var connections = s_roomConnections.Get(chatRoom.Id) as ImmutableHashSet <string>;
if (connections != null)
{
return(Task.FromResult <IList <string> >(connections.ToList()));
}
return(Task.FromResult <IList <string> >(new List <string>()));
}
/// <summary>
/// Inserts a chat user.
/// </summary>
/// <param name="chatRoom">The chat room which contains the user.</param>
/// <param name="chatUser">The chat user to add.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual async Task AddUserAsync(ChatRoomInfo chatRoom, ChatUserInfo chatUser, CancellationToken cancellationToken)
{
ThrowIfDisposed();
var userStore = GetUserStore();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
if (chatUser == null)
{
throw new ArgumentNullException("chatUser");
}
await userStore.AddUserAsync(chatRoom, chatUser, cancellationToken);
await UpdateAsync(chatRoom, cancellationToken);
}
/// <summary>
/// Removes a chat message.
/// </summary>
/// <param name="chatRoom">The chat room which contains the chat message.</param>
/// <param name="chatMessage">The chat message to remove.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual async Task RemoveMessageAsync(ChatRoomInfo chatRoom, ChatMessageInfo chatMessage, CancellationToken cancellationToken)
{
ThrowIfDisposed();
var userMessage = GetUserMessageStore();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
if (chatMessage == null)
{
throw new ArgumentNullException("chatMessage");
}
await userMessage.RemoveMessageAsync(chatRoom, chatMessage, cancellationToken);
await UpdateAsync(chatRoom, cancellationToken);
}
/// <summary>
/// Creates a room for the given page.
/// </summary>
/// <param name="manager">The portal manager.</param>
/// <param name="portal">The site.</param>
/// <param name="page">The page.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// The created chat room.
/// </returns>
private async Task <ChatRoomInfo> CreateAsync(PortalManager manager, PortalItem portal, PageItem page, CancellationToken cancellationToken)
{
var chatRoom = new ChatRoomInfo
{
Id = portal.Id.ToString(),
PageId = page.Id,
PortalId = portal.Id,
ProjectId = portal.Project?.Id
};
foreach (var account in portal.Owners)
{
chatRoom.Users.Add(account.Email.Address, account);
}
await Store.CreateAsync(chatRoom, cancellationToken);
return(chatRoom);
}
/// <summary>
/// Gets the chat user for the caller.
/// </summary>
/// <param name="chatRoom">The chat room.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// The chat user.
/// </returns>
private async Task <ChatUserInfo> GetCallerUserAsync(ChatRoomInfo chatRoom = null,
CancellationToken cancellationToken = default(CancellationToken))
{
if (chatRoom == null)
{
chatRoom = await GetCallerRoomAsync(cancellationToken);
}
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
string user = Clients.Caller.user;
if (user != null)
{
return(await ChatManager.GetUserByUserNameAsync(chatRoom, user, cancellationToken));
}
return(null);
}
/// <summary>
/// Gets the information from the cache for the chat user associated with the specified unique identifier.
/// </summary>
/// <param name="chatRoom">The chat room which owns the user.</param>
/// <param name="userName">The user name for the item to be found.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual Task <ChatUserInfo> GetUserByUserNameAsync(ChatRoomInfo chatRoom, string userName, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (chatRoom == null)
{
throw new ArgumentNullException("chatRoom");
}
if (userName == null)
{
throw new ArgumentNullException("userName");
}
var user = default(ChatUserInfo);
var users = s_users.Get(chatRoom.Id) as ConcurrentDictionary <string, ChatUserInfo>;
if (users != null)
{
users.TryGetValue(userName, out user);
}
return(Task.FromResult(user));
}
/// <summary>
/// Gets or adds a new user to the given room.
/// </summary>
/// <param name="room">The room.</param>
/// <param name="userName">The user name.</param>
/// <param name="nickName">The nick name.</param>
/// <param name="ipAddress">The IP address.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// The chat user.
/// </returns>
private async Task <ChatUserInfo> GetOrAddRoomUserAsync(ChatRoomInfo room, string userName, string ipAddress,
CancellationToken cancellationToken = default(CancellationToken))
{
int? contactId = null;
string nickName = null;
if (!string.IsNullOrEmpty(userName))
{
var contact = await ChatManager.GetContactByUserNameAsync(room, userName, cancellationToken);
if (contact != null)
{
contactId = contact.Id;
userName = contact.Email.Address;
nickName = contact.NickName ?? contact.Email.Name ?? contact.FirstName ?? contact.LastName;
}
}
if (string.IsNullOrEmpty(userName))
{
userName = ChatManager.GenerateClientId(ipAddress);
nickName = nickName ?? userName;
}
var user = await ChatManager.GetUserByUserNameAsync(room, userName, cancellationToken);
if (user == null)
{
user = new ChatUserInfo
{
ContactId = contactId,
ClientId = ChatManager.GenerateClientId(ipAddress),
IPAddress = ipAddress,
UserName = userName,
NickName = nickName
};
await ChatManager.AddUserAsync(room, user, cancellationToken);
}
return(user);
}
