public void WhenICreateAnEventItIsCreated()
        {
            var expectedEventId           = Guid.NewGuid();
            var expectedContextId         = Guid.NewGuid();
            var expectedEventData         = Guid.NewGuid().ToString();
            var expectedEventType         = Substitute.For <IEventType>();
            var expectedEventDateTime     = DateTime.Now;
            var expectedEffectiveDateTime = DateTime.Now.AddDays(-2);
            var eventData = Substitute.For <IEventData>();

            _guidProvider.Create().Returns(expectedEventId);
            _dateTimeProvider.GetUtc().Returns(expectedEventDateTime);
            _eventDataSerializationService.Serialize(eventData).Returns(expectedEventData);
            _eventTypeService.Get <IEventData>().Returns(expectedEventType);

            var result = _target.Create(expectedContextId, eventData, expectedEffectiveDateTime);

            Assert.Equal(expectedEventId, result.EventId);
            Assert.Equal(expectedContextId, result.ContextId);
            Assert.Equal(expectedEventDateTime, result.CreatedDateTime);
            Assert.Equal(expectedEffectiveDateTime, result.EffectiveDateTime);
            Assert.Same(expectedEventType, result.EventType);
            Assert.Equal(expectedEventData, result.EventData);
            Assert.False(result.Undone);
        }
Exemple #2
0
        public void CreateEvent_CallEventFactory(
            [Frozen] IEventFactory eventFactory,
            CreateEventCommand message,
            Event @event,
            CreateEventCommandHandler createEventCommandHandler)
        {
            //Information
            A.CallTo(() => eventFactory.Create(message.Event)).Returns(@event);

            //Act
            createEventCommandHandler.ExecuteAsync(message);

            //Test
            A.CallTo(() => eventFactory.Create(message.Event)).MustHaveHappened();
        }
Exemple #3
0
        protected void Apply <TEvent>(Action <TEvent> action)
        {
            var @event = _eventFactory.Create(action);

            Raise(@event);

            _events.Add(@event);
        }
Exemple #4
0
        public Event Adapt(EventDataModel dataModel)
        {
            var eventRegistrations = dataModel.Registrations.Select(
                f => _eventRegistrationFactory.Create(f.IndividualId, f.EmailId, f.Id))
                                     .ToList();

            return(_eventFactory.Create(dataModel.EventName, eventRegistrations, dataModel.Id));
        }
Exemple #5
0
        public IEnumerable <IEvent> Execute(Guid contextId, SetNameCommand command)
        {
            var setNameEventData = new SetNameEventData {
                Name = command.Name
            };
            var @event = _eventFactory.Create(contextId, setNameEventData);

            return(new[] { @event });
        }
        public IEnumerable <IEvent> Execute(Guid contextId, SetDateOfBirth2Command command)
        {
            var setNameEventData = new SetDateOfBirthEventDataV2 {
                DateOfBirth = command.DateOfBirth, HourOfBirth = 10
            };
            var @event = _eventFactory.Create(contextId, setNameEventData);

            return(new[] { @event });
        }
        public Task ExecuteAsync(CreateEventCommand message)
        {
            var @event = _eventFactory.Create(message.Event);

            _eventRepository.Add(@event);

            _createRouteCommandHandler.ExecuteAsync(new CreateRouteCommand(message.Route));
            return(Task.CompletedTask);
        }
Exemple #8
0
        public override async Task <ModelEvent> MapToModel(SnapshotEvent snapshotEvent, SnapshotContext snapshotContext)
        {
            var modelEvent = _eventFactory.Create(snapshotEvent.Template);

            MapSnapshotPropertiesToModel(snapshotEvent, modelEvent);
            await UpdateParametersFromSnapshot(snapshotEvent, modelEvent, snapshotContext, snapshotEvent.Template);

            return(modelEvent);
        }
Exemple #9
0
 public IEnumerable <IEvent> Execute(Guid contextId, AddPremiumCommand command)
 {
     yield return(_eventFactory.Create(contextId,
                                       new AddPremiumData(
                                           command.PremiumId,
                                           command.PremiumSpread.ToDictionary(
                                               t => t.Key,
                                               t => new AddPremiumData.PremiumSpreadData {
         Id = t.Value.Id, Amount = t.Value.Amount
     }))));
 }
Exemple #10
0
        public void WhenTheHandlerExecutes(IEventFactory eventFactory, ApplyUnitAllocationCommand applyUnitAllocationCommand)
        {
            var expectedEvent = Substitute.For <IEvent>();
            var target        = new ApplyUnitAllocationHandler(eventFactory);
            var contextId     = Guid.NewGuid();

            eventFactory.Create(contextId, Arg.Is <UnitsAllocatedData>(data =>
                                                                       data.FundId == applyUnitAllocationCommand.FundId &&
                                                                       data.OfferPrice == applyUnitAllocationCommand.OfferPrice)).Returns(expectedEvent);

            var result = target.Execute(contextId, applyUnitAllocationCommand);

            Assert.Contains(expectedEvent, result);
        }
        public void WhenTheHandlerExecutes(IEventFactory eventFactory, PremiumReceivedCommand createNewPolicyCommand)
        {
            var expectedEvent = Substitute.For <IEvent>();
            var target        = new PremiumReceivedHandler(eventFactory);
            var contextId     = Guid.NewGuid();

            eventFactory.Create(contextId, Arg.Is <PremiumReceivedData>(data =>
                                                                        data.PremiumId == createNewPolicyCommand.PremiumId &&
                                                                        data.DateTimeReceived == createNewPolicyCommand.DateTimeReceived)).Returns(expectedEvent);

            var result = target.Execute(contextId, createNewPolicyCommand);

            Assert.Contains(expectedEvent, result);
        }
Exemple #12
0
        public void WhenTheHandlerExecutes(IEventFactory eventFactory, CreateNewPolicyCommand createNewPolicyCommand)
        {
            var expectedEvent = Substitute.For <IEvent>();
            var target        = new CreateNewPolicyHandler(eventFactory);
            var contextId     = Guid.NewGuid();

            eventFactory.Create(contextId, Arg.Is <PolicyCreationData>(data =>
                                                                       data.CustomerId == createNewPolicyCommand.CustomerId &&
                                                                       data.PolicyNumber == createNewPolicyCommand.PolicyNumber)).Returns(expectedEvent);

            var result = target.Execute(contextId, createNewPolicyCommand);

            Assert.Contains(expectedEvent, result);
        }
        public void WhenTheHandlerExecutes(IEventFactory eventFactory, AddPremiumCommand addPremiumCommand)
        {
            var expectedEvent = Substitute.For <IEvent>();
            var target        = new AddPremiumCommandHandler(eventFactory);
            var contextId     = Guid.NewGuid();

            eventFactory.Create(contextId, Arg.Is <AddPremiumData>(data =>
                                                                   data.PremiumId == addPremiumCommand.PremiumId &&
                                                                   ExceptionHelpers.ExecuteSuccessfully(() => ValidateAddPremium(addPremiumCommand, data)))).Returns(expectedEvent);

            var result = target.Execute(contextId, addPremiumCommand);

            Assert.Contains(expectedEvent, result);
        }
Exemple #14
0
        public void WhenTheHandlerExecutes(IEventFactory eventFactory, ApplyManagementChargeCommand applyManagementChargeCommand)
        {
            var expectedEvent = Substitute.For <IEvent>();
            var target        = new ApplyManagementChargeHandler(eventFactory);
            var contextId     = Guid.NewGuid();

            eventFactory.Create(contextId, Arg.Is <ManagementChargeAppliedData>(data =>
                                                                                data.FundId == applyManagementChargeCommand.FundId &&
                                                                                data.ChargeFactor == applyManagementChargeCommand.ChargeFactor)).Returns(expectedEvent);

            var result = target.Execute(contextId, applyManagementChargeCommand);

            Assert.Contains(expectedEvent, result);
        }
Exemple #15
0
        protected override JsonObjectContract CreateObjectContract(Type objectType)
        {
            if (objectType.IsInterface)
            {
                var mappedType     = _eventMapper.GetMappedTypeFor(objectType);
                var objectContract = base.CreateObjectContract(mappedType);

                objectContract.DefaultCreator = () => _eventFactory.Create(mappedType);

                return(objectContract);
            }

            return(base.CreateObjectContract(objectType));
        }
        protected override JsonObjectContract CreateObjectContract(Type objectType)
        {
            var mappedType = _eventMapper.GetMappedTypeFor(objectType);

            if (mappedType == null)
            {
                return(base.CreateObjectContract(objectType));
            }

            var jsonObjectContract = base.CreateObjectContract(mappedType);

            jsonObjectContract.DefaultCreator = () => _eventFactory.Create(mappedType);

            return(jsonObjectContract);
        }
Exemple #17
0
        public List <Event> Mapper(DbDataReader source)
        {
            var events = new List <Event>();

            while (source.Read())
            {
                var id          = source.GetGuid(0);
                var version     = source.GetInt16(1);
                var timeStamp   = source.GetInt64(2);
                var contentType = source.GetString(4);
                var json        = source.GetString(3);
                var @event      = _eventFactory.Create(id, version, timeStamp, json, contentType);
                events.Add(@event);
            }
            return(events);
        }
        public async Task <IActionResult> SaveEventAsync([FromBody] EventDto dto)
        {
            var eventRegistrations = dto.Registrations?.Select(
                f => _eventRegistrationFactory.Create(f.IndividualId, f.EmailId, f.Id))
                                     .ToList();

            var newEvent = _eventFactory.Create(
                dto.EventName,
                eventRegistrations);

            var returnedEvent = await _eventRepository.SaveAsync(newEvent);

            var result = _mapper.Map <EventDto>(returnedEvent);

            return(Ok(result));
        }
Exemple #19
0
        public void WhenTheHandlerExecutes(IEventFactory eventFactory, AdjustFundInstanceUnitsCommand adjustFundInstanceUnitsCommand)
        {
            var expectedEvent = Substitute.For <IEvent>();
            var target        = new AdjustFundInstanceUnitsHandler(eventFactory);
            var contextId     = Guid.NewGuid();

            eventFactory.Create(contextId, Arg.Is <FundInstanceUnitAdjustmentData>(data =>
                                                                                   data.FundId == adjustFundInstanceUnitsCommand.FundId &&
                                                                                   data.InstanceId == adjustFundInstanceUnitsCommand.FundInstanceId &&
                                                                                   data.UnitAdjustment == adjustFundInstanceUnitsCommand.UnitAdjustment &&
                                                                                   data.Reason == adjustFundInstanceUnitsCommand.Reason)).Returns(expectedEvent);

            var result = target.Execute(contextId, adjustFundInstanceUnitsCommand);

            Assert.Contains(expectedEvent, result);
        }
Exemple #20
0
        protected override JsonObjectContract CreateObjectContract(Type objectType)
        {
            var mappedTypeFor = objectType;

            _mapper.Initialize(objectType);
            mappedTypeFor = _mapper.GetMappedTypeFor(objectType);

            if (mappedTypeFor == null)
            {
                return(base.CreateObjectContract(objectType));
            }

            var objectContract = base.CreateObjectContract(objectType);

            objectContract.DefaultCreator = () => _factory.Create(objectType);

            return(objectContract);
        }
Exemple #21
0
        public void CreateEvent_SendICommandHandlerWithCreateRouteCommand(
            [Frozen] ICommandHandler <CreateRouteCommand> createRouteCommandHandler,
            [Frozen] IEventRepository eventRepository,
            [Frozen] IEventFactory eventFactory,
            CreateEventCommand message,
            Event @event,
            CreateEventCommandHandler createEventCommandHandler)
        {
            //Information
            A.CallTo(() => eventFactory.Create(message.Event)).Returns(@event);
            A.CallTo(() => eventRepository.Add(@event));

            //Act
            createEventCommandHandler.ExecuteAsync(message);

            //Test
            A.CallTo(() => createRouteCommandHandler.ExecuteAsync(A <CreateRouteCommand> .Ignored))
            .MustHaveHappened();
        }
Exemple #22
0
 private void templateChanged(TemplateChangedEventArgs e)
 {
     _macroCommand.Clear();
     Event = _eventFactory.Create(e.Template);
     eventSettingsPresenter.EditEvent(Event);
 }
Exemple #23
0
        public Task <TResponse> Query <TQuery, TResponse>(Action <TQuery> query, IContainer container) where TQuery : IQuery <TResponse>
        {
            var result = _eventFactory.Create(query);

            return(Query <TQuery, TResponse>(result, container));
        }
 public IEnumerable <IEvent> Execute(Guid contextId, PremiumReceivedCommand command)
 {
     yield return(_eventFactory.Create(contextId, new PremiumReceivedData(
                                           command.PremiumId, command.DateTimeReceived)));
 }
 public IEnumerable <IEvent> Execute(Guid contextId, ApplyManagementChargeCommand command)
 {
     yield return(_eventFactory.Create(contextId, new ManagementChargeAppliedData(
                                           command.FundId, command.ChargeFactor)));
 }
Exemple #26
0
 public IEnumerable <IEvent> Execute(Guid contextId, AdjustFundInstanceUnitsCommand command)
 {
     yield return(_eventFactory.Create(contextId,
                                       new FundInstanceUnitAdjustmentData(command.FundId, command.FundInstanceId, command.UnitAdjustment, command.Reason)));
 }
Exemple #27
0
 public IEnumerable <IEvent> Execute(Guid contextId, CreateNewPolicyCommand command)
 {
     yield return(_eventFactory.Create(contextId,
                                       new PolicyCreationData(command.CustomerId, command.PolicyNumber)));
 }
Exemple #28
0
 public IEnumerable <IEvent> Execute(Guid contextId, ApplyUnitAllocationCommand command)
 {
     yield return(_eventFactory.Create(contextId, new UnitsAllocatedData(
                                           command.FundId, command.OfferPrice)));
 }
Exemple #29
0
 protected void Apply <TEvent>(Action <TEvent> action)
 {
     _events.Add(_eventFactory.Create(action));
 }
Exemple #30
0
 private bool TryGetEvent(byte[] data, out IEvent evnt)
 {
     evnt = _eventFactory.Create(data);
     return(null != evnt);
 }