Example #1
0
        protected override async Task ActAsync()
        {
            await base.ActAsync();

            _command  = Fixture.Create <UpdateCarCommand>();
            _response = await _handler.Handle(_command, CancellationToken.None);
        }
        public async Task <ICommandResult <Car> > Handle(UpdateCarCommand command, CancellationToken cancellationToken)
        {
            int carId = command.Id;

            Car car = await _carRepository.GetAsync(carId, cancellationToken);

            if (car == null)
            {
                return(new CommandResult <Car>(CommandStatus.NotFound, null));
            }

            CarSm carSm = _carToCarSmMapper.Map(car);

            command.Patch.ApplyTo(carSm);

            CarSmValidator   validator        = new CarSmValidator();
            ValidationResult validationResult = validator.Validate(carSm);

            if (!validationResult.IsValid)
            {
                return(new CommandResult <Car>(CommandStatus.ModelInvalid, null, validationResult.Errors.Select(e => e.ErrorMessage).ToArray()));
            }

            _carSmToCarMapper.Map(carSm, car);

            await _carRepository.UpdateAsync(car, cancellationToken);

            return(new CommandResult <Car>(CommandStatus.Ok, car));
        }
Example #3
0
        public void ExecutarComandos()
        {
            var bus = new FakeBus();

            // Registro com sucesso
            var cmd = new CreateCarCommand("Fox Rock in Rio", 19000, EStatus.Ativo, Guid.NewGuid());

            Init(cmd);
            bus.SendCommand(cmd);
            End(cmd);

            //Registro com erro
            cmd = new CreateCarCommand("Fox Rock in Rio", 19000, EStatus.Ativo, Guid.NewGuid());
            Init(cmd);
            bus.SendCommand(cmd);
            End(cmd);

            //Atualizar Car
            var cmd2 = new UpdateCarCommand(Guid.NewGuid(), "Fox Rock in Rio", 19000, EStatus.Ativo);

            Init(cmd2);
            bus.SendCommand(cmd2);
            End(cmd2);

            //Deletar Car
            var cmd3 = new DeleteCarCommand(Guid.NewGuid());

            Init(cmd3);
            bus.SendCommand(cmd3);
            End(cmd3);
        }
Example #4
0
        public async Task <ApiResponse> UpdateCar(UpdateCarCommand command)
        {
            try
            {
                var response = await _mediator.Send(command);

                return(new ApiResponse(response, 201));
            }
            catch (Exception ex)
            {
                return(new ApiResponse(ex.Message, 400));
            }
        }
Example #5
0
        public async Task <IActionResult> PutCar(Guid id, UpdateCarCommand updateCommand)
        {
            var car = _carsRepo.UpdateCar(id,
                                          updateCommand.BrandId,
                                          updateCommand.ModelName,
                                          updateCommand.ChassisTypeId,
                                          updateCommand.SeatsCount,
                                          updateCommand.Url,
                                          updateCommand.UrlImage
                                          );


            // await _context.SaveChangesAsync();
            await _carsRepo.UnitOfWork.SaveChangesAsync();

            var changedCar = await _carsRepo.Get(car.Id);

            _logger.LogWarning("Изменился автомобиль {brand}, {model}", changedCar.Brand.Name, changedCar.ModelName);
            return(NoContent());
        }
Example #6
0
 public async Task UpdateCar(int id, [FromBody] UpdateCarCommand command)
 {
     command.SetId(id);
     await Mediator.Send(command);
 }
 public async Task <ActionResult <CarDto> > UpdateCar(Guid id, UpdateCarCommand command)
 {
     command.Id = id;
     return(await Mediator.Send(command));
 }
Example #8
0
 public async Task <ActionResult <CarDto> > UpdateCar(Guid id, UpdateCarCommand command, CancellationToken cancellationToken)
 {
     command.Id = id;
     return(await Sender.Send(command, cancellationToken));
 }
Example #9
0
 public async Task <IActionResult> PutAsync([FromForm] UpdateCarCommand command)
 {
     return(Ok(await Mediator.Send(command)));
 }
Example #10
0
        public async Task <IActionResult> Update(UpdateCarCommand updateCarCommand)
        {
            var rs = await _mediator.Send(updateCarCommand);

            return(rs != null?Ok(rs) : NotFound());
        }