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"));
}
