public async Task <UserVm> UpdateUserPhoneAsync(long userId, string phone)
{
using (MessengerDbContext context = contextFactory.Create())
{
var user = await context.Users
.Include(opt => opt.Phones)
.Include(opt => opt.Emails)
.FirstOrDefaultAsync(opt => opt.Id == userId)
.ConfigureAwait(false);
user.Phones = new List <Phones>
{
new Phones
{
Main = true,
PhoneNumber = phone,
UserId = userId
}
};
context.Users.Update(user);
await context.SaveChangesAsync().ConfigureAwait(false);
return(UserConverter.GetUserVm(user));
}
}
public async Task <UserVm> GetUserAsync(long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
var targetUser = await context.Users
.AsNoTracking()
.Include(user => user.Phones)
.Include(user => user.Emails)
.FirstOrDefaultAsync(user => user.Id == userId && user.Deleted == false).ConfigureAwait(false);
return(UserConverter.GetUserVm(targetUser));
}
}
public async Task <UserVm> GetUserInformationAsync(long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
User resultUser = await context.Users
.AsNoTracking()
.Include(user => user.BlackList)
.Include(user => user.Emails)
.Include(user => user.Phones)
.FirstOrDefaultAsync(user => user.Id == userId)
.ConfigureAwait(false);
return(UserConverter.GetUserVm(resultUser));
}
}
public async Task <UserVm> SetUserBannedAsync(long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
var user = await context.Users
.FirstOrDefaultAsync(opt => opt.Id == userId)
.ConfigureAwait(false);
user.Banned = !user.Banned;
context.Users.Update(user);
await context.SaveChangesAsync().ConfigureAwait(false);
return(UserConverter.GetUserVm(user));
}
}
public async Task <UserVm> EditUserAsync(EditUserVm editableUser, long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
User editedUser = await context.Users
.Include(user => user.Phones)
.Include(user => user.Emails)
.FirstOrDefaultAsync(user => user.Id == userId && user.Deleted == false)
.ConfigureAwait(false);
editedUser = UserConverter.GetUser(editedUser, editableUser);
context.Update(editedUser);
await context.SaveChangesAsync().ConfigureAwait(false);
return(UserConverter.GetUserVm(editedUser));
}
}
public async Task ApplyPrivacySettingPhones()
{
var user = fillTestDbHelper.Users.FirstOrDefault();
var firstUser = UserConverter.GetUserVm(fillTestDbHelper.Users.FirstOrDefault());
var secondUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(1).FirstOrDefault());
var thirdUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(2).FirstOrDefault());
var fourthUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(3).FirstOrDefault());
await contactsService.RemoveContactsAsync(user.Contacts.Select(opt => opt.ContactId).ToList(), user.Id);
var secondContact = await contactsService.CreateOrEditContactAsync(new ContactDto
{
ContactUserId = secondUser.Id.Value,
UserId = firstUser.Id.Value
});
var thirdContact = await contactsService.CreateOrEditContactAsync(new ContactDto
{
ContactUserId = thirdUser.Id.Value,
UserId = firstUser.Id.Value
});
var group = await gropsService.CreateOrEditGroupAsync(new GroupDto
{
UserId = firstUser.Id.Value,
UsersId = new List <long> {
thirdContact.ContactUserId
},
PrivacySettings = int.MaxValue
});
Assert.NotEmpty(privacyService.ApplyPrivacySettings(new List <UserVm> {
firstUser
}, firstUser.Phones.Select(opt => opt.FullNumber).ToList(), thirdUser.Id));
Assert.Empty(privacyService.ApplyPrivacySettings(new List <UserVm> {
firstUser
}, firstUser.Phones.Select(opt => opt.FullNumber).ToList(), secondUser.Id));
Assert.Empty(privacyService.ApplyPrivacySettings(new List <UserVm> {
firstUser
}, firstUser.Phones.Select(opt => opt.FullNumber).ToList(), fourthUser.Id));
}
public void UserApplyPrivacySettings()
{
var user = UserConverter.GetUserVm(fillTestDbHelper.Users.FirstOrDefault());
var hiddenUser = privacyService.ApplyPrivacySettings(user, user.Privacy);
user.Privacy[1] = true;
user.Privacy[2] = true;
var publicUser = privacyService.ApplyPrivacySettings(user, user.Privacy);
Assert.True(hiddenUser.About == null &&
hiddenUser.NameFirst == null &&
hiddenUser.NameSecond == null &&
hiddenUser.Tag == null &&
hiddenUser.Photo == null &&
hiddenUser.Emails == null &&
hiddenUser.Phones == null &&
publicUser.NameFirst != null &&
publicUser.NameSecond != null &&
publicUser.Tag != null &&
publicUser.About != null &&
publicUser.Photo != null);
}
public async Task <UserVm> UpdateUserEmailAsync(long userId, string email)
{
using (MessengerDbContext context = contextFactory.Create())
{
var user = await context.Users
.Include(opt => opt.Emails)
.Include(opt => opt.Phones)
.FirstOrDefaultAsync(opt => opt.Id == userId)
.ConfigureAwait(false);
user.Emails = new List <Emails>
{
new Emails
{
EmailAddress = email,
UserId = userId
}
};
context.Users.Update(user);
await context.SaveChangesAsync().ConfigureAwait(false);
return(UserConverter.GetUserVm(user));
}
}
public async Task ApplyPrivacySettingsGroupsAndContacts()
{
var user = fillTestDbHelper.Users.FirstOrDefault();
var firstUser = UserConverter.GetUserVm(fillTestDbHelper.Users.FirstOrDefault());
var secondUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(1).FirstOrDefault());
var thirdUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(2).FirstOrDefault());
var fourthUser = UserConverter.GetUserVm(fillTestDbHelper.Users.Skip(3).FirstOrDefault());
await contactsService.RemoveContactsAsync(user.Contacts.Select(opt => opt.ContactId).ToList(), user.Id);
var secondContact = await contactsService.CreateOrEditContactAsync(new ContactDto
{
ContactUserId = secondUser.Id.Value,
UserId = firstUser.Id.Value
});
var thirdContact = await contactsService.CreateOrEditContactAsync(new ContactDto
{
ContactUserId = thirdUser.Id.Value,
UserId = firstUser.Id.Value
});
var group = await gropsService.CreateOrEditGroupAsync(new GroupDto
{
UserId = firstUser.Id.Value,
UsersId = new List <long> {
thirdContact.ContactUserId
},
PrivacySettings = int.MaxValue
});
firstUser.ContactsPrivacy[1] = true;
var filteredBySecondUser = (await privacyService.ApplyPrivacySettingsAsync(new List <UserVm> {
firstUser
}, secondUser.Id)).FirstOrDefault();
Assert.True(filteredBySecondUser.NameFirst != null &&
filteredBySecondUser.NameSecond != null &&
filteredBySecondUser.Tag != null &&
filteredBySecondUser.About == null &&
filteredBySecondUser.Photo == null &&
filteredBySecondUser.Phones == null &&
filteredBySecondUser.Emails == null);
var filteredByThirdUser = (await privacyService.ApplyPrivacySettingsAsync(new List <UserVm> {
firstUser
}, thirdUser.Id)).FirstOrDefault();
Assert.True(filteredByThirdUser.NameFirst != null &&
filteredByThirdUser.NameSecond != null &&
filteredByThirdUser.Tag != null &&
filteredByThirdUser.About != null &&
filteredByThirdUser.Photo != null &&
filteredByThirdUser.Phones != null &&
filteredByThirdUser.Emails != null);
var filteredByFourthUser = (await privacyService.ApplyPrivacySettingsAsync(new List <UserVm> {
firstUser
}, fourthUser.Id)).FirstOrDefault();
Assert.True(filteredByFourthUser.NameFirst == null &&
filteredByFourthUser.NameSecond == null &&
filteredByFourthUser.Tag == null &&
filteredByFourthUser.About == null &&
filteredByFourthUser.Photo == null &&
filteredByFourthUser.Phones == null &&
filteredByFourthUser.Emails == null);
}
public async Task <ValuePair <UserVm, string> > CreateNewUserAsync(UserVm user, long nodeId, bool confirmed, string password = null)
{
using (MessengerDbContext context = contextFactory.Create())
{
using (var transaction = await context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
User targetUser = new User
{
Id = await poolsService.GetUserIdAsync().ConfigureAwait(false),
About = user.About,
Birthday = user.Birthday,
City = user.City,
Country = user.Country,
Language = user.Language,
NameFirst = user.NameFirst,
NameSecond = user.NameSecond,
Photo = user.Photo,
Confirmed = confirmed,
RegistrationDate = DateTime.UtcNow.ToUnixTime(),
NodeId = nodeId,
Privacy = user.Privacy?.ToInt32() ?? 0,
Tag = RandomExtensions.NextString(10, "QWERTYUIOPASDFGHJKLZXCVBNM1234567890")
};
if (user.Emails != null)
{
targetUser.Emails = user.Emails.Select(email => new Emails
{
EmailAddress = email
}).ToList();
}
if (user.Phones != null)
{
targetUser.Phones = user.Phones.Select(phone => new Phones
{
PhoneNumber = phone.FullNumber,
Main = phone.IsMain.GetValueOrDefault()
}).ToList();
}
if (password == null)
{
password = RandomExtensions.NextString(PASSWORD_LENGTH);
}
targetUser.Sha512Password = GetSha512Hash(password);
await context.Users.AddAsync(targetUser).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
return(new ValuePair <UserVm, string>(UserConverter.GetUserVm(targetUser), password));
}
catch (DbUpdateException ex)
{
if (ex.InnerException is PostgresException postgresException)
{
if (postgresException.ConstraintName == "IX_Emails_EmailAddress")
{
throw new CreateNewUserException($"Email already exists.");
}
if (postgresException.ConstraintName == "IX_Phones_PhoneNumber")
{
throw new CreateNewUserException($"Phone already exists");
}
}
throw new CreateNewUserException("Failed to create user.", ex);
}
catch (Exception ex)
{
transaction.Rollback();
throw new CreateNewUserException("Failed to create user.", ex);
}
}
}
}
