public IActionResult Add(Car newcar)
{
//image/jpeg
newcar.ContentType = newcar.PictureInfo.ContentType;
byte[] data = new byte[newcar.PictureInfo.Length];
using (var stream = newcar.PictureInfo.OpenReadStream())
{
stream.Read(data, 0, (int)newcar.PictureInfo.Length);
}
newcar.PictureData = data;
if (newcar.Plate == "AAA-111")
{
return(StatusCode(306));
}
if (!ModelState.IsValid)
{
return(View(nameof(Add), newcar));
}
repo.Add(newcar);
return(RedirectToAction(nameof(Index)));
//return Index();
}
public async Task <IActionResult> AddAnnounce(int userId, CarForAnnounceDto carAnnounceDto)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid data."));
}
var car = new Car()
{
Km = carAnnounceDto.Km,
Price = carAnnounceDto.Price,
EnginePower = carAnnounceDto.EnginePower,
CylindricalCapacity = carAnnounceDto.CylindricalCapacity,
State = carAnnounceDto.State,
Damaged = carAnnounceDto.Damaged,
ParticleFilter = carAnnounceDto.ParticleFilter,
RightHandDrive = carAnnounceDto.RightHandDrive,
BrandId = carAnnounceDto.BrandId,
BodyId = carAnnounceDto.BodyId,
ModelId = carAnnounceDto.ModelId,
ModelVersionId = carAnnounceDto.ModelVersionId,
FuelId = carAnnounceDto.FuelId,
CountryId = carAnnounceDto.CountryId,
GearboxId = carAnnounceDto.GearboxId,
TransmissionId = carAnnounceDto.TransmissionId,
ManufacturingDateId = carAnnounceDto.ManufacturingDateId,
PollutionRuleId = carAnnounceDto.PollutionRuleId
};
_repo.Add(car);
await _repo.SaveAll();
_repo.Add(new Announce()
{
Title = carAnnounceDto.Title,
Description = carAnnounceDto.Description,
CreatedDate = carAnnounceDto.CreatedDate,
Features = carAnnounceDto.Features,
CarId = car.CarId,
UserId = userId
});
if (await _repo.SaveAll())
{
return(NoContent());
}
return(BadRequest("A aparut o problema"));
}
public async Task <IActionResult> CreateMessage(int userId, MessageForCreationDto messageForCreationDto)
{
var sender = await _userRepo.GetUser(userId, true); // for automapper magic!!!!
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageForCreationDto.SenderId = userId;
var car = await _repo.GetCar(messageForCreationDto.CarId, false); // for automapper magic!!!!
if (car == null)
{
return(BadRequest("Could not find the car"));
}
var message = _mapper.Map <Message>(messageForCreationDto);
_repo.Add(message);
if (await _repo.SaveAll())
{
var messageToReturn = _mapper.Map <MessageForReturnDto>(message);
return(CreatedAtRoute("GetMessage", new { userId, id = message.Id }, messageToReturn));
}
throw new Exception("Failed to create the message");
}
public async Task <IActionResult> CreateCar([FromBody] SaveCarResource carResource)
{
// Validations- check if not ModelState is valid
// if (!ModelState.IsValid)
// return BadRequest(ModelState);
// Map API resource to Domain Object
var car = mapper.Map <SaveCarResource, Car>(carResource);
// setting the last update property
car.LastUpdate = DateTime.Now;
// Add the Car object into the dbcontext
repository.Add(car);
// saving the changes
await unitOfWork.CompleteAsync();
// fetch a complete representation of a Car
car = await repository.GetCar(car.Id);
// map the result back to a CarResource
var result = mapper.Map <Car, CarResource>(car);
// return Ok (carResource); // Ok() inherited from the base controller class. Will return it with HTTP Status 200
return(Ok(result));
}
public void AddCar(string carType, string civSeries, string bodySeries,
int carMileage, int yearOfManufacture, string itpValability,
string ownerFirstName, string ownerLastName,
string cNP)
{
var owner = ownerRepository.Add(new Owner()
{
Id = Guid.NewGuid(),
FirstName = ownerFirstName,
LastName = ownerLastName,
CNP = cNP
});
var car = carRepository.Add(new Car()
{
Id = Guid.NewGuid(),
CarType = carType,
CivSeries = civSeries,
BodySeries = bodySeries,
CarMileage = carMileage,
YearOfManufacture = yearOfManufacture,
ItpValability = itpValability,
Owner = owner,
});
}
public IActionResult Create(CreateCarViewModel model)
{
try
{
if (ModelState.IsValid)
{
string uniqueFileName = ProcessUploadFile(model);
Car newCar = new Car
{
CarModel = model.CarModel,
Prijs = model.Prijs,
Content = model.Content,
PhotoCar = uniqueFileName,
CreatedDate = DateTime.Now,
IsAvailableForRent = true,
};
_carRepository.Add(newCar);
return(RedirectToAction("Details", "Cars", new { id = newCar.CarId }));
}
return(View());
}
catch (Exception ex)
{
_logger.LogError(ex, $"When trying to create a new car.");
throw;
}
}
public async Task <Car> AddNewCar(CreateCarModel newCar)
{
if (await CheckIfRegistrationNumberExists(newCar.RegistrationNumber))
{
throw new EntryAlreadyExistsException("A car with such Registration Number already exists!");
}
var createdCar = new Car()
{
Brand = newCar.Brand,
Color = newCar.Color,
FuelId = (int)newCar.FuelId,
TransmissionId = (int)newCar.TransmissionId,
CarBodyId = (int)newCar.CarBodyId,
FabricationYear = newCar.FabricationYear,
RegistrationNumber = newCar.RegistrationNumber,
Model = newCar.Model,
NumberOfSeats = newCar.NumberOfSeats,
NumberOfDoors = newCar.NumberOfDoors,
AirCoditioning = newCar.AirCoditioning,
PricePerDay = newCar.PricePerDay,
};
_carRepository.Add(createdCar);
await _carRepository.SaveAll();
return(createdCar);
}
public async Task <CarDto> AddCarService([FromForm] CarPhotoDto carPhotoDto)
{
var result = await AddPhotoAsync(carPhotoDto.File);
var car = new Cars
{
CarPhotoUrl = result.SecureUrl.AbsoluteUri,
PublicId = result.PublicId,
Car = carPhotoDto.Car,
Brand = carPhotoDto.Brand,
FuelType = carPhotoDto.FuelType,
Year = carPhotoDto.Year,
Price = carPhotoDto.Price,
Mileage = carPhotoDto.Mileage,
isTaken = false,
AppUserId = 4
};
_carRepository.Add <Cars>(car);
if (await _carRepository.SaveAllAsync())
{
return(_mapper.Map <CarDto>(car));
}
throw new Exception();
}
public async Task <bool> AddAsync(CarDTO carDto)
{
var car = _mapper.Map <CarDTO, Car>(carDto);
var result = await _carRepository.Add(car);
return(result);
}
public IActionResult Add([FromBody] DetailDto value)
{
Car car = value;
if (String.IsNullOrWhiteSpace(car.PremiseId))
{
return(BadRequest(new ErrorModel
{
Message = "Premise MUST be chosen!"
}));
}
try
{
if (_repo.CarExists(car))
{
return(Conflict("Car already exists!"));
}
}
catch (ArgumentNullException ex)
{
return(BadRequest(new ErrorModel
{
Message = ex.Message,
CauseValue = nameof(value)
}));
}
_repo.Add(value);
_repo.Save();
return(Ok());
}
public async Task <IActionResult> LikeUser(int id, int recipientId)
{
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var like = await _repo.GetLike(id, recipientId);
if (like != null)
{
return(BadRequest("You already liked this user"));
}
if (await _repo.GetUser(recipientId, false) == null)
{
return(NotFound());
}
like = new Like
{
LikerId = id,
LikeeId = recipientId
};
_repo.Add <Like>(like);
if (await _repo.SaveAll())
{
return(Ok());
}
return(BadRequest("Failed to like user"));
}
public async Task <IActionResult> CreateMessage(int userId,
MessageForCreationDto messageForCreationDto)
{
var sender = await _repo.GetUser(userId, false);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageForCreationDto.SenderId = userId;
var recipient = await _repo.GetUser(messageForCreationDto.RecipientId, false);
if (recipient == null)
{
return(BadRequest("Utilizatorul nu a fost gasit."));
}
var message = _mapper.Map <Message>(messageForCreationDto);
_repo.Add(message);
if (await _repo.SaveAll())
{
var messageToReturn = _mapper.Map <MessageToReturnDto>(message);
return(CreatedAtRoute("GetMessage", new { userId, id = message.Id }, messageToReturn));
}
else
{
throw new Exception("Eroare la crearea mesajului.");
}
}
public async Task <IActionResult> Add(CarViewModel carViewModel)
{
if (!ModelState.IsValid)
{
return(View(carViewModel));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
ModelState.AddModelError("", "Błąd użytkownika");
return(View(carViewModel));
}
var car = carViewModel.GetCar();
car.User = user;
car.ActualMileage = car.StartMileage;
var result = await _carRepository.Add(car);
if (!result)
{
ModelState.AddModelError("", "Błąd dodawania pojazdu");
return(View(carViewModel));
}
return(RedirectToAction("index"));
}
public IActionResult AddCar(AddCarModel model)
{
Car car = new Car();
if (ModelState.IsValid)
{
if (model.Image != null)
{
var path = Path.GetExtension(model.Image.FileName);
var newImageName = Guid.NewGuid() + path;
var uploadPath = Path.Combine(Directory.GetCurrentDirectory
(), "wwwroot/img/" + newImageName);
var stream = new FileStream(uploadPath, FileMode.Create);
model.Image.CopyTo(stream);
car.Image = newImageName;
}
car.Brand = model.Brand;
car.Plate = model.Plate;
car.Start_date = model.EntryDate;
car.End_date = model.ExpireDate;
_carRepository.Add(car);
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public async Task <IActionResult> CreateCar([FromBody] CarResource carResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var car = mapper.Map <CarResource, Car>(carResource);
car.Race = context.Races.Where(r => r.Id == car.RaceId).FirstOrDefault();
var sections = new List <CourseSection>();
foreach (var checkpoint in context.Checkpoints.Where(c => c.RaceId == car.RaceId).ToList())
{
sections.Add(
new CourseSection()
{
Car = car,
Checkpoint = checkpoint
}
);
}
car.CourseSections = sections;
repository.Add(car);
await unitOfWork.CompleteAsync();
var finalResource = mapper.Map <Car, CarResource>(car);
return(Ok(finalResource));
}
private async Task CreateCar(string name, string description)
{
var car = new CreateCarDto {
Name = name, Description = description
};
await _carRepository.Add(car);
}
public async Task <int> Add(CarDomain carDomain)
{
var totalNumberOfCarsInRepository = await _bizCoverCarRepository.Add(carDomain.ToCar());
await _carsMemoryCache.Refresh(carsKey, () => _bizCoverCarRepository.GetAllCars());
return(totalNumberOfCarsInRepository);
}
public void Handle(CarParams car)
{
var carEntity = _mapper.Map <Car>(car);
carEntity.AddedOn = DateTime.Now;
_carRepository.Add(carEntity);
}
public HttpResponseMessage Post(Car car)
{
_repository.Add(car);
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.Created);
httpResponseMessage.Headers.Location = new Uri(Request.RequestUri.ToString() + "/" + car.Id.ToString());
return(httpResponseMessage);
}
public async Task <Car> AddCar(Car car)
{
var newCarId = await _carRepository.Add(car);
car.Id = newCarId;
return(car);
}
public async Task Add(Car car)
{
if (!ExecuteValidation(new CarValidation(), car))
{
return;
}
await _carRepository.Add(car);
}
public async Task <CarDTO> Handle(CreateCarCommand command, CancellationToken cancellationToken)
{
Car car = new Car(command.Model, command.Make, command.Registration, command.Year, command.Odometer);
_carRepository.Add(car);
await _uow.CommitAsync(cancellationToken);
return(_mapper.Map <CarDTO>(car));
}
public IResult Add(Car car)
{
_carRepository.Add(car);
return(new SuccessResult()
{
Message = Messages.CarAdded
});
}
public async Task <IActionResult> Post([FromBody] CarDto carDto)
{
var car = new Car(carDto.Type, carDto.Name, carDto.Doors,
carDto.Seats, carDto.Year, carDto.Fuel);
_carRepository.Add(car);
await _carRepository.CommitAsync();
return(Ok());
}
public IActionResult SaveCar(AddCarViewModel viewModel)
{
var car = mapper.Map <Car>(viewModel.CarDto);
car.Manufacturer = manufacturerRepo.Get(car.Manufacturer.Id);
carRepo.Add(car);
return(RedirectToAction("Index"));
}
public void Add()
{
Car c = Builder <Car> .CreateNew().Build();
r.Add(c);
Assert.Equal(101, c.ID);
Assert.Equal("Make1", c.Make);
Assert.Equal("Model1", c.Model);
Assert.Equal("Colour1", c.Colour);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns>Подтверждение автомобиля</returns>
public IActionResult Confirm(int id)
{
var car = carRepository.GetAll().Where(c => c.ID.IDValue == id).ToArray()[0];
carRepository.Delete(car);
car.IsConfirned = true;
car.Owner = "Автосалон";
carRepository.Add(car);
return(LocalRedirect("~/Worke/OperationComplited"));
}
public async Task <Car> AddCar(IAddCarRequest addCarRequest)
{
var request = _addCarRequestMapper.Map(addCarRequest);
var id = await _carRepository.Add(request);
request.Id = id;
_carRepositoryCache.InvalidateCache();
return(request);
}
public void AddCar(CarBindingModel model)
{
var car = new Car
{
Model = model.Model,
BrandId = _hashidsService.Decode(model.BrandNumber),
BodyTypeId = _hashidsService.Decode(model.BodyTypeNumber)
};
_carRepository.Add(car);
}
public IActionResult Execute(SaveCar saveCar)
{
var car = _saveCarToCarMapper.Map(saveCar);
_carRepository.Add(car);
var carViewModel = _carToCarMapper.Map(car);
return(new CreatedAtRouteResult(
CarsControllerRoute.GetCar,
new { id = carViewModel.Id },
carViewModel));
}
