public async Task <Unit> Handle(Command request, CancellationToken cancellationToken) { if (request.obj == null) { throw new StatusCodeException(HttpStatusCode.BadRequest, "object is empty"); } VehicleDto CarObj = JsonConvert.DeserializeObject <VehicleDto>(JObject.Parse(request.obj).ToString()); CarVehicleDtoValidation validator = new CarVehicleDtoValidation(); ValidationResult results = validator.Validate(CarObj); if (!results.IsValid) { validator.ValidateAndThrow(CarObj); } var obj = uow.Mapper.Map <Vehicle>(CarObj); var accessToken = uow.httpContextAccessor.HttpContext.User.Identity.Name; Guid id; if (!Guid.TryParse(accessToken, out id)) { throw new StatusCodeException(HttpStatusCode.Unauthorized, "guid has bad structure"); } obj.UserId = id; if (request.Image == null) { throw new StatusCodeException(HttpStatusCode.BadRequest, "Image is empty"); } if (!Directory.Exists(Directory.GetCurrentDirectory() + @"\Images\" + obj.Id)) { Directory.CreateDirectory(Directory.GetCurrentDirectory() + @"\Images\" + obj.Id); } foreach (var image in request.Image) { if (image.Length > 0) { string fileName = Guid.NewGuid() + image.FileName; using (var fileStream = new FileStream(Directory.GetCurrentDirectory() + @"\Images\" + obj.Id + @"\" + fileName, FileMode.Create)) { image.CopyTo(fileStream); var path = new Image() { Path = Directory.GetCurrentDirectory() + "\\Images\\" + obj.Id + "\\" + fileName }; //path.Path.Replace(@"\\", @"\"); obj.Image.Add(path); } } } obj.BikeDetails = null; obj.CarDetails.VehicleId = obj.Id; await uow.CarRepository.Insert(obj); uow.Commit(); return(Unit.Value); }
public IActionResult Advertise(VehicleDto dto) { var existingVehicle = db.FindVehicle(dto.Registration); if (existingVehicle != default) { ModelState.AddModelError(nameof(dto.Registration), "That registration is already listed in our database."); } var vehicleModel = db.FindModel(dto.ModelCode); if (vehicleModel == default) { ModelState.AddModelError(nameof(dto.ModelCode), $"Sorry, {dto.ModelCode} is not a valid model code."); } if (!ModelState.IsValid) { return(View(dto)); } var vehicle = new Vehicle() { Registration = dto.Registration, Color = dto.Color, VehicleModel = vehicleModel, Year = dto.Year }; db.CreateVehicle(vehicle); return(RedirectToAction("Details", new { id = vehicle.Registration })); }
public ResponseDetailsBase PushMessageToQueue(VehicleDto vehicle) { using (var channel = _messaginQueueHandler.CreateConnection()) { _logger.LogInformation("Push Message To Service Bus is starting"); if (vehicle == null || string.IsNullOrEmpty(vehicle.VehicleId)) { _logger.LogInformation("Cannot Retrieve Random Vehicle"); return(new ResponseDetailsBase(ResponseStatusCode.InvalidInputs)); } var pingComm = new PingVehicleModel() { Id = Guid.NewGuid(), CreatedAt = DateTime.UtcNow, VehicleId = vehicle.VehicleId }; var pushMessageResponse = _messaginQueueHandler.PushMessage(pingComm, channel); if (pushMessageResponse.StatusCode != ResponseStatusCode.Success) { _logger.LogInformation("Failed To Update Vehicle Status"); } _logger.LogInformation("Vehicle Status Updated Successfully"); return(pushMessageResponse); } }
public ActionResult Create(VehicleDto vehicleModel) { // Business logic to check vehicle inspection if (!iVehicleRaceService.VehicleInspection(vehicleModel)) { ModelState.AddModelError(nameof(vehicleModel.ResponseMessage), Utility.GetResourceValue("InspectionFail")); } if (ModelState.IsValid) { var image = vehicleModel.ImageFile; if (image?.ContentLength > 0) { //Business logic for save vehicle image string fileExtension = Path.GetExtension(image.FileName); string fileName = Guid.NewGuid() + fileExtension; string folderPath = Path.Combine(Server.MapPath(Utility.GetResourceValue("ImagePath")), fileName); image.SaveAs(folderPath); vehicleModel.Image = fileName; } //Business logic for save vehicle data ResponseMessage response = iVehicleRaceService.AddVehicles(vehicleModel); if (response == ResponseMessage.Inserted) { ViewBag.Success = Utility.GetResourceValue("Success"); } else { ModelState.AddModelError(nameof(vehicleModel.ResponseMessage), Utility.GetResourceValue("TrackOverload")); } } return(View()); }
public async Task HandleAsync_If_Vehicle_Is_Not_Already_Tracked_Vehicle_Tracked_Event_Published() { // Arrange var customer = GetTestCustomer(); var vehicle = new VehicleDto(_vehicleId, "regNr", customer.Id); _trackedVehicleRepository .ExistsAsync(_vehicleId) .Returns(false); _vehicleService .GetAsync(_vehicleId) .Returns(vehicle); _customerService .GetAsync(customer.Id) .Returns(customer); // Act await _trackVehicleHandler.HandleAsync(_command); // Assert await _busPublisher .Received() .PublishAsync(Arg.Is <VehicleTrackedEvent>(e => e.VehicleId == _vehicleId)); }
public async Task CreateVehicle(VehicleDto vehicleDto) { var vehicle = _mapper.Map <Vehicle>(vehicleDto); Insert(vehicle); await SaveChangesAsync(); }
public async Task <ServiceResponse> AddVehicle(VehicleDto newVehicle) { var vehicle = _mapper.Map <Vehicle>(newVehicle); ServiceResponse response = null; vehicle.Id = Guid.NewGuid().ToString(); vehicle.CreatedDate = DateTime.Now; vehicle.CreatedBy = _userSession.GetUser()?.Name; await _dbContext.Vehicles.AddAsync(vehicle); _unitOfWork.SetIsActive(true); var savedRecords = await _unitOfWork.CommitAsync(); if (savedRecords > 0) { response = new ServiceResponse { Success = true, Message = "Vehicle Added successfully" }; } else { response = new ServiceResponse { Success = false, Message = "Vehicle not saved" }; } return(response); }
public async Task HandleAsync_If_Vehicle_Is_Not_Already_Tracked_Tracked_Vehicle_Added() { // Arrange var customer = GetTestCustomer(); var vehicle = new VehicleDto(_vehicleId, "regNr", customer.Id); _trackedVehicleRepository .ExistsAsync(_vehicleId) .Returns(false); _vehicleService .GetAsync(_vehicleId) .Returns(vehicle); _customerService .GetAsync(customer.Id) .Returns(customer); // Act await _trackVehicleHandler.HandleAsync(_command); // Assert await _trackedVehicleRepository .Received() .AddAsync(Arg.Is <TrackedVehicle>(e => e.Id == _vehicleId && e.CustomerId == customer.Id && e.RegNr == vehicle.RegNr && e.Status == TrackedVehicleStatus.Disconnected && e.CustomerAddress == customer.Address)); }
public ActionResult CreateVehicle(VehicleModel addNewVehicle) { ViewBag.Message = "Vehicle has been created"; var createVehicleRequest = new VehicleDto { RegistrationNumber = addNewVehicle.RegistrationNumber, Model = addNewVehicle.Model, Brand = addNewVehicle.Brand, Weight = addNewVehicle.Weight, IsRegistered = addNewVehicle.IsRegistered, FirstUseInTraffic = addNewVehicle.FirstUseInTraffic }; string jsonCreateVehicle = JsonConvert.SerializeObject(createVehicleRequest); var httpContent = new StringContent(jsonCreateVehicle, Encoding.UTF8, "application/json"); using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Session["tokenkey"].ToString()); var response = client.PostAsync(new Uri(_endpoints.CreateVehicle), httpContent).Result; if (response.StatusCode != System.Net.HttpStatusCode.OK) { return(View("Error")); } } return(View("Success")); }
public async Task <IActionResult> Update(int id, [FromBody] VehicleDto vehicleDto) { if (!await vehicleRepository.Exists(id)) { return(NotFound("No such vehicle model.")); } var vehicle = mapper.Map <Vehicle>(vehicleDto); var currentInsurance = await insuranceRepository.Get() .Where(i => i.VehicleId == id) .OrderByDescending(i => i.EndDate) .FirstOrDefaultAsync(); if (currentInsurance == null) { vehicle.CanBeBookedUntil = vehicle.InspectionValidUntil; } else { vehicle.CanBeBookedUntil = currentInsurance.EndDate < vehicle.InspectionValidUntil ? currentInsurance.EndDate : vehicle.InspectionValidUntil; } await vehicleRepository.Update(vehicle); return(Ok()); }
public PositionViewModel(CreateTeltonikaGps tlGps, VehicleDto vehicle, GeofenceHelper.Position lasPosition) { double dir = 0; if (Math.Abs(lasPosition.Latitude - tlGps.Lat) > 0.0) { if (Math.Abs(lasPosition.Longitude - tlGps.Long) > 0.0) { dir = GetDirection(tlGps, lasPosition); } } Latitude = tlGps.Lat; Longitude = tlGps.Long; Address = tlGps.Address; IMEI = tlGps.Imei; // SerialNumber = tlGps.s; //Direction = tlGps.Address Speed = tlGps.Speed; if (vehicle != null) { VehicleName = vehicle.VehicleName; VehicleId = vehicle.Id.ToString(); CustomerName = vehicle.CustomerId; TimeStampUtc = tlGps.DateTimeUtc; SetVehicleImage(vehicle, dir); } }
public VehicleDto Details(string id) { var vehicle = this.vehicleRepository.All().FirstOrDefault(x => x.Id == id); if (vehicle == null) { throw new ArgumentException("There is no info for this vehicle."); } var battery = this.batteryRepository.All().FirstOrDefault(x => x.Id == vehicle.BatteryId); var vehicleDto = new VehicleDto() { VehicleModel = vehicle.VehicleModel, VehicleType = vehicle.VehicleType, ImageURL = vehicle.ImageURL, DateOfPurchase = vehicle.DateOfPurchase, BatteryId = vehicle.BatteryId, Battery = battery, Description = vehicle.Description, UserId = vehicle.UserId, ServiceId = vehicle.ServiceId, InsuranceId = vehicle.InsuranceId, }; return(vehicleDto); }
public IActionResult EditModel(int id, VehicleDto vehicle) { //vehicle = _vehicleService.GetMakeById(id); _vehicleService.UpdateModel(vehicle); return(RedirectToAction("Model")); }
public IHttpActionResult GetVehicleById(VehicleDto vehicle) { var getvehicle = vehicleRepository_.GetVehicleById(vehicle.VehicleId); var getService = vehicleServiceRepository_.GetVehicleServiceByVehicleId(vehicle.VehicleId); var getdate = new VehicleServiceDto(); if (getService != null) { getdate.ServiceDate = getService.ServiceDate; } if (getvehicle != null) { var response = new VehicleDto() { VehicleId = getvehicle.VehicleId, RegistrationNumber = getvehicle.RegistrationNumber, Model = getvehicle.Model, Brand = getvehicle.Brand, YearlyFee = getvehicle.YearlyFee, VehicleType = getvehicle.VehicleType, IsRegistered = getvehicle.IsRegistered, Weight = getvehicle.Weight, FirstUseInTraffic = getvehicle.FirstUseInTraffic, BookedService = getdate.ServiceDate }; return(Ok(response)); } else { return(NotFound()); } }
public async Task <IActionResult> Save(VehicleDto model) { return(Ok(await Mediator.Send(new SaveVehicleCommand() { Model = model }))); }
public static Models.Domain.Vehicle ToDomain(this VehicleDto vehicle) { Enum.TryParse(vehicle.Type, out VehicleType vehicleType); Enum.TryParse(vehicle.Status, out VehicleStatus vehicleStatus); return(new Models.Domain.Vehicle(vehicle.Id, vehicle.TeamName, vehicle.Model, vehicle.ManufacturingDate, vehicleType, vehicleStatus, vehicle.Distance, vehicle.FinishTime)); }
public int UpdateVehicle(VehicleDto vehicle) { int result = 0; try { var lstVehicles = GetCacheData(); if (lstVehicles != null) { var updateVehicle = lstVehicles.Where(x => x.Id == vehicle.Id).FirstOrDefault(); if (updateVehicle != null) { lstVehicles.Remove(updateVehicle); lstVehicles.Add(vehicle); AddCacheData(lstVehicles); result = 1; } } } catch (Exception) { result = -1; throw; } return(result); }
public List <UserVM> Get() { VehicleDto vehicleDto = new VehicleDto { Price = 99 }; UserEntity userEntity = new UserEntity { Age = 30, NameSurname = "Mehmet Ali EROL", Password = "******", Price = 88 }; UserDto userDto = _mapper.Map <UserDto>(userEntity); UserVM userVm = _mapper.Map <UserVM>(userDto); CustomNamedVM customType = _mapper.Map <CustomNamedVM>(userDto); CustomNamedListVM customListType1 = _mapper.Map <CustomNamedListVM>(userDto); CustomNamedListVM customListType2 = _mapper.Map <CustomNamedListVM>(vehicleDto); List <UserEntity> userListEntity = new List <UserEntity> { new UserEntity { Age = 30, NameSurname = "Mehmet Ali EROL1", Password = "******" }, new UserEntity { Age = 40, NameSurname = "Mehmet Ali EROL2", Password = "******" }, new UserEntity { Age = 50, NameSurname = "Mehmet Ali EROL3", Password = "******" } }; List <UserDto> userDtoList = _mapper.Map <List <UserDto> >(userListEntity); List <UserVM> userVMList = _mapper.Map <List <UserVM> >(userDtoList); return(userVMList); }
public ResponseViewModel Get(int id) { var response = new ResponseViewModel(); var vehicle = _vehicleDal.GetVehicle(p => p.Id == id); if (vehicle == null) { response.IsSuccess = false; response.Message = "Vehicle bulunamadı."; return(response); } var vehicleDto = new VehicleDto() { Id = vehicle.Id, PlateNo = vehicle.PlateNo, VehicleTypeId = vehicle.VehicleTypeId, UserId = vehicle.UserId, CreateDate = vehicle.CreateDate, CreatedBy = vehicle.CreatedBy, ModifyDate = vehicle.ModifyDate, ModifiedBy = vehicle.ModifiedBy, IsDeleted = vehicle.IsDeleted }; response.Data = vehicleDto; return(response); }
public List <VehicleDto> Fetch() { using (var ctx = ConnectionManager <SqlConnection> .GetManager(_dbName)) { using (var cm = ctx.Connection.CreateCommand()) { cm.CommandType = CommandType.Text; cm.CommandText = "SELECT * FROM Vehicle"; // WHERE PDNumber = @pdNumber"; //cm.Parameters.AddWithValue("@pdNumber", pdNumber); using (var dr = cm.ExecuteReader()) { if (dr.HasRows) { var result = new List <VehicleDto>(); while (dr.Read()) { var vehicle = new VehicleDto { VehicleId = dr.GetInt32(0), VIN = dr.GetString(1), Xml = dr.GetString(2), VehicleMode = dr.GetInt32(3), GroupId = dr.GetInt32(4), }; result.Add(vehicle); } return(result); } else { return(null); } } } } }
public ActionResult <Vehicle> Create([FromBody] VehicleDto vehicleDto) { try { var userId = _user.GetUserId(); var vehicle = new Vehicle { Brand = vehicleDto.Brand, Model = vehicleDto.Model, Year = vehicleDto.Year, Plate = vehicleDto.Plate, FuelType = vehicleDto.FuelType, Mileage = vehicleDto.Mileage, UserId = userId, Picture = vehicleDto.Picture, VehicleType = vehicleDto.VehicleType }; var result = _vehicleService.Create(vehicle); return(Ok(result)); } catch (ArgumentException ex) { return(NotFound("Invalid data: " + ex.Message)); } catch (Exception e) { return(BadRequest("An error occured: " + e.Message)); } }
public VehicleViewModel Create() { using (var db = new SmartAutosContext()) { return(VehicleDto.VehicleAddViewModelDTO(new Colours(), new Models(), new Manufacturers())); } }
public VehicleDto GetVehicle(int id) { var vehicle = this.vehicleService.GetVehicle(id); var vehicleDto = new VehicleDto(); vehicleDto.ID = vehicle.ID; vehicleDto.SupplierBaseId = vehicle.SupplierBaseId; vehicleDto.DriverContactNo = vehicle.DriverContactNo; vehicleDto.NumberPlate = vehicle.NumberPlate; vehicleDto.VehicleTypeId = vehicle.VehicleTypeId; vehicleDto.ColorCode = vehicle.ColorCode; vehicleDto.MaximumCapacity = vehicle.MaximumCapacity; vehicleDto.Availability = vehicle.Availability; var baseSuplier = supplierBaseService.GetAllSupplierBases(); var baseSuplierItem = baseSuplier.FirstOrDefault(p => p.SupplierBaseId == vehicleDto.ID); if (baseSuplierItem != null) { vehicleDto.SupplierBase = baseSuplierItem.SupplierBaseName; } var vehicleType = vehicleTypeDataService.GetVehicleType(); var vehicleTypeItem = vehicleType.FirstOrDefault(p => p.ID == vehicleDto.VehicleTypeId); if (baseSuplierItem != null) { vehicleDto.VehicleType = vehicleTypeItem.Name; } return(vehicleDto); }
public ActionResult <Vehicle> Update(long vehicleId, [FromBody] VehicleDto vehicleDto) { try { var vehicle = _vehicleService.Get(vehicleId); vehicle.Brand = vehicleDto.Brand; vehicle.Model = vehicleDto.Model; vehicle.FuelType = vehicleDto.FuelType; vehicle.Mileage = vehicleDto.Mileage; vehicle.Picture = vehicleDto.Picture; vehicle.Plate = vehicleDto.Plate; vehicle.Year = vehicleDto.Year; vehicle.VehicleType = vehicleDto.VehicleType; return(Ok(_vehicleService.Update(vehicle))); } catch (ArgumentException ex) { return(NotFound("Invalid data: " + ex.Message)); } catch (Exception e) { return(BadRequest("An error occured: " + e.Message)); } }
public async Task Create(VehicleDto vehicleDto) { var vehicle = Vehicle.Create(vehicleDto.ModelId, vehicleDto.ContactName, vehicleDto.ContactPhone, vehicleDto.ContactEmail, vehicleDto.Features); await _vehicleRepository.Create(vehicle); }
// GET: Admin/Vehicle/Edit/5 public ActionResult Edit(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var vehicle = db.Vehicles.Find(id); var result = new VehicleDto() { Id = vehicle.Id, Brand = vehicle.Brand, DailyPrice = vehicle.DailyPrice, OldImage = vehicle.Image, Image = null, Model = vehicle.Model, VehicleTypeId = vehicle.VehicleTypeId, Year = vehicle.Year }; if (vehicle == null) { return(HttpNotFound()); } ViewBag.VehicleTypeId = new SelectList(db.VehicleTypes, "Id", "Type", result.VehicleTypeId); return(View(result)); }
public ActionResult Create([Bind(Include = "Id,Brand,Model,Year,Image,DailyPrice,VehicleTypeId")] VehicleDto input) { if (ModelState.IsValid) { string newfoto = null; if (input.Image != null && input.Image.ContentLength > 0) { FileInfo fotoinfo = new FileInfo(input.Image.FileName); newfoto = Guid.NewGuid().ToString() + fotoinfo.Extension; string path = Path.Combine(Server.MapPath("~/Upload"), Path.GetFileName(newfoto)); input.Image.SaveAs(path); } var vehicle = new Vehicle() { Brand = input.Brand, DailyPrice = input.DailyPrice, Image = newfoto != null ? ("/Upload/" + newfoto) : null, Model = input.Model, VehicleTypeId = input.VehicleTypeId, Year = input.Year }; db.Vehicles.Add(vehicle); db.SaveChanges(); return(RedirectToAction("Index")); } ViewBag.VehicleTypeId = new SelectList(db.VehicleTypes, "Id", "Type", input.VehicleTypeId); return(View(input)); }
public ActionResult Save(Vehicle vehicle, VehicleDto vehicleDto) { if (vehicle.Id == 0) { _context.Vehicles.Add(vehicle); } else { using (var client = new HttpClient()) { client.BaseAddress = new Uri("http://localhost:51570/api/"); var vehicleInDb = _context.Vehicles.Single(c => c.Id == vehicle.Id); //put request to the api vehicle/id var putTask = client.PutAsJsonAsync <Vehicle>("vehicles/" + vehicle.Id + "/", vehicle); putTask.Wait(); var result = putTask.Result; if (result.IsSuccessStatusCode) { return(RedirectToAction("Index")); } } } return(RedirectToAction("Index")); }
public async Task <IActionResult> CreateMakeAsync([FromForm] VehicleDto vehicle) { var entity = AutoMapper.Mapper.Map <VehicleDto, VehicleMakeEntity>(vehicle); await _vehicleService.InsertMakeAsync(entity); return(Redirect("./fetch-data")); }
public async Task <IActionResult> EditModelAsync(VehicleDto vehicle) { var entity = AutoMapper.Mapper.Map <VehicleDto, VehicleModelEntity>(vehicle); await _vehicleService.UpdateModelAsync(entity); return(RedirectToAction("Model")); }