public IActionResult UpdateData([FromBody] DataModel model, int id)
{
using (IUpdateUnitOfWork <ProtectedData, int> unitOfWork = _repository.ProtectedDataRepository.Update(id))
{
if (unitOfWork == null)
{
return(NotFound());
}
User user = GetSessionUser();
IAuthorizer authorizer = new UserDataAuthorizerBuilder(user, unitOfWork.Entity)
.AddIsOwnerCheck()
.AddRequiredPermission(Permission.WRITE)
.Build();
if (!authorizer.Authorize())
{
return(StatusCode(403));
}
unitOfWork.Entity.Name = model.Name;
unitOfWork.Entity.Data = model.Data;
unitOfWork.Complete();
return(Ok());
}
}
public void UpdateNotExistingUser_ShouldNotThrowException()
{
using (IUpdateUnitOfWork <User, int> uow = repository.Update(99))
{
uow.Complete();
}
}
public void UpdateUser_ShouldSucceed()
{
using (DbCommand inserTestData = memoryDbConnection.CreateCommand())
{
inserTestData.CommandText = "INSERT INTO Users('Username', 'PasswordHash', 'RoleID') VALUES ('BarUser', 'pw', 1);" +
"INSERT INTO PublicKeys ('UserID', 'PublicKeyNumber', 'KeyData', 'Active') VALUES (1, 1, 'base64string', 1);";
inserTestData.ExecuteNonQuery();
}
using (IUpdateUnitOfWork <User, int> uow = repository.Update(1))
{
uow.Entity.UserName = "******";
uow.Entity.PasswordHash = "newPassword";
uow.Entity.PublicKeys[0].Flag = Key.KeyFlag.OBSOLET;
uow.Entity.PublicKeys[0].KeyData = Encoding.Default.GetBytes("ChangedKeyData");
uow.Entity.Role = "Admin";
uow.Complete();
}
User u = repository.GetById(1);
Assert.AreEqual("FooUser", u.UserName);
Assert.AreEqual("FooUser".ToUpper(), u.NormalizedUserName);
Assert.AreEqual("newPassword", u.PasswordHash);
Assert.AreEqual("Admin", u.Role);
Assert.AreEqual(Key.KeyFlag.OBSOLET, u.PublicKeys[0].Flag);
Assert.AreEqual(Convert.ToBase64String(Encoding.Default.GetBytes("ChangedKeyData")), Convert.ToBase64String(u.PublicKeys[0].KeyData));
}
public IActionResult EditKey([FromBody] PublicKeyModel model)
{
User sessionUser = _repository.UserRepository.GetUserByNormalizedName(User.Identity.Name.ToUpper());
using (IUpdateUnitOfWork <User, int> uow = _repository.UserRepository.Update(sessionUser.Id))
{
uow.Entity.PublicKeys.Find((k) => k.Id == model.KeyNumber).KeyData = Encoding.Default.GetBytes(model.KeyData);
if (model.Active)
{
uow.Entity.PublicKeys.Find((k) => k.Id == model.KeyNumber).Flag = Key.KeyFlag.ACTIVE;
}
else
{
uow.Entity.PublicKeys.Find((k) => k.Id == model.KeyNumber).Flag = Key.KeyFlag.OBSOLET;
}
uow.Complete();
}
return(Ok());
}
public IActionResult AddNewKey([FromBody] PublicKeyModel model)
{
Console.Write("Model: " + model.KeyData);
if (model.KeyData == null)
{
return(Ok());
}
User sessionUser = _repository.UserRepository.GetUserByNormalizedName(User.Identity.Name.ToUpper());
using (IUpdateUnitOfWork <User, int> uow = _repository.UserRepository.Update(sessionUser.Id))
{
uow.Entity.PublicKeys.Add(new Key()
{
KeyData = Encoding.UTF8.GetBytes(model.KeyData)
});
uow.Complete();
}
return(Ok());
}
public void UpdateUser_AddNewKey_ShouldIgnore()
{
using (DbCommand inserTestData = memoryDbConnection.CreateCommand())
{
inserTestData.CommandText = "INSERT INTO Users('Username', 'PasswordHash', 'RoleID') VALUES ('BarUser', 'pw', 1);" +
"INSERT INTO PublicKeys ('UserID', 'PublicKeyNumber', 'KeyData', 'Active') VALUES (1, -1, 'base64string', 1);";
inserTestData.ExecuteNonQuery();
}
using (IUpdateUnitOfWork <User, int> uow = repository.Update(1))
{
uow.Entity.PublicKeys.Add(new Key()
{
KeyData = Encoding.Default.GetBytes("NewKeyData")
});
uow.Complete();
}
User u = repository.GetById(1);
Assert.AreEqual(1, u.PublicKeys.Count);
}
public Task <IdentityResult> UpdateAsync(User user, CancellationToken cancellationToken)
{
try
{
using (IUpdateUnitOfWork <User, int> uow = UserRepository.Update(user.Id))
{
if (uow != null)
{
uow.Entity.NormalizedUserName = user.NormalizedUserName;
uow.Entity.PasswordHash = user.PasswordHash;
uow.Entity.PublicKeys = user.PublicKeys;
uow.Entity.Role = user.Role;
}
uow.Complete();
}
}
catch (IOException exception)
{
return(GetResultFromUnitCompleteException(exception));
}
return(Task.FromResult(IdentityResult.Success));
}
