// "MemberId,ParkingLotNumber,RegNr,VehicleTypeId,Color,NumberOfTyres,Model,Brand"
public ActionResult Create([Bind(Include = "MemberId, ParkingLotNumber,RegNr,VehicleTypeId,Color,NumberOfTyres,VModel,Brand")] VehicleCreateViewModel model)
{
if (ModelState.IsValid)
{
var vehicle = new Vehicle
{
Id = model.Id,
MemberId = model.MemberId,
ParkingLotNumber = model.ParkingLotNumber,
RegNr = model.RegNr,
VehicleTypeId = model.VehicleTypeId,
Color = model.Color,
NumberOfTyres = model.NumberOfTyres,
Modell = model.VModel,
Brand = model.Brand,
ParkingStartTime = DateTime.Now,
};
db.Vehicles.Add(vehicle);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
public void CreateVehicle(VehicleCreateViewModel vehicle)
{
_vehicleRepo.Insert(_mapper.Map <Vehicle>(vehicle));
Vehicle currentVehicle = _vehicleRepo.GetAll().LastOrDefault();
foreach (IFormFile vi in vehicle.Images)
{
var base64 = String.Empty;
if (vi.Length > 0)
{
using (var ms = new MemoryStream())
{
vi.CopyTo(ms);
var fileBytes = ms.ToArray();
base64 = Convert.ToBase64String(fileBytes);
}
_vehicleImageRepo.Insert(new VehicleImage
{
VehicleId = currentVehicle.Id,
ImageString = base64
});
}
}
}
public async Task <IActionResult> Create(VehicleCreateViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
VehicleModel vehicle = new VehicleModel()
{
Number = viewModel.Number,
VIN = viewModel.VIN,
PlateNumber = viewModel.PlateNumber,
ProducerId = viewModel.ProducerId,
RegistrationDate = viewModel.RegistrationDate,
RegistrationDateString = viewModel.RegistrationDate.ToString("d")
};
_vehicleService.Create(vehicle);
return(RedirectToAction("Index"));
}
catch
{
return(View(viewModel));
}
}
else
{
return(View(viewModel));
}
}
public void AddVehicle(VehicleCreateViewModel VCVModel)
{
Vehicle toAdd = VCVModel.ConvertyToVehicleFromCreateModel();
toAdd.Owner = GContext.Owners.Find(toAdd.OwnerId);
toAdd.VehicleType = GContext.VehicleTypes.Find(toAdd.VehicleTypeId);
GContext.Vehicles.Add(toAdd);
GContext.SaveChanges();
}
public ActionResult VehicleCreate()
{
var vm = new VehicleCreateViewModel
{
Vehicle = new Vehicle(),
Fuels = new SelectList(_fuels.Get(), "FuelId", "Name")
};
return(View(vm));
}
public async Task <IActionResult> Create(VehicleCreateViewModel model)
{
model.UserId = this.userManager.GetUserId(User);
var serviceModel = Mapper.Map <VehicleCreateServiceModel>(model);
var newVehicleId = await this.vehicles.CreateAsync(serviceModel);
return(RedirectToAction(nameof(Details), new { id = newVehicleId }));
}
// GET: Vehicles/Create
public IActionResult Create()
{
var viewModel = new VehicleCreateViewModel
{
Brokers = _context.ApplicationUsers.ToList()
};
List <ApplicationUser> brokers = GetAllBrokers();
viewModel.Brokers = brokers;
return(View(viewModel));
}
public IActionResult Create()
{
var vm = new VehicleCreateViewModel
{
lastServiceDate = DateTime.UtcNow.AddDays(-7),
batteryRatedCycles = 200,
StatesList = WellKnown.StatesList
};
return(View(vm));
}
public ActionResult CreateVehicle([Bind(Include = "RegNr, Color, OwnerId, VehicleTypeId")] VehicleCreateViewModel newVehicle)
{
try
{
GRepo.AddVehicle(newVehicle);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
private async Task <VehicleCreateViewModel> InitializeCreationModel()
{
var allManufacturers = await this.manufacturers.AllAsync();
var model = new VehicleCreateViewModel
{
AllManufacturers = allManufacturers.Select(m => new SelectListItem(m.Name, m.Id.ToString())),
AllVehicleTypes = await this.GetAllVehicleTypesAsync(),
AllFuelTypes = await this.GetAllFuelTypesAsync(),
AllGearingTypes = await this.GetAllGearingTypesAsync(),
AvailableYears = this.GetAvailableYears()
};
return(model);
}
public ActionResult Create([Bind(Include = "RegNr,VehicleTypeName,ParkingLotNo,Color,NoOfTyres,FabricateModel,Fabricate")] VehicleCreateViewModel model)
{
if (ModelState.IsValid)
{
model.ParkingStartTime = DateTime.Now;
VehicleCreateViewModel m = new VehicleCreateViewModel();
var vehicle = m.toEnity(model);
//vehicle.ParkingStopTime = DateTime.Now;
db.Vehicles.Add(vehicle);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
// GET: Vehicles/Create
public ActionResult Create()
{
var vehicles = db.Vehicles.ToList();
int count = parkingHelper.getFreeParkingLots(vehicles).Count();
if (count == 0)
{
return(RedirectToAction("Error"));
}
VehicleCreateViewModel model = new VehicleCreateViewModel();
model.Freeparking = parkingHelper.getFreeParkingLots(vehicles);
return(View(model));
}
public async Task <ActionResult> Create([Bind(Include = "Name,Type,LicensePlate,LicenseExpirationDate,Mileage,NextService,EmployeeID")] VehicleCreateViewModel createdVehicle)
{
try
{
if (ModelState.IsValid)
{
IVehicle vehicle = (Mapper.Map <Vehicle>(createdVehicle));
await Service.CreateAsync(vehicle);
return(RedirectToAction("Index"));
}
}
catch (DataException)
{
ModelState.AddModelError("", "Unable to save changes. Try again and if the problem persists see your system administrator.");
}
return(View(createdVehicle));
}
public async Task <IActionResult> Create(VehicleCreateViewModel viewModel)
{
ModelState.Remove("Vehicle.Customer");
ModelState.Remove("Vehicle.Salesman");
ModelState.Remove("Vehicle.Broker");
if (ModelState.IsValid)
{
var vehicle = viewModel.Vehicle;
_context.Add(vehicle);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
viewModel.Brokers = await _context.ApplicationUsers.ToListAsync();
return(View(viewModel));
}
// GET: Vehicles/Create
public ActionResult Create()
{
var vehicles = db.Vehicles.ToList();
int count = ParkingHelper.GetFreeParkingLots(vehicles).Count();
if (count == 0)
{
return(RedirectToAction("Error"));
}
var createViewModel = new VehicleCreateViewModel
{
FreeParking = new SelectList(ParkingHelper.GetFreeParkingLots(vehicles)),
VehicleTypeList = new SelectList(db.VehicleTypes.ToList(), "Id", "Name"),
MemberList = new SelectList(db.Members.ToList(), "MemberId", "FullName"), //We dont really want to do this, but this is an experiment
};
return(View(createViewModel));
}
/*
* public static List<VehicleDetailsViewModel> ConvertToVehicleDetailsModel(this IEnumerable<Vehicle> VModel)
* {
* List<VehicleDetailsViewModel> VDVModel = new List<VehicleDetailsViewModel>();
*
* foreach (var v in VModel)
* {
* VehicleDetailsViewModel VDModel = new VehicleDetailsViewModel();
* VDModel.Id = v.VehicleId;
* VDModel.Color = v.Color;
* VDModel.OwnerName = v.Owner.Name;
* VDModel.PNR = v.Owner.PNR;
* VDModel.RegNr = v.RegNr;
* VDModel.VehicleType = v.VehicleType.Name;
*
* VDVModel.Add(VDModel);
*
* }
*
*
* return VDVModel;
* }
*
* public static List<VehicleViewModel> ConvertToVehicleViewModel(this IEnumerable<Vehicle> VModel)
* {
* List<VehicleViewModel> VVModel = new List<VehicleViewModel>();
*
* foreach (var v in VModel)
* {
* VehicleViewModel VVmodel = new VehicleViewModel();
* VVmodel.Id = v.VehicleId;
* VVmodel.Owner = v.Owner.Name;
* VVmodel.RegNr = v.RegNr;
* VVmodel.VehicleType = v.VehicleType.Name;
*
* VVModel.Add(VVmodel);
* }
*
* return VVModel;
* }
*/
public static Vehicle ConvertyToVehicleFromCreateModel(this VehicleCreateViewModel CVCModel)
{
Vehicle VModel = new Vehicle();
Owner owner = new Owner()
{
Id = CVCModel.OwnerId
};
VehicleType Vtype = new VehicleType()
{
Id = CVCModel.VehicleTypeId
};
VModel.RegNr = CVCModel.RegNr;
VModel.OwnerId = CVCModel.OwnerId;
VModel.Id = CVCModel.VehicleTypeId;
VModel.Color = CVCModel.Color;
VModel.VehicleType = Vtype;
VModel.Owner = owner;
return(VModel);
}
public async Task <ActionResult> CreateAsync([Bind("vin,lastServiceDate,batteryAgeDays,batteryRatedCycles,lifetimeBatteryCyclesUsed,stateVehicleRegistered")] VehicleCreateViewModel item)
{
if (ModelState.IsValid)
{
var newVehicle = new Vehicle
{
id = Guid.NewGuid().ToString(),
vin = item.vin,
lastServiceDate = item.lastServiceDate,
batteryAgeDays = item.batteryAgeDays,
batteryRatedCycles = item.batteryRatedCycles,
lifetimeBatteryCyclesUsed = item.lifetimeBatteryCyclesUsed,
stateVehicleRegistered = item.stateVehicleRegistered
};
// Add the new vehicle to the metadata Cosmos DB container:
await _cosmosDbService.AddItemAsync(newVehicle, newVehicle.partitionKey);
return(RedirectToAction("Index"));
}
return(View(item));
}
public IActionResult Create(VehicleCreateViewModel vehicle)
{
_vehicleService.CreateVehicle(vehicle);
return(RedirectToAction(nameof(Index)));
}
