public async Task <ShoppingUserModel> GetUserByIdAsync(string id)
{
ShoppingUserModel userModel = null;
var user = await _userManager.FindByIdAsync(id);
if (user != null)
{
userModel = new ShoppingUserModel()
{
Id = user.Id,
UserName = user.UserName,
Email = user.Email,
Settings = new ShoppingUserSettingsModel()
{
FirstName = user.FirstName,
LastName = user.LastName,
StandardUserGroupId = user.StandardUserGroupId
}
};
}
else
{
_logger.LogError($"Could not find any user by id: {id}");
}
return(userModel);
}
public async Task <UserGroup> AddUserToGroup(string userGroupId, ShoppingUserModel user)
{
var group = await GetAsync(userGroupId);
var existingUser = await _userRepository.GetUserAsync(user);
if (existingUser == null)
{
throw new ItemNotFoundException($"No user with provided user data found");
}
if (group.Members.Any(m => m.Id == existingUser.Id))
{
throw new ItemAlreadyExistsException($"User with '{existingUser.UserName} already exists in group: '{group.Name}'");
}
_context.UserGroupMembers.Add(new UserGroupMembers
{
MemberId = existingUser.Id,
UserGroupId = userGroupId
});
await _context.SaveChangesAsync();
return(group);
}
public async Task <List <string> > GetRolesOfUserAsync(ShoppingUserModel userModel)
{
List <string> roles = null;
var dbUser = await GetDbUserFromModelData(userModel);
if (dbUser != null)
{
roles = (await _userManager.GetRolesAsync(dbUser)).ToList();
}
return(roles);
}
public static ICurrentUserProvider GetMockUserProvider(ShoppingUserModel user)
{
var userRepoMock = new Mock <ICurrentUserProvider>();
userRepoMock.Setup(m => m.GetUserAsync())
.Returns(Task.FromResult(user));
bool isAdmin = user.UserName.Contains("admin", StringComparison.InvariantCultureIgnoreCase);
userRepoMock.Setup(m => m.IsUserAdminAsync())
.Returns(Task.FromResult(isAdmin));
return(userRepoMock.Object);
}
public ShoppingUserModel CreateUserModel()
{
var userModel = new ShoppingUserModel();
if (new EmailAddressAttribute().IsValid(this.UserNameOrEmail))
{
userModel.Email = this.UserNameOrEmail;
}
else
{
userModel.UserName = this.UserNameOrEmail;
}
return(userModel);
}
public async Task <ShoppingUserModel> UpdateUserData(string id, ShoppingUserModel updateData)
{
var client = await _authService.GetHttpClientAsync();
var response = await client.PutAsJsonAsync($"{BaseAddress}/{id}", updateData);
var resultObject = await response.Content.ReadFromJsonAsync <ShoppingUserResult>();
if (!response.IsSuccessStatusCode)
{
throw new Exception(resultObject.CompleteErrorMessage);
}
return(resultObject.ResultData.FirstOrDefault());
}
public async Task <ShoppingUserModel> UpdateUserData(string id, ShoppingUserModel updateData)
{
var user = await _userManager.FindByIdAsync(id);
user.Email = updateData.Email;
user.UserName = updateData.UserName;
var updateResult = await _userManager.UpdateAsync(user);
if (!updateResult.Succeeded)
{
_logger.LogError("Could not update user", updateResult.GetErrorMessagesAsList());
return(null);
}
return(updateData);
}
public async Task <UserGroup> RemoveUserFromGroup(string userGroupId, ShoppingUserModel user)
{
var group = await GetAsync(userGroupId);
var existingUser = await _userRepository.GetUserAsync(user);
if (existingUser == null)
{
throw new ItemNotFoundException($"No user with provided user data found");
}
var assignment = await _context.UserGroupMembers.FirstOrDefaultAsync(c => c.UserGroupId == userGroupId && c.MemberId == user.Id);
_context.UserGroupMembers.Remove(assignment);
await _context.SaveChangesAsync();
return(group);
}
public async Task <ShoppingUserModel> GetUserAsync()
{
ShoppingUserModel user = null;
var name = _httpContextAccessor.HttpContext.User.Identity.Name;
if (!string.IsNullOrEmpty(name))
{
_logger.LogDebug($"Searching for user with user name or email: {name}");
var dbUser = await _userManager.FindByNameAsync(name);
if (dbUser == null)
{
dbUser = await _userManager.FindByEmailAsync(name);
}
if (dbUser != null)
{
user = GetUserModelFromDbData(dbUser);
}
}
return(user);
}
private async Task <ShoppingUser> GetDbUserFromModelData(ShoppingUserModel userModel)
{
ShoppingUser dbUser = null;
if (!string.IsNullOrEmpty(userModel.Id))
{
dbUser = await _userManager.FindByIdAsync(userModel.Id);
}
else if (!string.IsNullOrEmpty(userModel.UserName))
{
dbUser = await _userManager.FindByNameAsync(userModel.UserName);
}
else if (!string.IsNullOrEmpty(userModel.Email))
{
dbUser = await _userManager.FindByEmailAsync(userModel.Email);
}
else
{
_logger.LogError($"No valid data provided");
}
return(dbUser);
}
public async Task <UserGroup> AddUserToGroup(string userGroupId, ShoppingUserModel user)
{
var client = await GetApiClient();
var content = new StringContent(JsonConvert.SerializeObject(user), System.Text.Encoding.UTF8, "application/json");
var response = await client.PutAsync($"{_baseUri}/AddUser/{userGroupId}", content);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadFromJsonAsync <UserGroupResult>();
if (!result.IsSuccessful)
{
throw new Exception(result.CompleteErrorMessage);
}
else
{
return(result.ResultData.FirstOrDefault());
}
}
return(null);
}
public async Task <ShoppingUserModel> GetUserAsync(ShoppingUserModel userModel)
{
var dbUser = await GetDbUserFromModelData(userModel);
ShoppingUserModel modelFromDbData = null;
if (dbUser != null)
{
modelFromDbData = new ShoppingUserModel()
{
Id = dbUser.Id,
UserName = dbUser.UserName,
Email = dbUser.Email,
Settings = new ShoppingUserSettingsModel()
{
FirstName = dbUser.FirstName,
LastName = dbUser.LastName,
StandardUserGroupId = dbUser.StandardUserGroupId
}
};
}
return(modelFromDbData);
}
public async Task <ActionResult <UserGroupResult> > RemoveUserFromGroup(string id, [FromBody] ShoppingUserModel user)
{
var result = new UserGroupResult();
var currentUser = await _userProvider.GetUserAsync();
bool isUserInGroup = await _userGroups.UserIsInGroupAsync(id, currentUser.Id);
bool isAdmin = await _userProvider.IsUserAdminAsync();
if (!(isAdmin || isUserInGroup))
{
result.IsSuccessful = false;
result.ErrorMessages.Add("Not authorized");
return(Unauthorized(result));
}
try
{
var group = await _userGroups.RemoveUserFromGroup(id, user);
group.Owner = await _userRepository.GetUserByIdAsync(group.OwnerId);
foreach (var member in group.Members)
{
var dbUser = await _userRepository.GetUserByIdAsync(member.Id);
member.UserName = dbUser.UserName;
member.Email = dbUser.Email;
}
result.IsSuccessful = true;
result.ResultData.Add(group);
}
catch (Exception e)
{
result.IsSuccessful = false;
result.ErrorMessages.Add(e.Message);
throw e;
}
return(Ok(result));
}
public async Task <ActionResult <ShoppingUserResult> > UpdateUserData(string id, [FromBody] ShoppingUserModel updatedData)
{
ShoppingUserResult result = new ShoppingUserResult();
if (id != updatedData.Id)
{
result.IsSuccessful = false;
result.ErrorMessages.Add($"Ids do not match");
return(BadRequest(result));
}
if (!(await IsUserAuthorized(id)))
{
result.IsSuccessful = false;
result.ErrorMessages.Add("Not authorized to access this resource");
return(Unauthorized(result));
}
var updateResult = await _userRepository.UpdateUserData(id, updatedData);
if (updateResult == null)
{
result.IsSuccessful = false;
result.ErrorMessages.Add("Could not update user data");
return(NotFound(result));
}
result.IsSuccessful = true;
result.ResultData.Add(updateResult);
return(Ok(result));
}
public ShoppingList()
{
UserGroups = new List <UserGroup>();
Items = new List <ShoppingListItem>();
Owner = new ShoppingUserModel();
}
public Task <List <string> > GetRolesOfUserAsync(ShoppingUserModel userModel)
{
throw new NotImplementedException();
}
public Task <ShoppingUserModel> GetUserAsync(ShoppingUserModel userModel)
{
throw new NotImplementedException();
}
