public async Task <IActionResult> OnPostAsync(Car car)
{
AppUser user = await _userManager.GetUserAsync(User);
if (!ModelState.IsValid)
{
return(Page());
}
string typedNumberPlate = car.NumberPlate;
bool Carfound;
Carfound = false;
IEnumerable <Car> carPlates = carService.GetCarsNumberPlate(typedNumberPlate);
if (carPlates.Count() > 0)
{
Carfound = true;
}
if (Carfound == false)
{
car.AppUserID = user.Id;
carService.AddCar(car);
return(RedirectToPage("MyCars"));
}
else
{
Message = "You cannot add two cars with the same number plate";
return(Page());
}
}
public async Task <IActionResult> AddCar([FromForm] NewCarDto dto)
{
try
{
_logger.LogInformation($"Create new car ad by userID: {_currentUserService.UserId}");
var newCar = _mapper.Map <Car>(dto);
if (dto.Image != null)
{
var imageResult = await _storageService.UploadImageToStorage(_currentUserService.UserId, dto.Image);
if (imageResult != null)
{
newCar.Image = imageResult.Name;
}
}
var result = await _carService.AddCar(newCar, _currentUserService.UserId);
if (result != null)
{
return(CreatedAtAction(nameof(Get), new { carId = result.Id },
_mapper.Map <CarDto>(result)));
}
_logger.LogError($"Something went wrong to create new car");
return(BadRequest());
}
catch (Exception e)
{
_logger.LogError($"Something went wrong inside AddCar action: {e.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public IActionResult Post([FromForm] CarAddDto carAddDto)
{
List <string> imagePaths = new List <string>();
if (Request.Form.Files.Count > 0)
{
var carImages = Request.Form.Files;
foreach (var file in carImages)
{
// TODO: Filename edit
// upload request form files to under "wwwroot/Images/CarImages" folder and return saving db paths
var dbPath = FileUploadHelper.UploadFile(file, "wwwroot", "Images\\CarImages");
imagePaths.Add(dbPath);
}
}
var car = _mapper.Map <Car>(carAddDto);
var result = _carManager.AddCar(car, imagePaths);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
//imagePaths.ForEach(FileUploadHelper.RemoveFile);
return(Ok(result));
}
public IHttpActionResult AddCar([FromBody] CarAddViewModel carViewModel)
{
if (ModelState.IsValid)
{
Car car = new Car()
{
Model = carViewModel.Model,
Brand = carViewModel.Brand,
MainImage = carViewModel.MainImage,
NumberOfDoors = carViewModel.NumberOfDoors,
NumberOfSeats = carViewModel.NumberOfSeats
};
if (_carService.AddCar(car))
{
string carObject = JsonConvert.SerializeObject(car, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
_carHub.Clients.All.carAdded(carObject);
return(Ok());
}
return(BadRequest());
}
return(BadRequest(ModelState));
}
private void ProcessCarList(Chunk chunk)
{
var newSize = chunk.Size - Reader.AlignToBoundary(0x10);
if (newSize % 0xD0 != 0)
{
throw new InvalidDataException("Malformed car list chunk");
}
Progress?.Report("Processing car list");
while (Stream.Position < chunk.EndOffset)
{
var cti = BinaryHelpers.ReadStruct <CarTypeInfo>(Reader);
//Debug.WriteLine("{0} {1} ({2})", cti.ManufacturerName, cti.BaseModelName, cti.UsageType);
var acr = new AaronCarRecord();
acr.BaseModelName = cti.BaseModelName;
acr.CarTypeName = cti.CarTypeName;
acr.ManufacturerName = cti.ManufacturerName;
acr.DefaultBasePaint = cti.DefaultBasePaint;
acr.DefaultSkinNumber = cti.DefaultSkinNumber;
acr.Skinnable = cti.Skinnable;
acr.UsageType = cti.UsageType;
_carService.AddCar(acr);
HashResolver.Add(cti.CarTypeNameHash, cti.CarTypeName);
}
this.GenerateHashes();
}
private void btnAdd_Click(object sender, EventArgs e)
{
//Dodawanie/Modyfikowanie
var provider = new Dependencies().Load();
ICarService carService = provider.GetService <ICarService>();
if (isUpdate)
{
var carUpdate = UpdateCarFromForm();
if (!carUpdate.Validate())
{
MessageBox.Show("Validation error");
return;
}
carService.UpdateCar(id, carUpdate);
this.Hide();
}
else
{
var carAdd = AddCarFromForm();
if (!carAdd.Validate())
{
MessageBox.Show("Validation error");
return;
}
carService.AddCar(carAdd);
this.Hide();
}
}
public async Task <AddCarCommandResponse> Handle(AddCarCommand request, CancellationToken cancellationToken)
{
var car = _mapper.Map <Car>(request);
var newCar = await _carService.AddCar(car);
var carResponse = _mapper.Map <AddCarCommandResponse>(newCar);
return(carResponse);
}
public IActionResult PostCar([FromBody] Car car)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_service.AddCar(car);
return(CreatedAtAction("GetCar", new { id = car.Id }, car));
}
public async Task <IActionResult> Create(CarCreateVM carVM)
{
if (ModelState.IsValid)
{
await _carService.AddCar(carVM, User.Identity.Name.ToString());
return(RedirectToAction(nameof(Index)));
}
return(View(carVM));
}
public IActionResult CarAdd(Car car)
{
var result = _carService.AddCar(car);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ActionResult Create([Bind(Include = "Maker,Model,Year")] Car car)
{
if (ModelState.IsValid)
{
_carService.AddCar(car);
return(RedirectToAction("Index"));
}
return(View(car));
}
public ActionResult AddCar(CarViewModel car)
{
if (ModelState.IsValid)
{
_carService.AddCar(CarViewModelAssembler.FromViewModelToModel(car));
TempData["Sucess"] = "Машина успешно добавлена";
return(RedirectToAction("Index", "Home"));
}
return(View(car));
}
public async Task <ActionResult> AddCar([FromBody] CarAddDto car)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
await _carService.AddCar(car);
return(Ok());
}
public async Task <IActionResult> Add(CarDTO model)
{
if (ModelState.IsValid)
{
await _service.AddCar(model);
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <IActionResult> AddCar([FromBody] CreateRentalCarDto addRentalCarDto)
{
var readRentalCarDto = await _carService.AddCar(addRentalCarDto);
if (readRentalCarDto != null)
{
return(CreatedAtRoute(nameof(GetRentalCarById), new { Id = readRentalCarDto.Id }, readRentalCarDto));
}
return(BadRequest());
}
public HttpResponse Add(AddCarListingViewModel model)
{
var checkForErrors = CarService.AddCar(model, this.User.Id);
if (checkForErrors.Count != 0)
{
return(Error(checkForErrors));
}
return(Redirect("./All"));
}
public IActionResult Add(NCar car)
{
var result = _iCarService.AddCar(car);
if (result.Success == true)
{
return(Ok(result));
}
return(BadRequest(result.Message));
}
public IActionResult Create(Car car)
{
_logger.LogInfo($"Car {car.Name} was created; max speed= {car.MaxSpeed}");
if (car.MaxSpeed == 111)
{
var ex = new FormatException("Error on purpose");
_logger.LogError(ex, "Logging exception on purpose");
throw ex;
}
_carService.AddCar(car);
return(RedirectToAction("Index"));
}
public ActionResult AddCustomerToCar(Car car)
{
if (car == null)
{
return(RedirectToAction("Index", "Customers"));
}
car.CarAddedDate = DateTime.Now;
car.CarUpdateDate = DateTime.Now;
_carService.AddCar(car);
return(RedirectToAction("CustomerIsCars", new RouteValueDictionary(
new { controller = "Cars", action = "CustomerIsCars", Id = car.CustomerId })));
}
public ActionResult Create(CarViewModel carViewModel, HttpPostedFileBase uploadImage)
{
if (ModelState.IsValid && uploadImage != null)
{
carViewModel.Image = carViewModel.Image = _service.GetCarImage(uploadImage);
var carDto = carViewModel.ToCarDto();
_service.AddCar(carDto);
return(RedirectToAction("Index"));
}
return(View(carViewModel));
}
public ActionResult AddCar([FromBody] Car car)
{
_logger.LogInformation("AddCar Car called");
if (!ModelState.IsValid)
{
return(BadRequest("Please check data entered"));
}
var result = _carService.AddCar(car);
return(Ok(result));
}
public async Task <IActionResult> CreateCar([FromBody] CarForCreationDto carFromBody, string userId)
{
if (!_userService.UserExists(userId))
{
return(NotFound());
}
var carToRetrun = _carService.AddCar(carFromBody, userId);
await _linksService.AddLinksAsync(carToRetrun);
return(CreatedAtRoute(Constants.RouteNames.GetCar, new { userId = userId, id = carToRetrun.Id }, carToRetrun));
}
public void Create(CarGridModel car)
{
decimal price = car.LastPrice;
DateTime time = DateTime.Now;
var carView = Mapper.Map <CarGridModel, CarViewModel>(car);
carView.BrandId = (int)TempData["BrandID"];
carView.ModelId = (int)TempData["ModelID"];
carView.Prices.Add(new CostViewModel {
Date = time, Price = price
});
carService.AddCar(Mapper.Map <CarViewModel, CarDTO>(carView));
}
public ActionResult Create(Car car)
{
try
{
_carService.AddCar(car);
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
_logger.Error(ex, "Error while creating car");
return(View());
}
}
public async Task <ActionResult <Car> > Add(CarDto newCar)
{
var vehicleTypes = await _vehicleTypeService.GetAllVehicleTypes();
newCar.VehicleTypeID = vehicleTypes.First(t => t.Type.ToLower().Equals("car")).VehicleTypeID;
Car addedCar = await _carService.AddCar(newCar);
if (addedCar != null)
{
return(CreatedAtAction("Add", addedCar));
}
return(StatusCode(500));
}
public IActionResult Create([FromBody] Car car)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newCar = new Car {
Model = car.Model, Brand = car.Brand, Price = car.Price
};
newCar = carsService.AddCar(newCar);
return(CreatedAtAction(nameof(Create), new { id = newCar.Id }, newCar));
}
public CarStatus AddCar([FromBody] Car car)
{
try
{
return(_carService.AddCar(car));
}
catch
{
CarStatus status = new CarStatus();
status.Message = "Cos poszlo nie tak";
status.Status = "Failed";
status.RegistrationNumber = car.RegistrationNumber;
return(status);
}
}
public ActionResult Create(string number = null, int type = -1, int status = -1)
{
if (number == null || number == "" || type < 0 || status < 0)
{
ModelState.AddModelError("error", "ERROR!");
}
else if (carService.AddCar(number, type, status) == 0)
{
ModelState.AddModelError("error", "Add OK!");
}
else
{
ModelState.AddModelError("error", "ERROR!");
}
return(View("Index", carService.GetListAllCar()));
}
public IActionResult Post(string id, [FromBody] Car car)
{
if (ModelState.IsValid)
{
if (car.Id == 0)
{
_repo.AddCar(id, car);
}
else
{
_repo.UpdateCar(car);
}
return(Ok(car));
}
return(HttpBadRequest(ModelState));
}
public async Task <IActionResult> AddCar([FromBody] EditCarDto editCar)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var newCar = _mapper.Map <Car>(editCar);
await _carService.AddCar(newCar);
editCar.Id = newCar.Id;
await _priceHistoryService.AddPriceHistory(_mapper.Map <PriceHistory>(editCar));
return(await GetCar(newCar.Id));
}
