public void SendRequestDeniedMessage(UserAggregate forAgg, List <PermissionAggregate> deniedPermissions)
{
try
{
var PermissionNames = new List <string>();
foreach (var permission in deniedPermissions)
{
PermissionNames.Add(permission.Name);
}
var requests = String.Join(", ", PermissionNames.ToArray());
//recipient address
_mail.To.Add(new MailAddress(forAgg.Email));
_mail.Subject = "*******Request Denied********";
//Formatted mail body
_mail.IsBodyHtml = true;
string message = "Hello " + forAgg.FirstName + " " + forAgg.LastName + ", the request(s) for your access to the following: " + requests + ", was denied. ";
_mail.Body = message;
_smtp.Send(_mail);
}
catch (Exception)
{
}
}
public void SendPermissionsUpdatedMessage(UserAggregate forAgg, List <PermissionAggregate> revokedPermissions, List <PermissionAggregate> grantedPermissions)
{
try
{
var revokedPermissionNames = new List <string>();
foreach (var permission in revokedPermissions)
{
revokedPermissionNames.Add(permission.Name);
}
var revokedPermissionsString = String.Join(", ", revokedPermissionNames.ToArray());
var grantedPermissionNames = new List <string>();
foreach (var permission in grantedPermissions)
{
grantedPermissionNames.Add(permission.Name);
}
var grantedPermissionsString = String.Join(", ", grantedPermissionNames.ToArray());
//recipient address
_mail.To.Add(new MailAddress(forAgg.Email));
_mail.Subject = "*******Permissions Updated********";
//Formatted mail body
_mail.IsBodyHtml = true;
string message = "Hello " + forAgg.FirstName + " " + forAgg.LastName + ", The following permissions have been Revoked: " + revokedPermissionsString + ". The following permissions have been Granted: " + grantedPermissionsString + ". ";
_mail.Body = message;
_smtp.Send(_mail);
}
catch (Exception)
{
}
}
public void Registration(UserDTO User)
{
UserAggregate UserAgg = new UserAggregate(new UserEntity()
{
ID = User.ID,
UserName = User.UserName,
Email = User.Email,
PasswordHash = User.PasswordHash,
PasswordRepeatHash = User.PasswordRepeatHash,
IsActive = true
});
List <string> ValidationResult = UserAgg.Validation(ValidationStateEnum.Registation);
if (ValidationResult.Count == 0)
{
var UserData = UserAgg.GetUser();
_UserRepository.Registration(new UserDTO()
{
ID = UserData.ID,
UserName = UserData.UserName,
Email = UserData.Email,
PasswordHash = UserData.PasswordHash,
PasswordRepeatHash = UserData.PasswordRepeatHash,
});
}
else
{
throw new CustomException(ValidationResult);
}
}
public void setup_session_to_return_correct_aggregate(UserAggregate agg, PermissionAggregate permAgg)
{
// Get UserAggregate
SessionMock.Setup(a => a.Get <UserAggregate>(It.IsAny <Guid>(), It.IsAny <int?>(), It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionGetWasCalled = true;
})
.Returns(Task.FromResult(agg));
// Get PermissionAggregate
SessionMock.Setup(a => a.Get <PermissionAggregate>(It.IsAny <Guid>(), It.IsAny <int?>(), It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionGetPermisisonWasCalled = true;
})
.Returns(Task.FromResult(permAgg));
// Commit
SessionMock.Setup(a => a.Commit(It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionCommitWasCalled = true;
})
.Returns(Task.FromResult(0));
}
public Task Consume(ConsumeContext <UserRegister> context)
{
var aggregate = new UserAggregate();
aggregate.RegisterUser(new UserDetails()
{
AnnualIncomeBeforeTax = context.Message.AnnualIncomeBeforeTax,
DoB = context.Message.DoB,
Email = context.Message.Email,
EmploymentStatus = context.Message.EmploymentStatus,
Firstname = context.Message.Firstname,
HomeOwnership = context.Message.HomeOwnership,
Lastname = context.Message.Lastname,
LoanReason = context.Message.LoanReason,
MonthlyMortgageContribution = context.Message.MonthlyMortgageContribution,
MonthlyRentContribution = context.Message.MonthlyRentContribution,
PhoneNumber = context.Message.PhoneNumber,
Title = context.Message.Title,
UserId = context.Message.UserId
});
repository.Save(aggregate);
return(Task.FromResult(0));
}
/// <summary>Создает пару JWT токенов для пользователя</summary>
/// <param name="user">Аутентифицируемый пользователь</param>
/// <returns>Пара Access/refresh JWT токенов</returns>
private LoginResponse CreateTokensPair(UserAggregate user)
{
// Создание списка Claim'ов
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, user.Username),
new Claim(ClaimsIdentity.DefaultRoleClaimType, user.Role)
};
// Генерация Access и Refresh токенов
var accessTokenRaw = _jwtAccessOptions.GenerateToken(claims);
var refreshTokenRaw = _jwtRefreshOptions.GenerateToken(claims);
var securityHandler = new JwtSecurityTokenHandler();
var accessToken = securityHandler.WriteToken(accessTokenRaw);
var refreshToken = securityHandler.WriteToken(refreshTokenRaw);
// Формирование ответа от сервера
var loginResponse = new LoginResponse()
{
AccessToken = accessToken,
ExpiresIn = accessTokenRaw.ValidTo.ToEpochTime(),
RefreshToken = refreshToken,
};
return(loginResponse);
}
public Guid Login(LoginDTO User)
{
UserAggregate UserAgg = new UserAggregate(new UserEntity()
{
UserName = User.UserName,
PasswordHash = User.PasswordHash
});
List <string> ValidationResult = UserAgg.Validation(ValidationStateEnum.Login);
if (ValidationResult.Count == 0)
{
var UserData = UserAgg.GetUser();
return(_UserRepository.Login(new LoginDTO()
{
UserName = UserData.UserName,
PasswordHash = UserData.PasswordHash,
SessionID = UserData.SessionID
}));
}
else
{
throw new CustomException(ValidationResult);
}
}
public async Task <IdentityResult> Handle(Command request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByIdAsync(request.Id);
var allUserRoles = await _context.UserRoles.Where(x => x.UserId == request.Id)
.Join(_context.Roles, ur => ur.RoleId, r => r.Id, (ur, r) => new { r.Id, r.Name })
.ToListAsync(cancellationToken);
List <string> rolesToRemove = allUserRoles.Where(x => !request.RolesId.Contains(x.Id)).Select(x => x.Name).ToList();
List <string> rolesId = allUserRoles.Select(x => x.Id).ToList();
List <string> rolesToAddIds = request.RolesId.Where(x => !rolesId.Contains(x)).ToList();
List <string> rolesToAddNames = await _context.Roles.Where(x => rolesToAddIds.Contains(x.Id))
.Select(x => x.Name).ToListAsync(cancellationToken);
foreach (string roleName in rolesToRemove)
{
await _userManager.RemoveFromRoleAsync(user, roleName);
}
foreach (string roleName in rolesToAddNames)
{
await _userManager.AddToRoleAsync(user, roleName);
}
user = UserAggregate.FromState(user).Update(request).State;
IdentityResult updateResult = await _userManager.UpdateAsync(user);
return(updateResult);
}
public void UserController_GetByUsername_ReturnUser()
{
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
var user01 = UserAggregate.Create("jsmith", "*****@*****.**", "password hash", "security stamp");
var user02 = UserAggregate.Create("mjane", "*****@*****.**", "password hash", "security stamp");
databaseContext.Set <UserAggregate>().AddRange(new[] { user01, user02 });
databaseContext.SaveChanges();
}
using (WebApp.Start <Startup>(url: iisAddress))
{
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.GetAsync(String.Format("{0}UserRead?username={1}", iisAddress, "jsmith")).Result;
response.StatusCode.Should().Be(HttpStatusCode.OK);
var result = response.Content.ReadAsStringAsync().Result;
Debug.WriteLine(response.Content.ReadAsStringAsync().Result);
var user = JsonConvert.DeserializeObject <UserMessage>(result);
user.Username.Should()
.Be("jsmith");
}
}
public UserAggregate GetUserInfo(string accountNumber)
{
var user = session.Query <User>().FirstOrDefault(x => x.AccountNumber == accountNumber);
var ammout = session.Load <AccountUpdateEvent>($"{user.Id}/Events").Updates.Sum(x => x.Ammount);
return(UserAggregate.Create(user, ammout));
}
public void setup_session_to_return_aggregate_with_requested_permission(UserAggregate agg, PermissionAggregate permAgg)
{
SessionCommitWasCalled = false;
var input = new RequestUserPermissionsDTO
{
ForId = agg.Id,
ById = agg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{
permAgg.Id, new PermissionDetails
{
Reason = "testReason"
}
}
}
};
agg.UserRequestedPermissions(new List <PermissionAggregate> {
permAgg
}, input);
SessionMock.Setup(a => a.Get <UserAggregate>(It.IsAny <Guid>(), It.IsAny <int?>(), It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionGetWasCalled = true;
})
.Returns(Task.FromResult(agg));
}
public async Task It_should_delete_entity_and_record_change_log()
{
// Given
var user = new UserAggregate(Guid.NewGuid(), "Bond");
using var db = NewDbContext();
db.Users.Add(user);
await db.SaveChangesAsync();
// When
user.Delete();
var changeLog = user.Changes.GetUncommittedChanges().ToList();
db.Users.Remove(user);
await db.SaveChangesAsync();
// Then
db.DetachAll();
var savedUser = await db.Users.FindAsync(user.Id);
var savedChangeLog = (await LoadChangeLog(user.StreamId)).AsEnumerable()
.Reverse()
.Take(changeLog.Count)
.Reverse()
.ToList();
savedUser.Should().BeNull();
for (var i = 0; i < savedChangeLog.Count; i++)
{
savedChangeLog[i].Should().BeEquivalentTo((object)changeLog[i]);
savedChangeLog[i].Should().BeOfType(changeLog[i].GetType());
}
}
/**
* filters actions taken according to the forAgg's permissionList's event type, and the event types being passed in
*
* Ex: if a forAgg's permission list has VisualStudio permission's eventType as "revoked", we do not want to be able to revoke it again, so we
* remove it from the list of actions.
*/
private Dictionary <Guid, PermissionDetails> VerifyActions(UserAggregate forAgg, UserAggregate byAgg, Dictionary <Guid, PermissionDetails> requests, List <string> eventTypesToRemove)
{
var result = new Dictionary <Guid, PermissionDetails>();
var markedForRemoval = new List <Guid>();
foreach (var request in requests)
{
result[request.Key] = request.Value;
//if forAgg's permission list contains a definition for that permission
if (forAgg.PermissionList.ContainsKey(request.Key))
{
// if the definition of that permission is one of the eventTypes to remove, remove it from requests.
if (eventTypesToRemove.Contains(
JsonConvert.DeserializeObject <string>(forAgg.PermissionList[request.Key].EventType)))
{
markedForRemoval.Add(request.Key);
}
else
{
//might not even need this******because admin rights are handled in the aggregate.
//(admins can override eventTypes) Otherwise, if they are not an admin, remove it from requests
if (!byAgg.IsAdmin)
{
markedForRemoval.Add(request.Key);
}
}
} // if the permission list does not contain, this case will be handled by the aggregate since admins can do
// whatever they want. and the aggregate will restrict user actions based on that
}
markedForRemoval.ForEach(a => result.Remove(a));
return(result);
}
public void UserAggregate_Delete_WillDelete()
{
// create
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
var user = UserAggregate.Create("raffaeu", "*****@*****.**",
"password hash", "security stamp");
databaseContext.Set <UserAggregate>().Add(user);
databaseContext.SaveChanges();
}
// delete
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
var user = databaseContext.Set <UserAggregate>().First();
databaseContext.Set <UserAggregate>().Remove(user);
databaseContext.SaveChanges();
}
// verify
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
databaseContext.Set <UserAggregate>().Count().Should().Be(0);
}
}
public void UserAggregate_AddClaim_WillPersist()
{
// create
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
var user = UserAggregate.Create("raffaeu", "*****@*****.**",
"password hash", "security stamp");
user.AddClaim("LOCAL AUTHORITY", "LOCAL AUTHORITY", "schema", "Raffaeu", "schema#string");
databaseContext.Set <UserAggregate>().Add(user);
databaseContext.SaveChanges();
}
// verify
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
var expectedUser = databaseContext.Set <UserAggregate>()
.Include(x => x.Claims)
.First();
expectedUser.Claims.Count.Should().Be(1);
}
}
public void It_should_reply_change_log()
{
// Given
var id = Random.NextGuid();
var name = Random.GetString();
var changedName = Random.GetString();
var history = new IDomainEvent[]
{
new UserRegistered {
Id = id, Name = name
},
new UserNameChanged {
Name = changedName
}
};
// When
var user = new UserAggregate();
user.Changes.LoadFromHistory(history);
// Then
Assert.That(user.Changes.GetUncommittedChanges(), Is.Empty);
Assert.That(user.Id, Is.EqualTo(id));
Assert.That(user.Name, Is.EqualTo(changedName));
Assert.That(user.Version, Is.EqualTo(2));
}
public async Task AddAndRetrieve_MultipleSimpleObjects_Success()
{
var unitOfWork = new UserUnitOfWork(Database, CollectionName);
var person1 = new UserAggregate()
{
FirstName = "John",
Surname = "Smith"
};
var person2 = new UserAggregate()
{
FirstName = "Jane",
Surname = "Doe"
};
unitOfWork.Users.Add(person1);
unitOfWork.Users.Add(person2);
await unitOfWork.CommitAsync();
var person1Result = await unitOfWork.Users.QuerySingleAsync(user => user.Id == person1.Id);
var person2Result = await unitOfWork.Users.QuerySingleAsync(user => user.Id == person2.Id);
Assert.IsNotNull(person1Result);
Assert.IsNotNull(person2Result);
}
public void It_should_record_change_log_when_entity_is_updated()
{
// Given
var id = Random.NextGuid();
var name = Random.GetString();
var changedName = Random.GetString();
var user = new UserAggregate(id, name);
user.Changes.MarkChangesAsCommitted();
// When
user.Rename(changedName);
// Then
var changes = user.Changes.GetUncommittedChanges().ToList();
Assert.That(changes, Has.Count.EqualTo(1));
Assert.That(changes[0], Is.TypeOf <UserNameChanged>());
var evt = (UserNameChanged)changes[0];
Assert.That(evt.Id, Is.EqualTo(id));
Assert.That(evt.Name, Is.EqualTo(changedName));
Assert.That(evt.Version, Is.EqualTo(2));
Assert.That(user.Version, Is.EqualTo(2));
}
public async Task It_should_rollback_both_entity_and_change_log_within_sync_flow()
{
// Given
var id = Guid.NewGuid();
var user = new UserAggregate(id, "Bond");
var changeLog = user.Changes.GetUncommittedChanges().ToList();
using var db = NewDbContext();
db.Users.Add(user);
await db.SaveChangesAsync();
// When
using (var tran = TransactionExt.Begin(IsolationLevel.ReadCommitted))
{
user.Rename("James Bond");
db.SaveChanges();
}
// Then
db.DetachAll();
var savedUser = await db.Users.FindAsync(id);
var savedChangeLog = await LoadChangeLog(user.StreamId);
savedUser.Should().BeEquivalentTo(new UserAggregate(id, "Bond"));
savedChangeLog.Should().HaveSameCount(changeLog);
for (var i = 0; i < savedChangeLog.Count; i++)
{
savedChangeLog[i].Should().BeEquivalentTo((object)changeLog[i]);
savedChangeLog[i].Should().BeOfType(changeLog[i].GetType());
}
}
public void UserAggregate_Created_EmptyValues_IsNotValid()
{
var user = UserAggregate.Create(
string.Empty, string.Empty,
string.Empty, string.Empty);
user.IsValid.Should().BeFalse();
}
public CommandStatus Handle(CreateUserCommand message)
{
var user = new UserAggregate(_userService, message.Key, message.Name);
_userStore.Save("Users", user);
return(CommandStatus.Accepted);
}
public void IncludeUpdateTest()
{
var userBuilder = new UserAggregateBuilder();
var userAggregate = userBuilder.GetRandomUserAggregate();
var user = UserAggregate.Update(userAggregate.Id, userAggregate);
userAggregate.Should().BeEquivalentTo(user);
}
public void UserAggregate_Create_ValidValues_IsValid()
{
var user = UserAggregate.Create(
"Username", "Email",
"PasswordHash", "SecurityStamp");
user.IsValid.Should().BeTrue();
}
public async Task <Guid> Create(UserCreateRequest request)
{
var user = UserAggregate.CreateFromRequest(request);
await _repo.Add(user);
return(user.Id);
}
public async Task <UserId> SetAsync(UserAggregate aggregate)
{
var user = await ToModel(aggregate);
_context.Users.Upsert(user);
await _context.SaveChangesAsync();
return(new UserId(user.Id));
}
public async Task <Guid> Create(User item)
{
var user = UserAggregate.Create(item.Username, item.PasswordHash, item.Role);
item.EnsureNotNull(nameof(item));
await _userAggregateRepo.Add(user);
return(item.Id);
}
private void Commit(UserAggregate aggregate)
{
var changes = _repository.Save(aggregate);
foreach (var change in changes)
{
_publisher.Publish(change);
}
}
public void Handle(StartUserRegistration c)
{
var aggregate = new UserAggregate {
AggregateIdentifier = c.AggregateIdentifier
};
aggregate.StartRegistration(c.Name, c.Password);
Commit(aggregate);
}
public UserAggregate GetUserInfoFromSpan(string accountNumber, TimeSpan span)
{
var user = session.Query <User>().FirstOrDefault(x => x.AccountNumber == accountNumber);
var ammout =
session.Load <AccountUpdateEvent>($"{user.Id}/Events")
.Updates.Where(x => x.OccuredDate - DateTime.Now <= span)
.Sum(x => x.Ammount);
return(UserAggregate.Create(user, ammout));
}
public void given_create_user_with_bad_input_should_throw_CreateUserDataNotFoundException()
{
// Assemble
CreateUserInputDTO input = new CreateUserInputDTO();
UserAggregate agg;
// Apply / Assert
Assert.Throws <CreateUserDataNotFoundException>(() => agg = UserAggregate.CreateNewUser(input));
}
public void Given_a_user_When_updating_the_name_Then_update_name_event_is_witten_to_the_store()
{
var eventStore = new ListEventStore<IUserCommand>();
var userAggregate = new UserAggregate();
using (var user = new User(eventStore, userAggregate))
{
user.ChangeName("The Name");
Assert.IsTrue(eventStore.Events.Any());
}
}
