public async Task <IActionResult> AddCar(CarVm model, IFormFile carfile)
{
string filePath = null;
if (carfile != null)
{
filePath = await _fileUploadService.AddFile(carfile);
}
if (!ModelState.IsValid)
{
return(this.ReturnModelErrorsAsJson());
}
var car = new Car
{
CarrierId = _carrierService.Carrier.Id,
Brand = model.Brand,
Model = model.CarModel,
StateNumber = model.StateNumber,
Volume = model.Volume,
IsActive = true,
FilePath = filePath
};
_dbContext.Cars.Add(car);
await _dbContext.SaveChangesAsync();
return(PartialView("_Car", car));
}
public ActionResult RazorDemo()
{
// ViewBag, ViewData, ViewModel
var c = new CarVm {
Name = "Delorian"
};
ViewData["Auto"] = c;
ViewBag.Auto = c;
// Cookies
var keks = new HttpCookie("keks");
keks.Value = "Hallo Nürnberg";
keks.Expires = DateTime.Now.AddHours(1);
//Response.Cookies.Add(keks);
//Löschen expires in Vergangenheit setzen
//Response.Cookies["keks"].Expires = DateTime.Now.AddDays(-1);
string xyz;
if (Request.Cookies["keks"] != null)
{
xyz = Request.Cookies["keks"].Value;
}
Session["Autos"] = c;
var cool = Session["Autos"] as CarVm;
return(View());
}
public ActionResult RazorDemo()
{
// ViewBag, ViewData, ViewModel
var c = new CarVm {
Name = "Golf"
};
ViewBag.Auto = c;
ViewData["Auto"] = c;
// Cookies
var keks = new HttpCookie("keks");
keks.Value = "Hallo Leipzig";
keks.Expires = DateTime.Now.AddHours(1);
Response.Cookies.Add(keks);
//Response.Cookies["keks"].Expires = DateTime.Now.AddDays(-1);
string xyz;
if (Request.Cookies["keks"] != null)
{
xyz = Request.Cookies["keks"].Value;
}
Session["Autos"] = c;
var cool = Session["Autos"] as CarVm;
HttpContext.Application["GlobalVar"] = 123;
return(View());
}
public IActionResult Edit(int?id)
{
var car = _carRepository.GetCarById(id);
var carVm = new CarVm();
string[] arr = Enum.GetNames(typeof(EventType));
List <SelectListItem> list = new List <SelectListItem>();
foreach (var item in arr)
{
var y = new SelectListItem()
{
Text = item, Value = item
};
list.Add(y);
}
carVm.AllEventTypes = list;
carVm.Car = car;
return(View(carVm));
}
public CarVm GetCarById(int id)
{
Car model = this.Context.Cars.Find(id);
CarVm vm = Mapper.Instance.Map <Car, CarVm>(model);
return(vm);
}
public async Task <IActionResult> ExecuteAsync(int carId, CancellationToken cancellationToken)
{
ICommandResult <Car> result = await _mediator
.Send(new GetCarCommand(carId), cancellationToken);
switch (result.Status)
{
case CommandStatus.Unknown:
default:
throw new ArgumentOutOfRangeException(nameof(result.Status), result.Status, null);
case CommandStatus.NotFound:
return(new NotFoundResult());
case CommandStatus.Ok:
CarVm carVm = _carToVmMapper.Map(result.Data);
if (_actionCtx.ActionContext.HttpContext
.Request.Headers.TryGetValue(HeaderNames.IfModifiedSince, out StringValues stringValues))
{
if (DateTimeOffset.TryParse(stringValues, out DateTimeOffset modifiedSince) && (modifiedSince >= carVm.Modified))
{
return(new StatusCodeResult(StatusCodes.Status304NotModified));
}
}
_actionCtx.ActionContext.HttpContext
.Response.Headers.Add(HeaderNames.LastModified, carVm.Modified.ToString("R", CultureInfo.InvariantCulture));
return(new OkObjectResult(carVm));
}
}
public async Task <IActionResult> Edit(Guid id, [Bind("CarId,LicenseNumber,CarType,NumberOfDrivenKm")] Car car)
{
if (id != car.CarId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_carRepository.UpdateCar(car);
_entityFrameworkRepository.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarExists(car.CarId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
CarVm carTypeVm = new CarVm();
carTypeVm.CarTypes = GetCarTypesToSelectList();
carTypeVm.Car = car;
return(View(carTypeVm));
}
public async Task <IActionResult> ExecuteAsync(
int carId,
JsonPatchDocument <CarSm> patch,
CancellationToken cancellationToken)
{
Car car = await _carRepository.GetAsync(carId, cancellationToken);
if (car == null)
{
return(new NotFoundResult());
}
CarSm saveCar = _carToCarSmMapper.Map(car);
ModelStateDictionary modelState = _actionContextAccessor.ActionContext.ModelState;
patch.ApplyTo(saveCar, modelState);
_objectModelValidator.Validate(_actionContextAccessor.ActionContext, null, null, saveCar);
if (!modelState.IsValid)
{
return(new BadRequestObjectResult(modelState));
}
_carSmToCarMapper.Map(saveCar, car);
await _carRepository.UpdateAsync(car, cancellationToken);
CarVm carViewModel = _carToCarVmMapper.Map(car);
return(new OkObjectResult(carViewModel));
}
public async Task <IActionResult> ExecuteAsync(int carId, CancellationToken cancellationToken)
{
Car car = await _carRepository.GetAsync(carId, cancellationToken);
if (car == null)
{
return(new NotFoundResult());
}
HttpContext httpContext = _actionContextAccessor.ActionContext.HttpContext;
if (httpContext.Request.Headers.TryGetValue(HeaderNames.IfModifiedSince, out StringValues stringValues))
{
if (DateTimeOffset.TryParse(stringValues, out DateTimeOffset modifiedSince) && (modifiedSince >= car.Modified))
{
return(new StatusCodeResult(StatusCodes.Status304NotModified));
}
}
CarVm carViewModel = _carMapper.Map(car);
httpContext.Response.Headers.Add(HeaderNames.LastModified, car.Modified.ToString("R"));
return(new OkObjectResult(carViewModel));
}
public IActionResult GetCars(string category)
{
// if search category such as EcoFriendly and Non-EcoFriendly is empty
if (string.IsNullOrEmpty(category))
{
Cars = _carRepo.Cars.OrderBy(c => c.CarId);
CurrentCategory = "All-Cars";
}
else
{
if (string.Equals("Eco-Friendly", category, StringComparison.OrdinalIgnoreCase))
{
Cars = _carRepo.Cars.Where(c => c.Category.CategoryName.Equals("Eco-Friendly")).OrderBy(c => c.Name).ThenBy(c => c.Price);
}
else
{
Cars = _carRepo.Cars.Where(c => c.Category.CategoryName.Equals("NonEco-Friendly")).OrderBy(c => c.Name).ThenBy(c => c.Price);
}
// here we assign the current category based on search equality
CurrentCategory = category;
}
CarVm vm = new CarVm()
{
Cars = Cars,
CurrentCategory = CurrentCategory
};
return(View(vm));
}
public IActionResult Create()
{
CarVm carTypeVm = new CarVm();
carTypeVm.CarTypes = GetCarTypesToSelectList();
return(View(carTypeVm));
}
public async Task <IActionResult> ExecuteAsync(CarSm carSm, CancellationToken cancellationToken)
{
Car car = _carSmToCarMapper.Map(carSm);
car = await _carRepository.AddAsync(car, cancellationToken);
CarVm carViewModel = _carToCarVmMapper.Map(car);
return(new CreatedAtRouteResult(RouteNames.GetCar, new { carId = carViewModel.CarId }, carViewModel));
}
// GET: api/Cars/5
public IHttpActionResult Get(int id)
{
if (!this.service.ContainsCar(id))
{
return(this.NotFound());
}
CarVm wanted = this.service.GetCarById(id);
return(this.Ok(wanted));
}
//public void AddEvent(Events events)
//{
// _context.Add(events);
// _context.SaveChanges();
//}
public void AddEvent(CarVm carVm)
{
var events = new Events();
events.Time = DateTime.Now;
events.EventType = carVm.Event.EventType;
events.CarId = carVm.Car.Id;
_context.Add(events);
_context.SaveChanges();
}
public ActionResult Create(CarVm carVm)
{
if (!ModelState.IsValid)
{
return(View(carVm));
}
// mapping carVm => car
// Daten auf DB speichern
return(View());
}
public AboutCarVm GetCarWithParts(int id)
{
Car wantedCar = this.Context.Cars.Find(id);
IEnumerable <Part> carParts = wantedCar.Parts;
CarVm wantedCarVm = Mapper.Map <Car, CarVm>(wantedCar);
IEnumerable <PartVm> carPartsVms = Mapper.Map <IEnumerable <Part>, IEnumerable <PartVm> >(carParts);
return(new AboutCarVm()
{
Car = wantedCarVm,
Parts = carPartsVms
});
}
public async Task <IActionResult> ExecuteAsync(int carId, CarSm saveCar, CancellationToken cancellationToken)
{
Car car = await _carRepository.GetAsync(carId, cancellationToken);
if (car == null)
{
return(new NotFoundResult());
}
_carSmToCarMapper.Map(saveCar, car);
car = await _carRepository.UpdateAsync(car, cancellationToken);
CarVm carViewModel = _carToCarVmMapper.Map(car);
return(new OkObjectResult(carViewModel));
}
public AboutCarVm GetCarWithParts(int id)
{
var car = Data.Data.Context.Cars.Find(id);
IEnumerable <Part> partsOfCar = car.Parts;
CarVm carVm = Mapper.Map <Car, CarVm>(car);
IEnumerable <PartVm> partsVm = Mapper.Map <IEnumerable <Part>, IEnumerable <PartVm> >(partsOfCar);
var viewmodel = new AboutCarVm()
{
Car = carVm,
Parts = partsVm
};
return(viewmodel);
}
public IActionResult Create()
{
CarVm carVm = new CarVm();
string[] arr = Enum.GetNames(typeof(CarType));
List <SelectListItem> list = new List <SelectListItem>();
foreach (var item in arr)
{
var y = new SelectListItem()
{
Text = item, Value = item
};
list.Add(y);
}
carVm.AllCarTypes = list;
return(View(carVm));
}
public async Task <IActionResult> EditCar(CarVm carVm)
{
if (carVm.Event.EventType == EventType.Cleaning)
{
carVm.Car.Cleaning = false;
}
if (carVm.Event.EventType == EventType.Service)
{
carVm.Car.Service = false;
}
//var car = _carRepository.GetCarById(id);
_carRepository.UpdateCar(carVm.Car);
_eventsRepository.AddEvent(carVm);
return(RedirectToAction(nameof(Index)));
}
public IActionResult AddCar(CarVm carVm)
{
if (!ModelState.IsValid)
{
return(View(carVm));
}
Car car = new Car
{
Model = carVm.Model,
Color = carVm.Color,
NumberOfDoors = carVm.NumberOfDoors,
ProductionDate = carVm.ProductionDate
};
_carService.Add(car);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> ExecuteAsync(int carId, CarSm carSm, CancellationToken cancellationToken)
{
ICommandResult <Car> result = await _mediator
.Send(new ReplaceCarCommand(carId, carSm), cancellationToken);
switch (result.Status)
{
case CommandStatus.Unknown:
default:
throw new ArgumentOutOfRangeException(nameof(result.Status), result.Status, null);
case CommandStatus.NotFound:
return(new NotFoundResult());
case CommandStatus.Ok:
CarVm carVm = _carVmMapper.Map(result.Data);
return(new OkObjectResult(carVm));
}
}
public async Task <IActionResult> ExecuteAsync(CarSm carSm, CancellationToken cancellationToken)
{
ICommandResult <Car> result = await _mediator
.Send(new CreateCarCommand(carSm), cancellationToken);
switch (result.Status)
{
case CommandStatus.Unknown:
default:
throw new ArgumentOutOfRangeException(nameof(result.Status), result.Status, null);
case CommandStatus.Ok:
CarVm carVm = _carVmMapper.Map(result.Data);
_actionCtx.ActionContext.HttpContext
.Response.Headers.Add(HeaderNames.LastModified, carVm.Modified.ToString("R", CultureInfo.InvariantCulture));
return(new CreatedAtRouteResult(RouteNames.GetCar, new { carId = carVm.CarId }, carVm));
}
}
public async Task <IActionResult> Edit(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var car = _carRepository.GetCarById(id);
if (car == null)
{
return(NotFound());
}
CarVm carTypeVm = new CarVm();
carTypeVm.CarTypes = GetCarTypesToSelectList();
carTypeVm.Car = car;
return(View(carTypeVm));
}
public async Task <IActionResult> ExecuteAsync(int carId, JsonPatchDocument <CarSm> patch, CancellationToken cancellationToken)
{
ICommandResult <Car> result = await _mediator
.Send(new UpdateCarCommand(carId, patch), cancellationToken);
switch (result.Status)
{
case CommandStatus.Unknown:
default:
throw new ArgumentOutOfRangeException(nameof(result.Status), result.Status, null);
case CommandStatus.ModelInvalid:
return(new BadRequestObjectResult(new Failure(_runtimeCtx.GetCorrelationId(), result.ErrorMessages)));
case CommandStatus.NotFound:
return(new NotFoundResult());
case CommandStatus.Ok:
CarVm carViewModel = _carToCarVmMapper.Map(result.Data);
return(new OkObjectResult(carViewModel));
}
}
public bool Resolve(Domain.Car car, CarVm destination, bool destMember, ResolutionContext context)
{
return(car.ServiceRules?.Any(x => x.NeedsService(car, dateTimeProvider)) ?? false);
}
