public static ChatUser GetUser(this IJabbrRepository repository, ClaimsPrincipal principal)
{
string identity = principal.GetClaimValue(ClaimTypes.NameIdentifier);
string providerName = principal.GetIdentityProvider();
return(repository.GetUserByIdentity(providerName, identity));
}
private static void UpdateUnreadCountInChat(IJabbrRepository repository, IChatNotificationService notificationService,
ChatUser user)
{
var unread = repository.GetUnreadNotificationsCount(user);
notificationService.UpdateUnreadMentions(user, unread);
}
public Chat(IApplicationSettings settings, IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository)
{
_settings = settings;
_resourceProcessor = resourceProcessor;
_service = service;
_repository = repository;
}
public Chat(IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository, ICache cache)
{
_resourceProcessor = resourceProcessor;
_service = service;
_repository = repository;
_cache = cache;
}
public ChatService(ICache cache, IRecentMessageCache recentMessageCache, IJabbrRepository repository)
: this(cache,
recentMessageCache,
repository,
ApplicationSettings.GetDefaultSettings())
{
}
public Chat(IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository, ICache cache)
{
_resourceProcessor = resourceProcessor;
_service = service;
_repository = repository;
_cache = cache;
}
private static void Sweep(Func <IJabbrRepository> repositoryFactory)
{
if (_sweeping)
{
return;
}
_sweeping = true;
try
{
using (IJabbrRepository repo = repositoryFactory())
{
MarkInactiveUsers(repo);
repo.CommitChanges();
}
}
catch (Exception ex)
{
Elmah.ErrorLog.GetDefault(null).Log(new Error(ex));
}
finally
{
_sweeping = false;
}
}
public Chat(IApplicationSettings settings, IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository)
{
_settings = settings;
_resourceProcessor = resourceProcessor;
_service = service;
_repository = repository;
}
private void RemoveOfflineUsers(ILogger logger, IJabbrRepository repo)
{
var offlineUsers = new List <ChatUser>();
IQueryable <ChatUser> users = repo.GetOnlineUsers();
foreach (var user in users.ToList())
{
if (user.ConnectedClients.Count == 0)
{
logger.Log("{0} has no clients. Marking as offline", user.Name);
// Fix users that are marked as inactive but have no clients
user.Status = (int)UserStatus.Offline;
offlineUsers.Add(user);
}
}
if (offlineUsers.Count > 0)
{
PerformRoomAction(offlineUsers, async roomGroup =>
{
foreach (var user in roomGroup.Users)
{
await _hubContext.Clients.Group(roomGroup.Room.Name).leave(user, roomGroup.Room.Name);
}
});
repo.CommitChanges();
}
}
public AccountController(
UserManager <ChatUser> userManager,
SignInManager <ChatUser> signInManager,
ApplicationSettings applicationSettings,
IHttpContextAccessor context,
IJabbrRepository repository,
IOptions <ApplicationSettings> settings,
IEmailSender emailsender
// IOptions<ApplicationSettings> settings,
// IMembershipService membershipService,
// IAuthenticationService authService
// IChatNotificationService notificationService,
// IUserAuthenticator authenticator,
// IEmailService emailService
)
{
// _settings = settings.Value;
// _authService = authService;
// _membershipService = membershipService;
_context = context;
_settings = applicationSettings;
_repository = repository;
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailsender;
}
private static IPagedList <NotificationViewModel> GetNotifications(IJabbrRepository repository, ChatUser user, bool all = false,
int page = 1, int take = 20, string roomName = null)
{
IQueryable <Notification> notificationsQuery = repository.GetNotificationsByUser(user);
if (!all)
{
notificationsQuery = notificationsQuery.Unread();
}
if (!String.IsNullOrWhiteSpace(roomName))
{
var room = repository.VerifyRoom(roomName);
if (room != null)
{
notificationsQuery = notificationsQuery.ByRoom(roomName);
}
}
return(notificationsQuery.OrderByDescending(n => n.Message.When)
.Select(n => new NotificationViewModel()
{
NotificationKey = n.Key,
FromUserName = n.Message.User.Name,
FromUserImage = n.Message.User.Hash,
Message = n.Message.Content,
HtmlEncoded = n.Message.HtmlEncoded,
RoomName = n.Room.Name,
Read = n.Read,
When = n.Message.When
})
.ToPagedList(page, take));
}
public TestableChat(IJabbrRepository repository, OptionsManager <ApplicationSettings> settings, ChatService chatService, Mock <IConnection> mockConnection)
: base(repository, settings, new Mock <RecentMessageCache>().Object, chatService)
{
Repository = repository;
ChatService = chatService;
MockConnection = mockConnection;
Settings = settings;
}
public TestableChat(Mock <ContentProviderProcessor> mockedResourceProcessor, Mock <IChatService> mockedChatService, IJabbrRepository repository, Mock <IConnection> connection)
: base(mockedResourceProcessor.Object, mockedChatService.Object, repository, new Mock <ICache>().Object, new Mock <ILogger>().Object)
{
MockedResourceProcessor = mockedResourceProcessor;
MockedChatService = mockedChatService;
Repository = repository;
MockedConnection = connection;
}
public TestableChat(Mock <IApplicationSettings> mockSettings, Mock <IResourceProcessor> mockedResourceProcessor, Mock <IChatService> mockedChatService, IJabbrRepository repository, Mock <IConnection> connection)
: base(mockedResourceProcessor.Object, mockedChatService.Object, repository, new Mock <ICache>().Object)
{
MockedResourceProcessor = mockedResourceProcessor;
MockedChatService = mockedChatService;
Repository = repository;
MockedConnection = connection;
}
public static string TransformAndParseUrls(IJabbrRepository repository, string text)
{
HashSet<string> urls;
var transform = new TextTransform(repository);
var parsedText = transform.Parse(text);
return TextTransform.TransformAndExtractUrls(parsedText, out urls);
}
public JabbRAuthenticationCallbackProvider(IAuthenticationTokenService authenticationTokenService,
IMembershipService membershipService,
IJabbrRepository repository)
{
_authenticationTokenService = authenticationTokenService;
_membershipService = membershipService;
_repository = repository;
}
public TestableChat(Mock<IApplicationSettings> mockSettings, Mock<IResourceProcessor> mockedResourceProcessor, Mock<IChatService> mockedChatService, IJabbrRepository repository, Mock<IConnection> connection)
: base(mockedResourceProcessor.Object, mockedChatService.Object, repository, new Mock<ICache>().Object)
{
MockedResourceProcessor = mockedResourceProcessor;
MockedChatService = mockedChatService;
Repository = repository;
MockedConnection = connection;
}
public JabbRAuthenticationCallbackProvider(IAuthenticationTokenService authenticationTokenService,
IMembershipService membershipService,
IJabbrRepository repository)
{
_authenticationTokenService = authenticationTokenService;
_membershipService = membershipService;
_repository = repository;
}
public ChatService(ICache cache,
IJabbrRepository repository,
ApplicationSettings settings)
{
_cache = cache;
_repository = repository;
_settings = settings;
}
public TestableChat(Mock<ContentProviderProcessor> mockedResourceProcessor, Mock<IChatService> mockedChatService, IJabbrRepository repository, Mock<IConnection> connection)
: base(mockedResourceProcessor.Object, mockedChatService.Object, repository, new Mock<ICache>().Object, new Mock<ILogger>().Object)
{
MockedResourceProcessor = mockedResourceProcessor;
MockedChatService = mockedChatService;
Repository = repository;
MockedConnection = connection;
}
public TestableChat(Mock <IResourceProcessor> mockedResourceProcessor, Mock <IChatService> mockedChatService, IJabbrRepository repository, Mock <IConnection> connection)
: base(mockedResourceProcessor.Object, mockedChatService.Object, repository)
{
MockedResourceProcessor = mockedResourceProcessor;
MockedChatService = mockedChatService;
Repository = repository;
MockedConnection = connection;
}
public CommandManager(string clientId,
string userId,
string roomName,
IChatService service,
IJabbrRepository repository,
INotificationService notificationService)
: this(clientId, null, userId, roomName, service, repository, notificationService)
{
}
public void StringWithHashtagButRoomDoesntExistDoesNotModifyMessage()
{
IJabbrRepository repository = CreateRoomRepository();
TextTransform transform = new TextTransform(repository);
string result = transform.Parse("#thisdoesnotexist");
Assert.Equal("#thisdoesnotexist", result);
}
public CommandManager(string clientId,
string userId,
string roomName,
IChatService service,
IJabbrRepository repository,
INotificationService notificationService)
: this(clientId, null, userId, roomName, service, repository, notificationService)
{
}
public void StringWithHashtagModifiesHashtagToRoomLink()
{
IJabbrRepository repository = CreateRoomRepository();
string expected = "<a href=\"#/rooms/hashtag\" title=\"#hashtag\">#hashtag</a>";
TextTransform transform = new TextTransform(repository);
string result = transform.Parse("#hashtag");
Assert.Equal(expected, result);
}
public static ChatUser VerifyUserId(this IJabbrRepository repository, string userId)
{
ChatUser user = repository.GetUserById(userId);
if (user == null)
{
throw new InvalidOperationException("You don't have a name. Pick a name using '/nick nickname'.");
}
return(user);
}
public Chat(
IJabbrRepository repository,
IOptions <ApplicationSettings> settings,
IRecentMessageCache recentMessageCache,
IChatService chatService)
{
// Request the injected object instances
_repository = repository;
_chatService = chatService;
_recentMessageCache = recentMessageCache;
_settings = settings.Value;
}
public Chat(ContentProviderProcessor resourceProcessor,
IChatService service,
IJabbrRepository repository,
ICache cache,
ILogger logger)
{
_resourceProcessor = resourceProcessor;
_service = service;
_repository = repository;
_cache = cache;
_logger = logger;
}
private static void ClearConnectedClients(IJabbrRepository repository)
{
try
{
repository.RemoveAllClients();
repository.CommitChanges();
}
catch (Exception ex)
{
Elmah.ErrorLog.GetDefault(null).Log(new Error(ex));
}
}
public Chat(ContentProviderProcessor resourceProcessor,
IChatService service,
IJabbrRepository repository,
ICache cache,
ILogger logger)
{
_resourceProcessor = resourceProcessor;
_service = service;
_repository = repository;
_cache = cache;
_logger = logger;
}
public static ChatUser VerifyUserId(this IJabbrRepository repository, string userId)
{
ChatUser user = repository.GetUserById(userId);
if (user == null)
{
// The user isn't logged in
throw new HubException(LanguageResources.Authentication_NotLoggedIn);
}
return(user);
}
public static bool IsUserInRoom(this IJabbrRepository repository, ICache cache, ChatUser user, ChatRoom room)
{
bool?cached = cache.IsUserInRoom(user, room);
if (cached == null)
{
cached = repository.IsUserInRoom(user, room);
cache.SetUserInRoom(user, room, cached.Value);
}
return(cached.Value);
}
public static ChatUser VerifyUserId(this IJabbrRepository repository, string userId)
{
ChatUser user = repository.GetUserById(userId);
if (user == null)
{
// The user isn't logged in
throw new InvalidOperationException("You're not logged in.");
}
return(user);
}
private static void ClearConnectedClients(IJabbrRepository repository)
{
try
{
repository.RemoveAllClients();
repository.CommitChanges();
}
catch (Exception ex)
{
Elmah.ErrorLog.GetDefault(null).Log(new Error(ex));
}
}
public static ChatUser VerifyUser(this IJabbrRepository repository, string userName)
{
userName = ChatService.NormalizeUserName(userName);
ChatUser user = repository.GetUserByName(userName);
if (user == null)
{
throw new InvalidOperationException(String.Format("Unable to find user '{0}'.", userName));
}
return(user);
}
public static ChatUser VerifyUser(this IJabbrRepository repository, string userName)
{
userName = MembershipService.NormalizeUserName(userName);
ChatUser user = repository.GetUserByName(userName);
if (user == null)
{
throw new HubException(String.Format(LanguageResources.UserNotFound, userName));
}
return(user);
}
public CommandManager(string clientId,
string userId,
string roomName,
IChatService service,
IJabbrRepository repository,
INotificationService notificationService)
{
_clientId = clientId;
_userId = userId;
_roomName = roomName;
_chatService = service;
_repository = repository;
_notificationService = notificationService;
}
public static ChatUser VerifyUser(this IJabbrRepository repository, string userName)
{
// MembershipService is getting replaced by identity so this test is no longer working
//userName = MembershipService.NormalizeUserName(userName);
ChatUser user = repository.GetUserByName(userName);
if (user == null)
{
throw new HubException(String.Format(LanguageResources.UserNotFound, userName));
}
return(user);
}
private static void RemoveZombies(ILogger logger, IJabbrRepository repo)
{
// Remove all zombie clients
var zombies = repo.Clients.Where(c =>
SqlFunctions.DateDiff("mi", c.LastActivity, DateTimeOffset.UtcNow) > 3);
// We're doing to list since there's no MARS support on azure
foreach (var client in zombies.ToList())
{
logger.Log("Removed zombie connection {0}", client.Id);
repo.Remove(client);
}
}
private static void RemoveZombies(ILogger logger, IJabbrRepository repo)
{
// Remove all zombie clients
var zombies = repo.Clients.Where(c =>
SqlFunctions.DateDiff("mi", c.LastActivity, DateTimeOffset.UtcNow) > 3);
// We're doing to list since there's no MARS support on azure
foreach (var client in zombies.ToList())
{
logger.Log("Removed zombie connection {0}", client.Id);
repo.Remove(client);
}
}
public CommandManager(string clientId,
string userId,
string roomName,
IChatService service,
IJabbrRepository repository,
INotificationService notificationService)
{
_clientId = clientId;
_userId = userId;
_roomName = roomName;
_chatService = service;
_repository = repository;
_notificationService = notificationService;
}
public TestableChat(Mock<ContentProviderProcessor> mockedResourceProcessor, Mock<IChatService> mockedChatService, IJabbrRepository repository, Mock<IConnection> connection, ApplicationSettings settings)
: base(mockedResourceProcessor.Object,
mockedChatService.Object,
new Mock<IRecentMessageCache>().Object,
repository,
new Mock<ICache>().Object,
new Mock<ILogger>().Object,
settings)
{
MockedResourceProcessor = mockedResourceProcessor;
MockedChatService = mockedChatService;
Repository = repository;
MockedConnection = connection;
Settings = settings;
}
public Chat(ContentProviderProcessor resourceProcessor,
IChatService service,
IRecentMessageCache recentMessageCache,
IJabbrRepository repository,
ICache cache,
ILogger logger,
ApplicationSettings settings)
{
_resourceProcessor = resourceProcessor;
_service = service;
_recentMessageCache = recentMessageCache;
_repository = repository;
_cache = cache;
_logger = logger;
_settings = settings;
}
private static void ClearConnectedClients(IJabbrRepository repository)
{
try
{
foreach (var u in repository.Users)
{
u.Status = (int)UserStatus.Offline;
}
repository.RemoveAllClients();
repository.CommitChanges();
}
catch (Exception ex)
{
Elmah.ErrorLog.GetDefault(null).Log(new Error(ex));
}
}
private static void CheckUserStatus(IJabbrRepository repo, IHubContext hubContext)
{
var inactiveUsers = new List<ChatUser>();
var offlineUsers = new List<ChatUser>();
IQueryable<ChatUser> users = repo.GetOnlineUsers();
foreach (var user in users)
{
var status = (UserStatus)user.Status;
var elapsed = DateTime.UtcNow - user.LastActivity;
if (user.ConnectedClients.Count == 0)
{
// Fix users that are marked as inactive but have no clients
user.Status = (int)UserStatus.Offline;
offlineUsers.Add(user);
}
else if (elapsed.TotalMinutes > 5)
{
user.Status = (int)UserStatus.Inactive;
inactiveUsers.Add(user);
}
}
if (inactiveUsers.Count > 0)
{
PerformRoomAction(inactiveUsers, roomGroup =>
{
hubContext.Clients.Group(roomGroup.Room.Name).markInactive(roomGroup.Users);
});
}
// TODO: Only remove users relevant to this server.
//if (offlineUsers.Count > 0)
//{
// PerformRoomAction(offlineUsers, roomGroup =>
// {
// foreach (var user in roomGroup.Users)
// {
// hubContext.Clients.Group(roomGroup.Room.Name).leave(user, roomGroup.Room.Name);
// }
// });
//}
}
private static void MarkInactiveUsers(IJabbrRepository repo, IHubContext hubContext)
{
var inactiveUsers = new List<ChatUser>();
IQueryable<ChatUser> users = repo.GetOnlineUsers();
foreach (var user in users)
{
var status = (UserStatus)user.Status;
var elapsed = DateTime.UtcNow - user.LastActivity;
if (user.ConnectedClients.Count == 0)
{
// Fix users that are marked as inactive but have no clients
user.Status = (int)UserStatus.Offline;
}
else if (elapsed.TotalMinutes > 15)
{
user.Status = (int)UserStatus.Inactive;
inactiveUsers.Add(user);
}
}
if (inactiveUsers.Count > 0)
{
var roomGroups = from u in inactiveUsers
from r in u.Rooms
select new { User = u, Room = r } into tuple
group tuple by tuple.Room into g
select new
{
Room = g.Key,
Users = g.Select(t => new UserViewModel(t.User))
};
foreach (var roomGroup in roomGroups)
{
hubContext.Clients.Group(roomGroup.Room.Name).markInactive(roomGroup.Users).Wait();
}
}
}
private static void MarkInactiveUsers(IJabbrRepository repo, IDependencyResolver resolver)
{
var connectionManager = resolver.Resolve<IConnectionManager>();
var hubContext = connectionManager.GetHubContext<Chat>();
var inactiveUsers = new List<ChatUser>();
IQueryable<ChatUser> users = repo.Users.Online();
foreach (var user in users)
{
var status = (UserStatus)user.Status;
var elapsed = DateTime.UtcNow - user.LastActivity;
if (elapsed.TotalMinutes > 15)
{
user.Status = (int)UserStatus.Inactive;
inactiveUsers.Add(user);
}
}
if (inactiveUsers.Count > 0)
{
var roomGroups = from u in inactiveUsers
from r in u.Rooms
select new { User = u, Room = r } into tuple
group tuple by tuple.Room into g
select new
{
Room = g.Key,
Users = g.Select(t => new UserViewModel(t.User))
};
foreach (var roomGroup in roomGroups)
{
hubContext.Group(roomGroup.Room.Name).markInactive(roomGroup.Users).Wait();
}
}
}
private void UpdatePresence(ILogger logger, IJabbrRepository repo)
{
// Get all connections on this node and update the activity
foreach (var connection in _heartbeat.GetConnections())
{
if (!connection.IsAlive)
{
continue;
}
ChatClient client = repo.GetClientById(connection.ConnectionId);
if (client != null)
{
client.LastActivity = DateTimeOffset.UtcNow;
}
else
{
EnsureClientConnected(logger, repo, connection);
}
}
repo.CommitChanges();
}
public MessagesController(IJabbrRepository repository)
{
_repository = repository;
}
public TestableChat(Mock<IResourceProcessor> mockedResourceProcessor, Mock<IChatService> mockedChatService, IJabbrRepository repository, Mock<IConnection> connection)
: base(mockedResourceProcessor.Object, mockedChatService.Object, repository)
{
MockedResourceProcessor = mockedResourceProcessor;
MockedChatService = mockedChatService;
Repository = repository;
MockedConnection = connection;
}
private LoginViewModel GetLoginViewModel(IApplicationSettings applicationSettings,
IJabbrRepository repository,
IAuthenticationService authService)
{
ChatUser user = null;
if (Context.CurrentUser != null)
{
user = repository.GetUserById(Context.CurrentUser.UserName);
}
var viewModel = new LoginViewModel(applicationSettings.AuthenticationMode,
authService.Providers,
user != null ? user.Identities : null);
return viewModel;
}
public AccountModule(IApplicationSettings applicationSettings,
IAuthenticationTokenService authenticationTokenService,
IMembershipService membershipService,
IJabbrRepository repository,
IAuthenticationService authService,
IChatNotificationService notificationService)
: base("/account")
{
Get["/"] = _ =>
{
if (Context.CurrentUser == null)
{
return HttpStatusCode.Forbidden;
}
ChatUser user = repository.GetUserById(Context.CurrentUser.UserName);
return GetProfileView(authService, user);
};
Get["/login"] = _ =>
{
if (Context.CurrentUser != null)
{
return Response.AsRedirect("~/");
}
return View["login", GetLoginViewModel(applicationSettings, repository, authService)];
};
Post["/login"] = param =>
{
if (Context.CurrentUser != null)
{
return Response.AsRedirect("~/");
}
string username = Request.Form.username;
string password = Request.Form.password;
if (String.IsNullOrEmpty(username))
{
this.AddValidationError("username", "Name is required");
}
if (String.IsNullOrEmpty(password))
{
this.AddValidationError("password", "Password is required");
}
try
{
if (ModelValidationResult.IsValid)
{
ChatUser user = membershipService.AuthenticateUser(username, password);
return this.CompleteLogin(authenticationTokenService, user);
}
else
{
return View["login", GetLoginViewModel(applicationSettings, repository, authService)];
}
}
catch
{
this.AddValidationError("_FORM", "Login failed. Check your username/password.");
return View["login", GetLoginViewModel(applicationSettings, repository, authService)];
}
};
Post["/logout"] = _ =>
{
if (Context.CurrentUser == null)
{
return HttpStatusCode.Forbidden;
}
var response = Response.AsJson(new { success = true });
response.AddCookie(new NancyCookie(Constants.UserTokenCookie, null)
{
Expires = DateTime.Now.AddDays(-1)
});
return response;
};
Get["/register"] = _ =>
{
if (Context.CurrentUser != null)
{
return Response.AsRedirect("~/");
}
return View["register"];
};
Post["/create"] = _ =>
{
if (Context.CurrentUser != null)
{
return Response.AsRedirect("~/");
}
string username = Request.Form.username;
string email = Request.Form.email;
string password = Request.Form.password;
string confirmPassword = Request.Form.confirmPassword;
if (String.IsNullOrEmpty(username))
{
this.AddValidationError("username", "Name is required");
}
if (String.IsNullOrEmpty(email))
{
this.AddValidationError("email", "Email is required");
}
ValidatePassword(password, confirmPassword);
try
{
if (ModelValidationResult.IsValid)
{
ChatUser user = membershipService.AddUser(username, email, password);
return this.CompleteLogin(authenticationTokenService, user);
}
}
catch (Exception ex)
{
this.AddValidationError("_FORM", ex.Message);
}
return View["register"];
};
Post["/unlink"] = param =>
{
if (Context.CurrentUser == null)
{
return HttpStatusCode.Forbidden;
}
string provider = Request.Form.provider;
ChatUser user = repository.GetUserById(Context.CurrentUser.UserName);
if (user.Identities.Count == 1 && !user.HasUserNameAndPasswordCredentials())
{
this.AddAlertMessage("error", "You cannot unlink this account because you would lose your ability to login.");
return Response.AsRedirect("~/account/#identityProviders");
}
var identity = user.Identities.FirstOrDefault(i => i.ProviderName == provider);
if (identity != null)
{
repository.Remove(identity);
this.AddAlertMessage("success", String.Format("Successfully unlinked {0} account.", provider));
return Response.AsRedirect("~/account/#identityProviders");
}
return HttpStatusCode.BadRequest;
};
Post["/newpassword"] = _ =>
{
if (Context.CurrentUser == null)
{
return HttpStatusCode.Forbidden;
}
string password = Request.Form.password;
string confirmPassword = Request.Form.confirmPassword;
ValidatePassword(password, confirmPassword);
ChatUser user = repository.GetUserById(Context.CurrentUser.UserName);
try
{
if (ModelValidationResult.IsValid)
{
membershipService.SetUserPassword(user, password);
repository.CommitChanges();
}
}
catch (Exception ex)
{
this.AddValidationError("_FORM", ex.Message);
}
if (ModelValidationResult.IsValid)
{
this.AddAlertMessage("success", "Successfully added a password.");
return Response.AsRedirect("~/account/#changePassword");
}
return GetProfileView(authService, user);
};
Post["/changepassword"] = _ =>
{
if (Context.CurrentUser == null)
{
return HttpStatusCode.Forbidden;
}
string oldPassword = Request.Form.oldPassword;
string password = Request.Form.password;
string confirmPassword = Request.Form.confirmPassword;
if (String.IsNullOrEmpty(oldPassword))
{
this.AddValidationError("oldPassword", "Old password is required");
}
ValidatePassword(password, confirmPassword);
ChatUser user = repository.GetUserById(Context.CurrentUser.UserName);
try
{
if (ModelValidationResult.IsValid)
{
membershipService.ChangeUserPassword(user, oldPassword, password);
repository.CommitChanges();
}
}
catch (Exception ex)
{
this.AddValidationError("_FORM", ex.Message);
}
if (ModelValidationResult.IsValid)
{
this.AddAlertMessage("success", "Successfully changed your password.");
return Response.AsRedirect("~/account/#changePassword");
}
return GetProfileView(authService, user);
};
Post["/changeusername"] = _ =>
{
if (Context.CurrentUser == null)
{
return HttpStatusCode.Forbidden;
}
string username = Request.Form.username;
string confirmUsername = Request.Form.confirmUsername;
ValidateUsername(username, confirmUsername);
ChatUser user = repository.GetUserById(Context.CurrentUser.UserName);
string oldUsername = user.Name;
try
{
if (ModelValidationResult.IsValid)
{
membershipService.ChangeUserName(user, username);
repository.CommitChanges();
}
}
catch (Exception ex)
{
this.AddValidationError("_FORM", ex.Message);
}
if (ModelValidationResult.IsValid)
{
notificationService.OnUserNameChanged(user, oldUsername, username);
this.AddAlertMessage("success", "Successfully changed your username.");
return Response.AsRedirect("~/account/#changeUsername");
}
return GetProfileView(authService, user);
};
}
public HomeModule(ApplicationSettings settings,
IJabbrConfiguration configuration,
IConnectionManager connectionManager,
IJabbrRepository jabbrRepository)
{
Get["/"] = _ =>
{
if (IsAuthenticated)
{
var viewModel = new SettingsViewModel
{
GoogleAnalytics = settings.GoogleAnalytics,
Sha = configuration.DeploymentSha,
Branch = configuration.DeploymentBranch,
Time = configuration.DeploymentTime,
DebugMode = (bool)Context.Items["_debugMode"],
Version = Constants.JabbRVersion,
IsAdmin = Principal.HasClaim(JabbRClaimTypes.Admin),
ClientLanguageResources = BuildClientResources(),
MaxMessageLength = settings.MaxMessageLength
};
return View["index", viewModel];
}
if (Principal != null && Principal.HasPartialIdentity())
{
// If the user is partially authenticated then take them to the register page
return Response.AsRedirect("~/account/register");
}
return HttpStatusCode.Unauthorized;
};
Get["/monitor"] = _ =>
{
ClaimsPrincipal principal = Principal;
if (principal == null ||
!principal.HasClaim(JabbRClaimTypes.Admin))
{
return HttpStatusCode.Forbidden;
}
return View["monitor"];
};
Get["/status", runAsync: true] = async (_, token) =>
{
var model = new StatusViewModel();
// Try to send a message via SignalR
// NOTE: Ideally we'd like to actually receive a message that we send, but right now
// that would require a full client instance. SignalR 2.1.0 plans to add a feature to
// easily support this on the server.
var signalrStatus = new SystemStatus { SystemName = "SignalR messaging" };
model.Systems.Add(signalrStatus);
try
{
var hubContext = connectionManager.GetHubContext<Chat>();
await (Task)hubContext.Clients.Client("doesn't exist").noMethodCalledThis();
signalrStatus.SetOK();
}
catch (Exception ex)
{
signalrStatus.SetException(ex.GetBaseException());
}
// Try to talk to database
var dbStatus = new SystemStatus { SystemName = "Database" };
model.Systems.Add(dbStatus);
try
{
var roomCount = jabbrRepository.Rooms.Count();
dbStatus.SetOK();
}
catch (Exception ex)
{
dbStatus.SetException(ex.GetBaseException());
}
// Try to talk to azure storage
var azureStorageStatus = new SystemStatus { SystemName = "Azure Upload storage" };
model.Systems.Add(azureStorageStatus);
try
{
if (!String.IsNullOrEmpty(settings.AzureblobStorageConnectionString))
{
var azure = new AzureBlobStorageHandler(settings);
UploadResult result;
using (var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes("test")))
{
result = await azure.UploadFile("statusCheck.txt", "text/plain", stream);
}
azureStorageStatus.SetOK();
}
else
{
azureStorageStatus.StatusMessage = "Not configured";
}
}
catch (Exception ex)
{
azureStorageStatus.SetException(ex.GetBaseException());
}
//try to talk to local storage
var localStorageStatus = new SystemStatus { SystemName = "Local Upload storage" };
model.Systems.Add(localStorageStatus);
try
{
if (!String.IsNullOrEmpty(settings.LocalFileSystemStoragePath) && !String.IsNullOrEmpty(settings.LocalFileSystemStorageUriPrefix))
{
var local = new LocalFileSystemStorageHandler(settings);
UploadResult localResult;
using (var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes("test")))
{
localResult = await local.UploadFile("statusCheck.txt", "text/plain", stream);
}
localStorageStatus.SetOK();
}
else
{
localStorageStatus.StatusMessage = "Not configured";
}
}
catch (Exception ex)
{
localStorageStatus.SetException(ex.GetBaseException());
}
// Force failure
if (Context.Request.Query.fail)
{
var failedSystem = new SystemStatus { SystemName = "Forced failure" };
failedSystem.SetException(new ApplicationException("Forced failure for test purposes"));
model.Systems.Add(failedSystem);
}
var view = View["status", model];
if (!model.AllOK)
{
return view.WithStatusCode(HttpStatusCode.InternalServerError);
}
return view;
};
}
public HomeModule(ApplicationSettings settings,
IJabbrConfiguration configuration,
UploadCallbackHandler uploadHandler,
IConnectionManager connectionManager,
IJabbrRepository jabbrRepository)
{
Get["/"] = _ =>
{
if (IsAuthenticated)
{
var viewModel = new SettingsViewModel
{
GoogleAnalytics = settings.GoogleAnalytics,
Sha = configuration.DeploymentSha,
Branch = configuration.DeploymentBranch,
Time = configuration.DeploymentTime,
DebugMode = (bool)Context.Items["_debugMode"],
Version = Constants.JabbRVersion,
IsAdmin = Principal.HasClaim(JabbRClaimTypes.Admin),
ClientLanguageResources = BuildClientResources()
};
return View["index", viewModel];
}
if (Principal != null && Principal.HasPartialIdentity())
{
// If the user is partially authenticated then take them to the register page
return Response.AsRedirect("~/account/register");
}
return HttpStatusCode.Unauthorized;
};
Get["/monitor"] = _ =>
{
ClaimsPrincipal principal = Principal;
if (principal == null ||
!principal.HasClaim(JabbRClaimTypes.Admin))
{
return HttpStatusCode.Forbidden;
}
return View["monitor"];
};
Get["/status"] = _ =>
{
var model = new StatusViewModel();
// Try to send a message via SignalR
// NOTE: Ideally we'd like to actually receive a message that we send, but right now
// that would require a full client instance. SignalR 2.1.0 plans to add a feature to
// easily support this on the server.
var signalrStatus = new SystemStatus { SystemName = "SignalR messaging" };
model.Systems.Add(signalrStatus);
try
{
var hubContext = connectionManager.GetHubContext<Chat>();
var sendTask = (Task)hubContext.Clients.Client("doesn't exist").noMethodCalledThis();
sendTask.Wait();
signalrStatus.SetOK();
}
catch (Exception ex)
{
signalrStatus.SetException(ex.GetBaseException());
}
// Try to talk to database
var dbStatus = new SystemStatus { SystemName = "Database" };
model.Systems.Add(dbStatus);
try
{
var roomCount = jabbrRepository.Rooms.Count();
dbStatus.SetOK();
}
catch (Exception ex)
{
dbStatus.SetException(ex.GetBaseException());
}
// Try to talk to storage
var azureStorageStatus = new SystemStatus { SystemName = "Upload storage" };
model.Systems.Add(azureStorageStatus);
try
{
if (!String.IsNullOrEmpty(settings.AzureblobStorageConnectionString))
{
var azure = new AzureBlobStorageHandler(settings);
UploadResult result;
using (var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes("test")))
{
result = azure.UploadFile("statusCheck.txt", "text/plain", stream)
.Result;
}
azureStorageStatus.SetOK();
}
else
{
azureStorageStatus.StatusMessage = "Not configured";
}
}
catch (Exception ex)
{
azureStorageStatus.SetException(ex.GetBaseException());
}
// Force failure
if (Context.Request.Query.fail)
{
var failedSystem = new SystemStatus { SystemName = "Forced failure" };
failedSystem.SetException(new ApplicationException("Forced failure for test purposes"));
model.Systems.Add(failedSystem);
}
var view = View["status", model];
if (!model.AllOK)
{
return view.WithStatusCode(HttpStatusCode.InternalServerError);
}
return view;
};
Post["/upload-file"] = _ =>
{
if (!IsAuthenticated)
{
return 403;
}
string roomName = Request.Form.room;
string connectionId = Request.Form.connectionId;
string file = Request.Form.file;
//string fileName = "clipboard_" + Guid.NewGuid().ToString("N");
string fileName = Request.Form.filename;
string contentType = Request.Form.type;
byte[] binData = null;
var info = Regex.Match(file, @"data:(?:(?<unkown>.+?)/(?<type>.+?))?;base64,(?<data>.+)");
binData = Convert.FromBase64String(info.Groups["data"].Value);
contentType = info.Groups["type"].Value;
if (String.IsNullOrWhiteSpace(contentType))
{
contentType = "application/octet-stream";
}
UploadFile(
uploadHandler,
Principal.GetUserId(),
connectionId,
roomName,
fileName,
contentType,
new MemoryStream(binData)).Wait();
return 200;
};
}
public JabbRAuthenticationCallbackProvider(IJabbrRepository repository)
{
_repository = repository;
}
// This is an uber hack to make sure the db is in sync with SignalR
private void EnsureClientConnected(ILogger logger, IJabbrRepository repo, ITrackingConnection connection)
{
var contextField = connection.GetType().GetField("_context",
BindingFlags.NonPublic | BindingFlags.Instance);
if (contextField == null)
{
return;
}
var context = contextField.GetValue(connection) as HostContext;
if (context == null)
{
return;
}
string connectionData = context.Request.QueryString["connectionData"];
if (String.IsNullOrEmpty(connectionData))
{
return;
}
var hubs = JsonConvert.DeserializeObject<HubConnectionData[]>(connectionData);
if (hubs.Length != 1)
{
return;
}
// We only care about the chat hub
if (!hubs[0].Name.Equals("chat", StringComparison.OrdinalIgnoreCase))
{
return;
}
logger.Log("Connection {0} exists but isn't tracked.", connection.ConnectionId);
string userId = context.Request.User.GetUserId();
ChatUser user = repo.GetUserById(userId);
if (user == null)
{
logger.Log("Unable to find user with id {0}", userId);
return;
}
var client = new ChatClient
{
Id = connection.ConnectionId,
User = user,
UserAgent = context.Request.Headers["User-Agent"],
LastActivity = DateTimeOffset.UtcNow,
LastClientActivity = user.LastActivity
};
repo.Add(client);
repo.CommitChanges();
}
public ChatService(IJabbrRepository repository, ICryptoService crypto)
{
_repository = repository;
_crypto = crypto;
}
private void RemoveOfflineUsers(ILogger logger, IJabbrRepository repo)
{
var offlineUsers = new List<ChatUser>();
IQueryable<ChatUser> users = repo.GetOnlineUsers();
foreach (var user in users.ToList())
{
if (user.ConnectedClients.Count == 0)
{
logger.Log("{0} has no clients. Marking as offline", user.Name);
// Fix users that are marked as inactive but have no clients
user.Status = (int)UserStatus.Offline;
offlineUsers.Add(user);
}
}
if (offlineUsers.Count > 0)
{
PerformRoomAction(offlineUsers, async roomGroup =>
{
foreach (var user in roomGroup.Users)
{
await _hubContext.Clients.Group(roomGroup.Room.Name).leave(user, roomGroup.Room.Name);
}
});
repo.CommitChanges();
}
}
public MembershipService(IJabbrRepository repository, ICryptoService crypto)
{
_repository = repository;
_crypto = crypto;
}
private void CheckUserStatus(ILogger logger, IJabbrRepository repo)
{
var inactiveUsers = new List<ChatUser>();
IQueryable<ChatUser> users = repo.GetOnlineUsers().Where(u =>
SqlFunctions.DateDiff("mi", u.LastActivity, DateTime.UtcNow) > 5);
foreach (var user in users.ToList())
{
user.Status = (int)UserStatus.Inactive;
inactiveUsers.Add(user);
}
if (inactiveUsers.Count > 0)
{
PerformRoomAction(inactiveUsers, async roomGroup =>
{
await _hubContext.Clients.Group(roomGroup.Room.Name).markInactive(roomGroup.Users);
});
repo.CommitChanges();
}
}
