/// <summary>
/// Creates 'MessageToUser' for every user which has currently conversation with currently logged in user '_activeUser'.
/// </summary>
/// <returns>Void</returns>
private async Task LoadConversations()
{
using (var _dbContext = new MessengerContext())
{
_dbContext.Users.Attach(_activeUser);
// Add users who have conversation with currently logged user
var _receivers = await _dbContext.Conversations
.Where(x => x.FirstUser.UserId == _activeUser.UserId)
.Select(x => x.SecondUser)
.ToListAsync();
_receivers.AddRange(await _dbContext.Conversations
.Where(x => x.SecondUser.UserId == _activeUser.UserId)
.Select(x => x.FirstUser)
.ToListAsync());
// Create 'MessageToUser' for every receiver
foreach (var _receiver in _receivers)
{
var _messageToUser = new MessageToUser(this, _receiver, _activeUser);
this.flowlayoutMessages.Controls.Add(_messageToUser);
_openConversations.Add(_receiver);
}
}
}
public async Task PutUpdate_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
this.SeedDataForMessagesTesting(context);
User testUser = await context.Users.FirstAsync();
Message message = await context.Messages.Skip(1).FirstAsync();
string newContent = "new content";
var requestBody = new EditMessageViewModel {
MessageId = message.MessageId, Content = newContent
};
var requestContent = new StringContent(JsonConvert.SerializeObject(requestBody), Encoding.UTF8, "application/json");
var response = await client.PutAsync($"/api/messages/{message.MessageId}", requestContent);
response.EnsureSuccessStatusCode();
Message updated = await context.Messages.SingleAsync(x => x.MessageId == message.MessageId);
Assert.Equal(newContent, updated.Content);
}
public async Task GetById_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
await context.Users.AddRangeAsync(this.GenerateUsers(5));
await context.SaveChangesAsync();
var dbUser = await context.Users.Skip(2).FirstAsync();
var response = await client.GetAsync($"/api/users/{dbUser.Id}");
response.EnsureSuccessStatusCode();
var user = response.Content.ReadAsAsync(typeof(UserViewModel)).Result as UserViewModel;
Assert.NotNull(user);
Assert.Equal(dbUser.UserName, user.UserName);
}
public async Task GetByConversation_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
this.SeedDataForMessagesTesting(context);
User testUser = await context.Users.FirstAsync();
Conversation testConversation = await context.Conversations.FirstAsync();
var response = await client.GetAsync($"/api/messages/Conversation/{testConversation.ConversationId}");
response.EnsureSuccessStatusCode();
var messages = response.Content.ReadAsAsync(typeof(IEnumerable <EditMessageViewModel>)).Result as IEnumerable <EditMessageViewModel>;
int messagesCount = await context.Messages.CountAsync(x => x.OwnerId == testUser.Id &&
x.Conversation.ConversationId == testConversation.ConversationId);
Assert.NotNull(messages);
Assert.Equal(messagesCount, messages.Count());
}
public async Task GetUserNameContains_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
UserManager <User> userManager = this.factory.Server.Host.Services.GetService(typeof(UserManager <User>))
as UserManager <User>;
foreach (var item in this.GenerateUsers(5))
{
await userManager.CreateAsync(item);
}
var dbUser = await context.Users.Skip(2).FirstAsync();
var searchString = dbUser.UserName.Substring(0, 2);
var response = await client.GetAsync($"/api/users/UserNameContains/{searchString}");
response.EnsureSuccessStatusCode();
var users = response.Content.ReadAsAsync(typeof(IEnumerable <UserViewModel>)).Result as IEnumerable <UserViewModel>;
Assert.True(users.Any(x => x.UserName == dbUser.UserName));
}
public async Task Post_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
User user = this.GenerateUsers(1).Single();
var requestBody = new UserCredentialsViewModel {
Password = "******", UserName = user.UserName, Name = user.Name
};
var requestContent = new StringContent(JsonConvert.SerializeObject(requestBody), Encoding.UTF8, "application/json");
var response = await client.PostAsync($"/api/users", requestContent);
response.EnsureSuccessStatusCode();
UserManager <User> userManager = this.factory.Server.Host.Services.GetService(typeof(UserManager <User>))
as UserManager <User>;
var insertedUser = await userManager.FindByNameAsync(user.UserName);
Assert.NotNull(insertedUser);
}
public async Task Delete_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
await context.Users.AddRangeAsync(this.GenerateUsers(5));
await context.SaveChangesAsync();
var dbUser = await context.Users.Skip(2).FirstAsync();
int previousCount = await context.Users.CountAsync();
var response = await client.DeleteAsync($"/api/users/{dbUser.Id}");
response.EnsureSuccessStatusCode();
int currentCount = await context.Users.CountAsync();
Assert.NotEqual(previousCount, currentCount);
Assert.Equal(previousCount, currentCount + 1);
Assert.False(await context.Users.AnyAsync(x => x.Id == dbUser.Id));
}
/// <summary>
/// Load conversation between '_activeUser' and '_receiver' if exists, create new otherwise.
/// </summary>
/// <returns>Void</returns>
private async Task LoadConversation()
{
using (var _db = new MessengerContext())
{
// Attaching users to this context
_db.Users.Attach(_activeUser);
_db.Users.Attach(_receiver);
// Find conversation between these two users if one already exists
var _conversationsMatch = await _db.Conversations
.Where(c => c.FirstUser.UserId == _activeUser.UserId || c.FirstUser.UserId == _receiver.UserId)
.Where(c => c.SecondUser.UserId == _activeUser.UserId || c.SecondUser.UserId == _receiver.UserId)
.Include(x => x.Messages)
.SingleOrDefaultAsync();
if (_conversationsMatch != null)
{
_conversation = _conversationsMatch;
return;
}
// Only runs when Conversation does not exists
var _newConversation = new Conversation
{
FirstUser = _activeUser,
SecondUser = _receiver,
Messages = new List <Message>()
};
_conversation = _newConversation;
_db.Conversations.AddOrUpdate(_newConversation);
await _db.SaveChangesAsync();
}
}
public async Task GetById_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
this.SeedDataForMessagesTesting(context);
User testUser = await context.Users.FirstAsync();
Message message = await context.Messages.Skip(1).FirstAsync();
var response = await client.GetAsync($"/api/messages/{message.MessageId}");
response.EnsureSuccessStatusCode();
var responseMessage = response.Content.ReadAsAsync(typeof(EditMessageViewModel)).Result as EditMessageViewModel;
Assert.NotNull(responseMessage);
Assert.Equal(message.Content, message.Content);
}
public async Task Delete_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
this.SeedDataForMessagesTesting(context);
User testUser = await context.Users.FirstAsync();
Message message = await context.Messages.Skip(1).FirstAsync();
int previousCount = await context.Messages.CountAsync();
var response = await client.DeleteAsync($"/api/messages/{message.MessageId}");
response.EnsureSuccessStatusCode();
int currentCount = await context.Messages.CountAsync();
Assert.NotEqual(previousCount, currentCount);
Assert.Equal(previousCount, currentCount + 1);
Assert.False(await context.Messages.AnyAsync(x => x.MessageId == message.MessageId));
}
// Handles the click event on 'sendBtn'
private async void SendButton_Click(object sender, EventArgs e)
{
// Display sent message first
var _msgText = messageTextBox.Text;
var _messageBubble = new MessageBubble(_activeUser, MessageType.Outgoing, _msgText);
messageFlowLayoutPanel.Controls.Add(_messageBubble);
messageTextBox.Clear();
// Save message to database
using (var _db = new MessengerContext())
{
_db.Users.Attach(_activeUser);
_db.Conversations.Attach(_conversation);
var _message = new Message()
{
Sender = _activeUser,
Text = _msgText
};
_conversation.Messages.Add(_message);
// Assign updated Message list to object in db
var _dbMessages = await _db.Conversations.FirstAsync(x => x.ConversationId == _conversation.ConversationId);
_dbMessages.Messages = _conversation.Messages;
await _db.SaveChangesAsync();
}
}
/// <summary>
/// Basically "debug" function. Just connects to the DB and select user with ID == 1.
/// </summary>
private async Task DatabaseUnlag()
{
using (var _db = new MessengerContext())
{
var _lagUser = await Task.Run(() => _db.Users.FirstAsync());
}
}
public UsersController(IConfiguration configuration, MessengerContext messengerContext, UserManager <User> userManager, ILogger <UsersController> logger)
{
this.configuration = configuration;
this.messengerContext = messengerContext;
this.userManager = userManager;
this.logger = logger;
}
public async Task Refresh_BadRefreshTokenValue_ShouldSuccess()
{
HttpClient client = this.factory.CreateClient();
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext)) as MessengerContext;
#region Login
var data = new
{
UserName = "******",
Password = "******"
};
StringContent content = new StringContent(JsonConvert.SerializeObject(data).ToString(), Encoding.UTF8, "application/json");
HttpResponseMessage loginResponse = await client.PostAsync("/api/auth/login", content);
loginResponse.EnsureSuccessStatusCode();
#endregion
string stringLoginResponse = await loginResponse.Content.ReadAsStringAsync();
JObject loginJsonResult = JObject.Parse(stringLoginResponse);
loginJsonResult["refreshToken"] = "badtoken";
StringContent refreshContent = new StringContent(loginJsonResult.ToString(), Encoding.UTF8, "application/json");
HttpResponseMessage refreshResponse = await client.PostAsync("/api/auth/refresh", refreshContent);
Assert.Equal(HttpStatusCode.BadRequest, refreshResponse.StatusCode);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
MessengerContext ctx = new MessengerContext();
ctx.Nutzer.Load();
ParentGrid.DataContext = ctx.Nutzer.Local;
}
public static void Initialize()
{
using (MessengerContext db = new MessengerContext())
{
db.Database.Initialize(false);
db.SaveChanges();
}
}
/// <summary>
/// Checks users in database, if a user with 'username' a password 'pass' exists - returns this user, null otherwise.
/// </summary>
/// <param name="username">Username to be "checked".</param>
/// <param name="pass">Password for account with username 'username'.</param>
/// <returns>User if matched, null otherwise.</returns>
private async Task <User> LoginUser(string username, string pass)
{
using (var _dataContext = new MessengerContext())
{
return(await _dataContext.Users
.FirstOrDefaultAsync(usr => usr.Username == username && usr.Password == pass));
}
}
// Handles the click event on 'registerUserBtn'
private async void RegisterUserBtn_Click(object sender, EventArgs e)
{
// Check if input is not empty
if (textUsername.Text == String.Empty || textPassword.Text == String.Empty)
{
MessageBox.Show("Invalid username or password.\n\nPlease try again with valid inputs.", "Invalid Arguments", MessageBoxButtons.OK, MessageBoxIcon.Error);
textUsername.Clear();
textPassword.Clear();
textPasswordCheck.Clear();
return;
}
// Check if retyped password is correct
if (textPassword.Text != textPasswordCheck.Text)
{
MessageBox.Show("Passwords do not match!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
textPassword.Clear();
textPasswordCheck.Clear();
return;
}
var _username = textUsername.Text;
var _pass = textPassword.Text;
// Compute hashed pass
var _hashedPass = Encoding.ASCII.GetString(_md5Crypto.ComputeHash(Encoding.ASCII.GetBytes(_pass)));
// Check if username is available
if (await CheckUsernameAvailability(_username))
{
using (var _dbContext = new MessengerContext())
{
var _newUser = new User()
{
Username = _username,
Password = _hashedPass
};
_dbContext.Users.AddOrUpdate(_newUser);
await _dbContext.SaveChangesAsync();
}
MessageBox.Show($"Well done! {_username.ToUpper()} was registered successfully.", "Success",
MessageBoxButtons.OK, MessageBoxIcon.Information);
_mainForm.OpenChildForm(new LoginForm(_mainForm));
Console.WriteLine($"DEBUG:\nusername: {_username} password: {_pass} hash: {_hashedPass}");
}
// Username is NOT available
else
{
MessageBox.Show($"Sorry, but {_username} is already taken!", "Invalid Username", MessageBoxButtons.OK, MessageBoxIcon.Warning);
textUsername.Clear();
textPassword.Clear();
textPasswordCheck.Clear();
}
}
public MessengerHub(
MessengerContext context,
ILogger <MessengerHub> logger,
UserManager <User> userManager)
{
this.context = context;
this.logger = logger;
this.userManager = userManager;
}
public List <User> selectUsers(int userID = 0)
{
using (var db = new MessengerContext())
{
var items = (from u in db.Users where u.Id > userID select u).ToList();
return(items);
}
}
/// <summary>
/// Checks if username is already registered in database.
/// </summary>
/// <param name="chosenUsername">Name to be checked.</param>
/// <returns>True - available, False - not available</returns>
private async Task <bool> CheckUsernameAvailability(string chosenUsername)
{
using (var _dbContext = new MessengerContext())
{
var _foundSameUsername = await _dbContext.Users
.FirstOrDefaultAsync(x => x.Username == chosenUsername);
return(_foundSameUsername == null);
}
}
public List <Mail> selectMails(string login, int mailID = 0)
{
using (var db = new MessengerContext())
{
var items = (from u in db.Mails where u.Id > mailID && (u.receiver.Login == login || u.sender.Login == login) select u).ToList();
return(items);
}
}
public JsonResult selectMails(int mailID = 0)
{
using (var db = new MessengerContext())
{
var items = (from u in db.Mails where u.Id > mailID select u).ToList();
JsonSerializerSettings jsSettings = new JsonSerializerSettings();
jsSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
return(Json(items, JsonRequestBehavior.AllowGet));
}
}
public ConversationsController(
MessengerContext messengerContext,
IConversationService conversationService,
ITokenService tokenService,
ILogger <ConversationsController> logger)
{
this.messengerContext = messengerContext;
this.conversationService = conversationService;
this.tokenService = tokenService;
this.logger = logger;
}
public List <ViewMessage> GetMessages(int groupId)
{
using (MessengerContext context = new MessengerContext())
{
return(context.Messages
.Include(m => m.Content)
.Include(m => m.User)
.ToList().Where(m => m.GroupId == groupId).ToList()
.Select(m => (ViewMessage)m).ToList());
}
}
public TokenService(
IConfiguration configuration,
UserManager <User> userManager,
MessengerContext context,
ILogger <TokenService> logger)
{
this.configuration = configuration;
this.userManager = userManager;
this.context = context;
this.logger = logger;
}
public AdminController(UserManager <User> userManager,
RoleManager <IdentityRole> roleManager,
SuppliersContext suppliersContext,
MessengerContext messengerContext,
IStreinger streinger)
{
_streinger = streinger;
_userManager = userManager;
_messengerContext = messengerContext;
_roleManager = roleManager;
_suppliersContext = suppliersContext;
}
public bool SingIn(string login, string password)
{
using (var db = new MessengerContext())
{
var users = from u in db.Users where u.Login == login && u.Password == password select u;
User user = users.FirstOrDefault();
if (user != null)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Loads every user except currently logged in user ('_activeUser') into the receiver combo box.
/// </summary>
/// <returns>Void</returns>
private async Task LoadUsers()
{
using (var _db = new MessengerContext())
{
// Select all users except '_activeUser'
_allUsers = await _db.Users
.Where(u => u.UserId != _activeUser.UserId)
.Select(u => u.Username)
.ToListAsync();
}
receiverComboBox.DataSource = _allUsers;
}
public void Connect(int userId)
{
var callback = OperationContext.Current.GetCallbackChannel <IMessengerServiceCallback>();
using (MessengerContext context = new MessengerContext())
{
var user = context.Users.Include(u => u.Groups).FirstOrDefault(u => u.UserId == userId);
if (user != null)
{
_clients.Add(callback, user);
}
}
//callback.Update(GetGroups(userId));
}
