private void OnCreated(UserCreated args)
{
this.Id = args.UserId;
this.FullName = args.FullName;
this.BirthDate = args.BirthDate;
this.Address = args.Address;
}
// Entry Point
public void CreateNewUsers(NewUserRequest[] newUsers)
{
// Do some validation
foreach (var request in newUsers)
{
AssertIsValid(request);
}
// Create new users
var users = newUsers
.Select(x => new User {
UserName = x.UserName
}).ToArray();
// Write it to the database
PersistUsers(users);
// Publish an event about the new user
// to a service bus
foreach (var user in users)
{
var @event = new UserCreated
{
UserName = user.UserName
};
_publisher.Publish(@event);
}
}
public void When(UserCreated e)
{
_store.Add(e.AggregateId, new ActiveUserView
{
Id = e.AggregateId
});
}
// public UserDashboard Create(UserCreated @event)
// {
// var item = new UserDashboard();
// item.Id = @event.UserId;
// item.UserName = @event.UserName;
// item.OrdersCount = 0;
// item.TotalAmount = 0;
// return item;
// }
public void Apply(UserDashboard item, UserCreated @event)
{
item.Id = @event.UserId;
item.UserName = @event.UserName;
item.OrdersCount = 0;
item.TotalAmount = 0;
}
public User(Guid id, string name)
{
var @event = new UserCreated(id, name);
Enqueue(@event);
Apply(@event);
}
protected void ProcessUserCreated(UserCreated @event)
{
this.Id = @event.UserId;
this.Name = @event.Username;
this.Job = @event.Job;
this.IsDeleted = @event.IsDeleted;
}
private void Handle(UserCreated evnt)
{
using (var conn = _connectionFactory.OpenConnection())
{
conn.Insert(evnt, "EventSourcing_Sample_User");
}
}
public void serialize_userAdded()
{
var evnt = new UserCreated(Guid.NewGuid(), DateTime.Now, UserId.CreateNew(), new UserLoginInfo("prov", "key"), "username", "password");
var settings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.None,
DefaultValueHandling = DefaultValueHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore,
ConstructorHandling = Newtonsoft.Json.ConstructorHandling.Default,
//Formatting = Newtonsoft.Json.Formatting.Indented,
ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver
{
DefaultMembersSearchFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
},
//ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
};
var data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(evnt, settings));
var result = (UserCreated)JsonConvert.DeserializeObject(Encoding.UTF8.GetString(data), typeof(UserCreated));
Assert.AreEqual(evnt.Id, result.Id);
Assert.AreEqual(evnt.Timestamp, result.Timestamp);
Assert.AreEqual(evnt.LoginInfo, result.LoginInfo);
Assert.AreEqual(evnt.UserId, result.UserId);
}
public async Task GivenTwoEventHandlers_WhenEventIsPublished_ThenBothHandles()
{
//Given
var services = new ServiceCollection();
services.AddDDD();
services.RegisterEventHandler <UserCreated, UsersCountHandler>(ServiceLifetime.Singleton);
services.RegisterEventHandler <UserCreated, UsersIdsHandler>(ServiceLifetime.Singleton);
var sp = services.BuildServiceProvider();
var eventBus = sp.GetService <IEventBus>();
var @event = new UserCreated(Guid.NewGuid());
//When
await eventBus.Publish(@event);
//Then
var usersCountHandler = sp.GetService <UsersCountHandler>();
usersCountHandler.UserCount.Should().Be(1);
var usersIdsHandler = sp.GetService <UsersIdsHandler>();
usersIdsHandler.UserIds.Should().HaveCount(1);
usersIdsHandler.UserIds.Should().Contain(@event.UserId);
}
public void Apply(UserCreated evnt)
{
Id = evnt.UserId.ToString();
UserName = evnt.UserName;
Created = evnt.Timestamp;
LoginInfo = evnt.LoginInfo;
}
protected virtual void OnUserCreated(User user)
{
UserCreated?.Invoke(this, new UserEventArgs()
{
User = user
});
}
public void Handle(UserCreated message)
{
var accommodationSupplier = new AccommodationSupplier(Data.AccommodationSupplierId, message.Name,
message.Email);
DomainRepository.Save(accommodationSupplier);
}
public void given_two_events_with_the_same_value_for_unique_field_with_single_property_when_inline_transformation_is_applied_then_throws_exception()
{
//1. Create Events
const string email = "*****@*****.**";
var firstEvent = new UserCreated {
UserId = Guid.NewGuid(), Email = email, FirstName = "John", Surname = "Smith"
};
var secondEvent = new UserCreated {
UserId = Guid.NewGuid(), Email = email, FirstName = "John", Surname = "Doe"
};
using (var store = InitStore())
{
using (var session = store.OpenSession())
{
//2. Publish Events
session.Events.Append(firstEvent.UserId, firstEvent);
session.Events.Append(secondEvent.UserId, secondEvent);
//3. Unique Exception Was thrown
try
{
session.SaveChanges();
}
catch (MartenCommandException exception)
{
((PostgresException)exception.InnerException).SqlState.ShouldBe(UniqueSqlState);
}
}
}
}
public void VoteQuestion(UserCreated fromUser, bool vote)
{
if (votesMap_.Contains(new KeyValuePair <Guid, bool>(fromUser.userId_, vote)))
{
return;
}
else if (votesMap_.ContainsKey(fromUser.userId_))
{
if (vote)
{
votes_ += 2;
votesMap_[fromUser.userId_] = true;
}
else
{
votes_ -= 2;
votesMap_[fromUser.userId_] = false;
}
}
else
{
if (vote)
{
votes_ += 1;
}
else
{
votes_ -= 1;
}
votesMap_.Add(fromUser.userId_, vote);
}
}
public void AggregateStream_ShouldReturnSpecifiedVersionOfTheStream()
{
var streamId = Guid.NewGuid();
var userCreated = new UserCreated(streamId, "John Doe");
var userNameUpdated = new UserNameUpdated(streamId, "Adam Smith");
var userNameUpdatedAgain = new UserNameUpdated(streamId, "Michael Newman");
eventStore.AppendEvent <User>(streamId, userCreated);
eventStore.AppendEvent <User>(streamId, userNameUpdated);
eventStore.AppendEvent <User>(streamId, userNameUpdatedAgain);
var aggregateAtVersion1 = eventStore.AggregateStream <User>(streamId, 1);
aggregateAtVersion1.Id.Should().Be(streamId);
aggregateAtVersion1.Name.Should().Be(userCreated.UserName);
aggregateAtVersion1.Version.Should().Be(1);
var aggregateAtVersion2 = eventStore.AggregateStream <User>(streamId, 2);
aggregateAtVersion2.Id.Should().Be(streamId);
aggregateAtVersion2.Name.Should().Be(userNameUpdated.UserName);
aggregateAtVersion2.Version.Should().Be(2);
var aggregateAtVersion3 = eventStore.AggregateStream <User>(streamId, 3);
aggregateAtVersion3.Id.Should().Be(streamId);
aggregateAtVersion3.Name.Should().Be(userNameUpdatedAgain.UserName);
aggregateAtVersion3.Version.Should().Be(3);
}
public QuestionPublished(QuestionMO question, Guid questionID, UserCreated user) {
question_ = question;
questionID_ = questionID;
user_ = user;
votes_ = 0;
votesMap_ = new Dictionary<Guid, bool>();
}
public void Handle(IViewContext context, UserCreated domainEvent)
{
UserProfiles.Add(new UserProfile
{
Id = domainEvent.GetAggregateRootId()
});
}
public async Task WriteASingleEventAsynchronously()
{
var eventStreamId =
new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C");
using (var storage = new AtomEventsInMemory())
{
var pageSize = 25;
var serializer = DataContractContentSerializer.Scan(
typeof(UserCreated).Assembly);
var obs = new AtomEventObserver<object>(
eventStreamId, // a Guid
pageSize, // an Int32
storage, // an IAtomEventStorage object
serializer); // an IContentSerializer object
var userCreated = new UserCreated
{
UserId = eventStreamId,
UserName = "******",
Password = "******",
Email = "*****@*****.**"
};
await obs.AppendAsync(userCreated);
Assert.NotEmpty(storage);
}
}
public void VoteQuestion(UserCreated fromUser, bool vote)
{
if (votesMap.Contains(new KeyValuePair <Guid, bool>(fromUser.UserId, vote)))
{
return;
}
else if (votesMap.ContainsKey(fromUser.UserId))
{
if (vote)
{
Votes += 2;
votesMap[fromUser.UserId] = true;
}
else
{
Votes -= 2;
votesMap[fromUser.UserId] = false;
}
}
else
{
if (vote)
{
Votes += 1;
}
else
{
Votes -= 1;
}
votesMap.Add(fromUser.UserId, vote);
}
}
public User(string loginId, string password, string userName, string email)
: this(Guid.NewGuid())
{
var userCreated = new UserCreated(loginId, password, userName, email);
RaiseEvent(userCreated);
}
private void Apply(UserCreated @event)
{
Id = @event.AggregateRootId;
Email = @event.Email;
UserName = @event.UserName;
Status = @event.Status;
}
private void OnUserCreated(UserCreated @event)
{
this.LoginId = @event.LoginId;
this.Password = @event.Password;
this.UserName = @event.UserName;
this.Email = @event.Email;
}
public void Apply(UserCreated vent)
{
Email = vent.Email;
FirstName = vent.FirstName;
LastName = vent.LastName;
Password = vent.Password;
}
public void Process(UserCreated @event)
{
var user = _users.GetById(@event.Id);
if (user == null)
{
user = new User()
{
Id = @event.Id,
Name = @event.Name,
PhoneNumber = @event.PhoneNumber,
Email = @event.Email,
Geo = @event.Geo,
RecipientType = @event.UserType
};
}
else
{
user.Id = @event.Id;
user.Name = @event.Name;
user.PhoneNumber = @event.PhoneNumber;
user.Email = @event.Email;
user.Geo = @event.Geo;
user.RecipientType = @event.UserType;
}
_users.Save(user);
}
void When(UserCreated evnt)
{
if (_userNames.ContainsKey(evnt.UserId.ToString()))
{
return;
}
_userNames[evnt.UserId.ToString()] = evnt.UserName;
}
public async Task Apply(UserCreated evnt)
{
await _store.InsertAsync(new UserView
{
Id = evnt.UserId,
Email = evnt.Email,
});
}
protected void When(UserCreated userCreated)
{
UserId = userCreated.UserId;
Salt = userCreated.Salt;
Username = userCreated.Username;
Password = userCreated.Password;
Roles = new HashSet <Role>();
}
public static void Handle(UserCreated created, IDocumentSession session)
{
session.Store(new ReceivedTrack
{
Id = created.Id,
MessageType = "UserCreated"
});
}
private void Apply(UserView view, UserCreated @event)
{
view.Id = @event.UserId;
view.Email = @event.Email;
view.FullName = $"{@event.FirstName} {@event.Surname}";
view.UserName = @event.Email;
}
public QuestionPublished(CreateQuestionCommand question, Guid questionID, UserCreated user)
{
Question = question;
QuestionID = questionID;
User = user;
Votes = 0;
votesMap = new Dictionary <Guid, bool>();
}
public void Apply(UserCreated domainEvent)
{
Id = domainEvent.Id;
State.Username = domainEvent.Username;
State.PasswordHash = domainEvent.Password;
State.Email = domainEvent.EMail;
State.Timezone = domainEvent.Timezone;
}
private void Apply(UserCreated userCreated)
{
Id = userCreated.AggregateId;
Nick = userCreated.Nick;
FirstName = userCreated.FirstName;
LastName = userCreated.LastName;
Email = userCreated.Email;
}
public static User Create(UserCreated @event)
{
return new User(
@event.UserId,
@event.UserName,
@event.Password,
@event.Email,
false);
}
static string When(UserCreated e)
{
return string.Format("Created user {0} (security {2}) with threshold {1}", e.Id.Id, e.ActivityThreshold,
e.SecurityId.Id);
}
public void When(UserCreated e)
{
SecurityId = e.SecurityId;
Id = e.Id;
}
protected virtual void Handle(UserCreated evnt)
{
_entityManager.BuildAndSave<UserEntity>(evnt);
}
public void When(UserCreated e)
{
_writer.UpdateOrThrow(e.Id, lv => { lv.LoginTrackingThreshold = e.ActivityThreshold; });
}
public void ReadASingleEvent()
{
var eventStreamId =
new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C");
using (var storage = new AtomEventsInMemory())
{
var pageSize = 25;
var serializer = DataContractContentSerializer.Scan(
typeof(UserCreated).Assembly);
var obs = new AtomEventObserver<object>(
eventStreamId,
pageSize,
storage,
serializer);
var userCreated = new UserCreated
{
UserId = eventStreamId,
UserName = "******",
Password = "******",
Email = "*****@*****.**"
};
obs.OnNext(userCreated);
IEnumerable<object> events = new FifoEvents<object>(
eventStreamId, // a Guid
storage, // an IAtomEventStorage object
serializer); // an IContentSerializer object
var firstEvent = events.First();
var uc = Assert.IsAssignableFrom<UserCreated>(firstEvent);
Assert.Equal(userCreated, uc, new SemanticComparer<UserCreated>());
}
}
