Exemple #1
0
        public IActionResult Post([FromBody] CreateCustomerCommand command)
        {
            var result = _handler.Handle(command);

            if (!result.IsValid)
            {
                return(BadRequest(result));
            }

            return(Ok(result));
        }
Exemple #2
0
 public ICommandResult Post(RegisterCustomerCommand command)
 {
     //fail fast validation
     AssertionConcern.AssertArgumentNotEmpty(command.FirstName, "O Primeiro nome não pode ser nulo.");
     AssertionConcern.AssertArgumentNotEmpty(command.Email, "O email nome não pode ser nulo.");
     return(_handler.Handle(command));
 }
        public async Task <ICommandResult> AddCustomerAsync(AddCustomerDto addCustomerDto)
        {
            var user = new ApplicationUser {
                UserName = addCustomerDto.Email, Email = addCustomerDto.Email
            };

            var result = await _userManager.CreateAsync(user, addCustomerDto.Password);

            if (result.Succeeded)
            {
                var createCustomerCommand = Mapper.Map <CreateCustomerCommand>(addCustomerDto);
                var commandResult         = _customerCommandHandler.Handle(createCustomerCommand);

                if (commandResult.Success)
                {
                    var customer = (Customer)commandResult.Data;
                    user.CustomerId = customer.Id;
                    await _userManager.UpdateAsync(user);
                }

                return(commandResult);
            }

            return(new CommandResult(false, result.Errors.Select(e => e.Description)));
        }
        public void ShouldNotCreatePaymentMethod_When_CommandIsInvalid()
        {
            var command = new CreatePaymentMethodCommand("", "", "", Guid.NewGuid());
            var handler = new CustomerCommandHandler(new CustomerRepositoryMock(), null);

            var result = handler.Handle(command);

            Assert.False(result.IsValid);
        }
        public void ShouldCreatePaymentMethod_When_CommandIsValid()
        {
            var command = new CreatePaymentMethodCommand("James B", "1234 1234 1234 1234", "1234", Guid.NewGuid());
            var handler = new CustomerCommandHandler(new CustomerRepositoryMock(), null);

            var result = handler.Handle(command);

            Assert.True(result.IsValid);
        }
        public void ShouldCreateCustomer_When_CommandIsValid()
        {
            var command = new CreateCustomerCommand("James Bond", "*****@*****.**", "+44 1111 1111");
            var handler = new CustomerCommandHandler(new CustomerRepositoryMock(), null);

            var result = handler.Handle(command);

            Assert.True(result.IsValid);
        }
        public async Task <IActionResult> Post([FromBody] RegisterCustomerCommand command)
        {
            var result = _handler.Handle(command);

            if (!_handler.IsValid())
            {
                return(BadRequest(new { success = false, errors = _handler.Notifications }));
            }

            return(Ok(result));
        }
Exemple #8
0
        public IActionResult Post([FromBody] RegisterCustomerCommand command)
        {
            var result = _commandHandler.Handle(command);

            if (_commandHandler.IsValid())
            {
                return(Ok(result));
            }

            else
            {
                return(BadRequest(_commandHandler.Notifications));
            }
        }
        public void CustomerHandlerTests_CreateCustomer_Should_Create_Successfully()
        {
            var command = new CreateCustomerCommand();

            command.Nome      = "Ray";
            command.Sobrenome = "Carneiro";
            command.Documento = "72092578022";
            command.Email     = "*****@*****.**";
            command.Telefone  = "";

            var handler = new CustomerCommandHandler(new FakeCustomerRepositoryTests());
            var result  = handler.Handle(command);

            Assert.AreNotEqual(null, result);
        }
        public void ShouldRegisterCustomerWhenCommandIsValid()
        {
            var command = new RegisterCustomerCommand()
            {
                FirstName = "Alipio",
                LastName  = "Ferro",
                Document  = "53702077049",
                Email     = "*****@*****.**"
            };


            var handler = new CustomerCommandHandler(new FakeCustomerRepository());
            var result  = handler.Handle(command);

            Assert.AreNotEqual(null, result);
        }
Exemple #11
0
        public async Task <IActionResult> Post([FromBody] RegisterCustomerCommand command)
        {
            /* Post válido
             * {
             *      "FirstName": "Vagner",
             *      "LastName": "Alcantara",
             *      "Email": "*****@*****.**",
             *      "Document": "55373466050",
             *      "Username": "******",
             *      "Password": "******",
             *      "ConfirmPassword": "******"
             * }
             */
            var result = _handler.Handle(command);

            return(await Response(result, _handler.Notifications));
        }
 public async Task <IActionResult> Post([FromBody] RegisterCustomerCommand command) =>
 await Response(_handler.Handle(command), _handler.Notifications);
Exemple #13
0
        public async Task <IActionResult> Post([FromBody] RegisterCustomerCommand command)
        {
            var result = _handler.Handle(command);

            return(await Response(result, _handler.Notifications));
        }
 public IActionResult Post([FromBody] CreateCustomerCommand command) //thin controller
 {
     return(StatusCode(201, _commandHandler.Handle(command)));
 }