Example #1
0
        public async Task <IActionResult> PutAsync(PersonUpdateDto p)
        {
            var command = new PersonUpdateCommand
            {
                Person = p
            };

            var status = await _mediator.Send(command);

            return(Ok(status));
        }
        public void Execute_Person_True()
        {
            var mockPersonRepo = new Mock <IPersonRepository>();

            mockPersonRepo.Setup(x => x.GetById(It.IsAny <int>())).Returns(new Person());
            var command = new PersonUpdateCommand(mockPersonRepo.Object);
            var actual  = command.Execute(new Person());

            mockPersonRepo.Verify(x => x.GetById(It.IsAny <int>()), Times.Once);
            Assert.IsTrue(actual);
        }
Example #3
0
        public IResponseCommand Handle(PersonUpdateCommand command)
        {
            Person entity = _repository.SearchById(command.Id);

            entity.SetIsActive(command.Active);
            _repository.Update(entity);

            return(new GenericResponseCommand(true,
                                              $"Id: {entity.Id} Status: {entity.IsActive}",
                                              null));
        }
        public Person Take(PersonUpdateCommand command)
        {
            this.CopyPropertiesFrom(command);

            base.AddEvent(new PersonUpdatedDomainEvent
            {
                AggregateRootId = Id,
                CommandJson     = JsonConvert.SerializeObject(command),
                UserId          = command.UserId
            });

            return(this);
        }
Example #5
0
 public async Task <IActionResult> UpdateAsync(PersonUpdateDto obj)
 {
     if (obj != null)
     {
         var command = new PersonUpdateCommand
         {
             Person = obj
         };
         Log.Information("Update realizado com sucesso.");
         await _mediator.Send(command);
     }
     Log.Error("Erro: sem objecto");
     return(NoContent());
 }
        public async Task <ICommandHandlerAggregateAnswer> HandleAsync(PersonUpdateCommand command)
        {
            var answer = new CommandHandlerAggregateAnswer();
            var person = await personRepository.Query(command.Id);

            if (person.IsNotNull())
            {
                answer.ValidationResult = this.updateValidationHandler.Validate(command);

                if (command.IsValid)
                {
                    answer.AggregateRoot = await personRepository.Update(person.Take(command));
                }
            }
            return(answer);
        }
Example #7
0
        public void Handle(PersonUpdateCommand command)
        {
            var data = _uow.PeopleRepo.Find(command.Id);

            if (data != null)
            {
                data.FirstName   = command.FirstName;
                data.LastName    = command.LastName;
                data.DateOfBirth = command.DateOfBirth;
                data.Address     = command.Address;
                data.BeltId      = command.BeltId;
                data.Stripes     = command.Stripes;

                _uow.PeopleRepo.Update(data);
                data.RaiseDomainEvent(new PersonUpdatedEvent(data.PersonRefId, command.FirstName, command.LastName, command.DateOfBirth, command.Address, command.BeltId, command.Stripes));
                _uow.Save();
            }
        }
Example #8
0
 public void UpdatePerson(PersonUpdateCommand data)
 {
     _messages.Dispatch(data);
 }
Example #9
0
 public IActionResult Put([FromBody] PersonUpdateCommand command)
 {
     return(Ok(_handlerUpdate.Handle(command)));
 }