public async Task <Vehicle> Build(CreateVehicleCommand command)
        {
            Vehicle vehicle;

            try
            {
                VehicleTypes type;
                VehicleBody  body;

                Enum.TryParse <VehicleTypes>(command.Vehicle, out type);
                body = await _bodyHandler.Build(command.Body);

                switch (type)
                {
                case VehicleTypes.BMW:
                    vehicle = new BMW(command.Id, body, command.Color);
                    break;

                case VehicleTypes.Ford:
                    vehicle = new Ford(command.Id, body, command.Color);
                    break;

                default:
                    vehicle = null;
                    break;
                }
            }
            catch (Exception exception)
            {
                return(null);
            }

            return(vehicle);
        }
예제 #2
0
        public async Task <IActionResult> CreateVehicle([FromBody] CreateVehicleCommand command)
        {
            if (command.Validate())
            {
                Vehicle vehicle = await _vehicleManufactureService.Build(command);

                if (vehicle == null)
                {
                    return(BadRequest());
                }

                await _vehicleManufactureService.QualityTestRun(vehicle);

                VehicleReleaseResponse response = new VehicleReleaseResponse
                {
                    Release = await _vehicleManufactureService.Release(vehicle)
                };

                return(new ContentResult
                {
                    Content = JsonConvert.SerializeObject(response),
                    StatusCode = 200,
                    ContentType = "json/application"
                });
            }

            return(BadRequest());
        }
예제 #3
0
        public async Task <IActionResult> CreateVehicle(CreateVehicleCommand request)
        {
            try
            {
                var result = await Mediator.Send(request);

                return(Ok(result));
            }
            catch (VehicleExistsException)
            {
                return(BadRequest($"The vehicle with Matrícula '{request.Matricula}' already exists."));
            }
            catch (DriverNotExistsException)
            {
                return(BadRequest($"The driver with DNI '{request.Dni}' does not exists."));
            }
            catch (VehiclesLimitException)
            {
                return(BadRequest($"The driver with DNI '{request.Dni}' cannot have more vehicles"));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                return(StatusCode(StatusCodes.Status500InternalServerError));
            }
        }
        public async Task <IActionResult> Create([FromBody] CreateVehicleCommand createVehicleCommand)
        {
            logger.LogInformation("start : ");
            var vehicle = await Mediator.Send(createVehicleCommand);

            logger.LogInformation("added " + vehicle.VehicleId);
            return(CreatedAtAction(nameof(Get), new { id = vehicle.VehicleId }, null));
        }
        public void Execute_ShouldCreateNewVehicle_WhenPassedCorrectCommand()
        {
            var executionResult = new CreateVehicleCommand().Execute(new List <string>()
            {
                "4", "2"
            });

            Assert.AreEqual(1, Engine.Vehicles.Count());
        }
        public void Execute_ShouldCreateTheCorrectNumberOfTyres_WhenPassedCommand()
        {
            var executionResult = new CreateVehicleCommand().Execute(new List <string>()
            {
                "4", "2"
            });

            Assert.AreEqual(4, Engine.Vehicles[1].Tyres.Count());
        }
예제 #7
0
        public async Task <ActionResult <VehicleViewModel> > CreateVehicle([FromBody] CreateVehicleCommand command)
        {
            var newId = await _Mediator.Send(command);

            var newVehicle = await _Mediator.Send(new GetVehicleQuery()
            {
                Id = newId
            });

            return(StatusCode(201, newVehicle));
        }
예제 #8
0
        public async Task <IActionResult> Post([FromBody] CreateVehicleViewModel viewModel)
        {
            if (!viewModel.Validate())
            {
                return(await ResponseBase(viewModel.Notifications));
            }

            var command = new CreateVehicleCommand(viewModel.Chassis, viewModel.Color, viewModel.Type);
            var result  = await mediator.SendCommandAsync(command);

            return(await ResponseBase(result));
        }
예제 #9
0
        public async Task TestVehicleManufactureService_GivenWith_Vehicle_ShouldReturn_BMW()
        {
            CreateVehicleCommand createVehicleCommand = new CreateVehicleCommand()
            {
                Id      = Guid.NewGuid(),
                Vehicle = "BMW",
                Body    = "Normal",
                Color   = "Blue"
            };

            Vehicle vehicle = await _sut.Build(createVehicleCommand);

            Assert.True(vehicle.GetType() == typeof(BMW));
        }
예제 #10
0
        public async Task TestVehicleManufactureService_GivenWith_Vehicle_AND_QualityTestRun_ShouldBe_QualityApproved()
        {
            CreateVehicleCommand createVehicleCommand = new CreateVehicleCommand()
            {
                Id      = Guid.NewGuid(),
                Vehicle = "BMW",
                Body    = "Normal",
                Color   = "Blue"
            };

            Vehicle vehicle = await _sut.Build(createVehicleCommand);

            await _sut.QualityTestRun(vehicle);

            Assert.True(vehicle.IsQualityApproved());
        }
예제 #11
0
        public async Task TestVehicleControllerShouldWork()
        {
            CreateVehicleCommand createVehicleCommand = new CreateVehicleCommand()
            {
                Id      = Guid.NewGuid(),
                Vehicle = "Ford",
                Body    = "Normal",
                Color   = "Blue"
            };

            _service.Setup(x => x.Build(createVehicleCommand));

            await _controller.CreateVehicle(createVehicleCommand);

            _service.Verify(x => x.Build(It.Is <CreateVehicleCommand>(command => command.Id == createVehicleCommand.Id)));
        }
예제 #12
0
        public Task <HttpResponseMessage> Post(CreateVehicleCommand vehicle)
        {
            HttpResponseMessage response = new HttpResponseMessage();

            try
            {
                _service.Create(vehicle);
                response = Request.CreateResponse(HttpStatusCode.OK, new { name = vehicle.Model });
            }
            catch (Exception ex)
            {
                response = Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message);
            }

            var tsc = new TaskCompletionSource <HttpResponseMessage>();

            tsc.SetResult(response);
            return(tsc.Task);
        }
예제 #13
0
        public async Task <IActionResult> CreateVehicle([FromBody] VehicleDTO vehicleDTO)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var createVehicleCommand = new CreateVehicleCommand(vehicleDTO);

            logger.Information($"Sending CreateVehicleCommand with parameters {vehicleDTO.ManufacturerName} {vehicleDTO.Model} {vehicleDTO.Generation}");
            var createdVehicleId = await mediator.Send(createVehicleCommand);

            if (createdVehicleId.HasNoValue)
            {
                return(BadRequest($"Cannot create vehicle"));
            }

            return(Created("", createdVehicleId.Value));
        }
예제 #14
0
        public async Task TestVehicleManufactureService_GivenWith_Vehicle_ShouldReturn_ReleasedDetails()
        {
            CreateVehicleCommand createVehicleCommand = new CreateVehicleCommand()
            {
                Id      = Guid.NewGuid(),
                Vehicle = "BMW",
                Body    = "Normal",
                Color   = "Blue"
            };

            Vehicle vehicle = await _sut.Build(createVehicleCommand);

            await _sut.QualityTestRun(vehicle);

            string result = await _sut.Release(vehicle);

            Assert.False(result == "No Release date yet.");
            Assert.Contains("year", result);
        }
예제 #15
0
        public async Task <IHttpActionResult> Post(Guid ownerId, CreateVehicleCommand vehicle)
        {
            var owner = await _context.Owners.FindAsync(ownerId);

            if (owner == null)
            {
                return(NotFound());
            }

            var entity = Mapper.Map <Vehicle>(vehicle);

            entity.Id      = Guid.NewGuid();
            entity.OwnerId = owner.Id;

            _context.Vehicles.Add(entity);
            await _context.SaveChangesAsync();

            return(CreatedAtRoute("Vehicles.GetById", new { id = entity.Id }, Mapper.Map <VehicleViewModel>(entity)));
        }
예제 #16
0
        //public BaseResponse Create(CreateVehicleRequest vehicleRequest)
        //{
        //    CreateVehicleCommand vehicleCommand = new CreateVehicleCommand
        //    {
        //        Volume = vehicleRequest.Volume,
        //        Capacity = vehicleRequest.Capacity,
        //        Image = vehicleRequest.Image,
        //        LicensePlate = vehicleRequest.LicensePlate,
        //        TypeVehicle = vehicleRequest.TypeVehicle
        //    };
        //    var result = _bus.SendCommand(vehicleCommand);
        //    Task<object> status = result as Task<object>;
        //    var isComplete = (bool)status.Result;
        //    if (isComplete)
        //    {
        //        return new BaseResponse(ResponseCode.OK.ToString(), code: ResponseCode.OK);
        //    }
        //    return new BaseResponse(ResponseCode.Fail.ToString(), code: ResponseCode.Fail);

        //    //if (_notifications.HasNotifications())
        //    //{

        //    //    Console.Write("ae oi");

        //    //    if(_notifications.GetNotifications().Any(x=>x.TypeNotification == TypeNotification.Success))
        //    //    {
        //    //        response.Code = (int)ResponseCode.OK;
        //    //        var message = _notifications.GetNotifications().FirstOrDefault().Value ?? "";
        //    //        response.Message = message as string;
        //    //    }
        //    //    if (_notifications.GetNotifications().Any(x => x.TypeNotification == TypeNotification.Fail))
        //    //    {
        //    //        response.Code = (int)ResponseCode.Fail;
        //    //        var message = _notifications.GetNotifications().FirstOrDefault().Value ?? "";
        //    //        response.Message = message as string;
        //    //    }

        //    //}

        //}

        public Task <StatusResponse> Create(CreateVehicleRequests vehicleRequest)
        {
            try
            {
                var existCode = _vehicleService.checkExist(vehicleRequest.Code);
                if (existCode)
                {
                    return(Task.FromResult(new StatusResponse
                    {
                        OK = false,
                        Content = "Trùng code"
                    }));
                }

                CreateVehicleCommand vehicleCommand = new CreateVehicleCommand
                {
                    LicensePlate = vehicleRequest.LicensePlate,
                    Code         = vehicleRequest.Code,
                    MaxLoad      = vehicleRequest.MaxLoad,
                    Name         = vehicleRequest.Name,
                    Note         = vehicleRequest.Note,
                    TypeID       = vehicleRequest.TypeID,
                    DriverID     = vehicleRequest.DriverID
                };
                var           result = _bus.SendCommand(vehicleCommand);
                Task <object> status = result as Task <object>;
                var           id     = (VehicleModel)status.Result;
                return(Task.FromResult(new StatusResponse
                {
                    OK = true,
                    Content = id.Id.ToString()
                }));
            }
            catch (Exception ex)
            {
                return(Task.FromResult(new StatusResponse
                {
                    OK = false,
                    Content = ex.Message
                }));
            }
        }
예제 #17
0
        static void Main(string[] args)
        {
            IVehicleStorage storage = JsonStorage.LoadFromFile("/home/joernneumeyer/vehicles");
            CarDealer       dealer  = new CarDealer(storage);
            IMenuCommand    cmd;

            Vehicle v = new Car();

            v.Price        = 200;
            v.Vendor       = "Skoda";
            v.LicensePlate = "ABC";
            dealer.AddVehicle(v);

            v              = new Truck();
            v.Price        = 300;
            v.Vendor       = "MAN";
            v.LicensePlate = "YTG";
            dealer.AddVehicle(v);

            bool repeat = true;

            do
            {
                Console.WriteLine("Please select an option:");
                Console.WriteLine("q: Quit");
                Console.WriteLine("1: Add a new vehicle");
                Console.WriteLine("2: List all available vehicles");
                Console.WriteLine("3: Show number of available vehicles");
                Console.WriteLine("4: Show total value of all vehicles");
                // Console.WriteLine("5: Show price of vehicle by id");
                Console.WriteLine("6: Increase all prices by percentage");
                Console.WriteLine("7: Search for vehicle in price range");

                string choice = Console.ReadLine();

                switch (choice)
                {
                case "1":
                    cmd = new CreateVehicleCommand();
                    break;

                case "2":
                    cmd = new PrintVehiclesCommand();
                    break;

                case "3":
                    cmd = new ShowNumberOfAllVehicles();
                    break;

                case "4":
                    cmd = new ShowTotalValueOfAllVehicles();
                    break;

                case "6":
                    cmd = new IncreasePricesCommand();
                    break;

                case "7":
                    cmd = new SearchVehicleInPriceRangeCommand();
                    break;

                case "q":
                    cmd    = null;
                    repeat = false;
                    break;

                default:
                    cmd = null;
                    break;
                }

                if (cmd != null)
                {
                    cmd.Execute(dealer);
                    Console.Write("\r\n\r\nPress enter...");
                    Console.ReadLine();
                    Console.Clear();
                }
            } while (repeat);
        }
예제 #18
0
        public async Task <IActionResult> CreateVehicle([FromBody] CreateVehicleCommand input)
        {
            var isCreated = await _mediator.Send(input);

            return(Ok(isCreated));
        }