public VehicleVO Create(VehicleVO vehicle)
{
var vehicleEntity = _converter.Parse(vehicle);
vehicleEntity = _repository.Create(vehicleEntity);
return(_converter.Parse(vehicleEntity));
}
public ActionResult AddVehicle(AddVehicleViewModel model)
{
if (model.Vehicle.Year > 2020 || model.Vehicle.Year < 1769)
{
ModelState.AddModelError("error", "No vehicles currently exist out side of the years 1769-2020");
return(View(model));
}
if (model.Vehicle.ModelId == 0 || model.Vehicle.MakeId == 0)
{
ModelState.AddModelError("error", "Please provide a make and model");
return(View(model));
}
if (ModelState.IsValid)
{
IVehicleRepository repo = RepoFactory.CreateVehicleRepo();
var vehicle = repo.Create(model.Vehicle);
byte[] imageByte = null;
BinaryReader rdr = new BinaryReader(model.Image.InputStream);
imageByte = rdr.ReadBytes((int)model.Image.ContentLength);
if (System.IO.File.Exists(@"C:\Cohort\Repos\isaiah-dahlberg-individual-work\GuildCars\GuildCars\GuildCars.UI\Images\Inventory-" + model.Vehicle.VehicleId + ".jpg"))
{
System.IO.File.Delete(@"C:\Cohort\Repos\isaiah-dahlberg-individual-work\GuildCars\GuildCars\GuildCars.UI\Images\Inventory-" + model.Vehicle.VehicleId + ".jpg");
}
using (FileStream fs = new FileStream(@"C:\Cohort\Repos\isaiah-dahlberg-individual-work\GuildCars\GuildCars\GuildCars.UI\Images\Inventory-" + vehicle.VehicleId + ".jpg", FileMode.Create))
{
fs.Write(imageByte, 0, imageByte.Length);
}
return(RedirectToAction("EditVehicle/" + vehicle.VehicleId));
}
return(View(model));
}
public async Task Create(VehicleDto vehicleDto)
{
var vehicle = Vehicle.Create(vehicleDto.ModelId, vehicleDto.ContactName,
vehicleDto.ContactPhone, vehicleDto.ContactEmail, vehicleDto.Features);
await _vehicleRepository.Create(vehicle);
}
public async Task <CreateVehicleResponse> Handle(
CreateVehicleRequest request,
CancellationToken cancellationToken)
{
var vehicle = new Vehicle(
request.Brand,
request.Model,
new Color(request.Color),
new LicensePlate(request.LicensePlate),
VehicleType.Car
);
var result = await _repository.Create(vehicle.ToDataEntity());
_repository.CommitChanges();
return(new CreateVehicleResponse(
result.Id,
result.Brand,
result.Model,
result.Color,
result.LicensePlate,
result.Type
));
}
public async Task <IActionResult> Create([FromBody] VehicleCreateDTO vehicleDTO)
{
try
{
if (vehicleDTO == null)
{
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = _mapper.Map <Vehicle>(vehicleDTO);
var isSuccess = await _vehicleRepository.Create(vehicle);
if (!isSuccess)
{
return(InternalError($"Creation failed"));
}
return(Created("Create", new { vehicle }));
}
catch (Exception e)
{
return(InternalError($"{e.Message} - {e.InnerException}"));
}
}
public virtual void Execute(int userId, ICreateVehicleCommand vehicleForm, HttpPostedFileBase photoFile)
{
if (vehicleForm == null)
{
throw new ArgumentNullException("vehicleForm");
}
try
{
var vehicle = vehicleForm.ConvertToEntity(userId);
_vehicleRepository.Create(userId, vehicle);
if (photoFile == null)
{
return;
}
// the double reference between vehicle and photo is a potential source of pain
var photo = photoFile.ConvertToEntity();
_photoRepository.Create(vehicle.VehicleId, photo);
vehicle.PhotoId = photo.VehiclePhotoId;
_vehicleRepository.Update(vehicle);
}
catch (InvalidOperationException ex)
{
throw new BusinessServicesException(Resources.UnableToCreateVehicleExceptionMessage, ex);
}
}
public BaseResult CreateOrUpdateVehicle(Vehicle v)
{
if (v.Id > 0) // Update
{
try
{
v.EmployeeRelations = null;
_vehicles.Update(v);
return(new BaseResult
{
Status = Status.Updated
});
}
catch (StaleObjectStateException ex)
{
return(new BaseResult
{
Status = Status.Conflict,
Message = "Beim Speichern ist ein Konflikt aufgetreten, laden sie die Daten neu"
});
}
catch (Exception ex)
{
return(new BaseResult
{
Status = Status.InternalServerError,
Message = ex.Message
});
}
}
else // Save
{
try
{
var saved = _vehicles.FindByLicensePlate(v.LicensePlate);
if (!(saved is null))
{
return(new BaseResult
{
Status = Status.BadRequest,
Message = "Es existiert bereits ein Fahrzeug mit diesem Nummernschild"
});
}
_vehicles.Create(v);
return(new BaseResult
{
Status = Status.Created
});
}
catch (Exception ex)
{
return(new BaseResult
{
Status = Status.InternalServerError,
Message = ex.Message
});
}
}
}
public async Task <ActionResult <Entities.Vehicle> > CreateVehicle([FromBody] Entities.Vehicle vehicle)
{
await _repository.Create(vehicle);
this.PublishEvent("create", "company.vehicle", vehicle: vehicle);
return(CreatedAtAction("GetVehicles", new { vehicle.Id }, vehicle)); //CreatedAtRoute("GetVehicle", new { id = vehicle.Id }, vehicle);
}
public async Task <IActionResult> Create(Vehicle v)
{
if (ModelState.IsValid)
{
var createdVehicle = await repo.Create(v);
return(RedirectToAction(nameof(Index)));
}
return(View(nameof(Index), null));
}
public async Task <Vehicle> Create(Vehicle vehicle)
{
var success = await _repository.Create(vehicle);
if (success)
{
return(vehicle);
}
else
{
return(null);
}
}
public async Task RegisterVehicle(Vehicle vehicle)
{
try
{
vehicle.RegDate = DateTime.UtcNow.Ticks; // Using UTC time to normalize the time zone.
vehicle.ID = await _vehicleRepository.Create(vehicle);
}
catch (Exception ex)
{
Logger.LogError(ex, $"Error accured while registering vehicle. RegNum:{vehicle.RegNumber}");
throw; // Let the consumer decide what they want to do.
}
}
public Vehicle Create(Vehicle vehicle)
{
if (vehicle == null)
{
throw new ArgumentException("Vehicle cannot be null");
}
if (vehicle.VehicleId != 0)
{
throw new ArgumentException("Create cannot have VehicleId");
}
return(_repo.Create(vehicle));
}
public async Task <ActionResult> PostVehicles([FromBody] Vehicle vehicle)
{
var existingItem = await _repo.Get(vehicle.VIN);
if (existingItem == null)
{
var item = await _repo.Create(vehicle);
return(Created("", vehicle));
}
else
{
return(BadRequest());
}
}
public IHttpActionResult CreateVehicle(VehicleDto request)
{
VehicleFactory vehicleFactory = new VehicleFactory();
IVehicle vehicle = vehicleFactory.CreateVehicle(request.VehicleId,
request.RegistrationNumber,
request.Model,
request.Brand,
request.Weight,
request.IsRegistered,
request.FirstUseInTraffic);
vehicleRepository_.Create(vehicle);
return(Ok());
}
public void Handle(AddVehicle command)
{
var userGroup = userGroupRepository.GetById(command.UserGroupId);
var vehicleType = command.VehicleTypeId == null
? vehicleTypeRepository.GetById(command.VehicleTypeId)
: null;
var tenant = tenantRepository.GetById(userGroup.TenantId);
var(vehicle, events) = tenant.CreateVehicle(
command.LicensePlateId,
vehicleType,
command.Name);
vehicleRepository.Create(vehicle);
eventBus.Publish(events);
}
public IActionResult Add(Vehicle v)
{
if (_userRepository.IsUserLoggedIn() == false)
{
return(RedirectToAction("Index", "Home"));
}
if (v.Year < 1885 || v.Year > DateTime.Now.Year + 1)
{
ModelState.AddModelError("", $"Year Must Be Between 1885 And {DateTime.Now.Year + 1}");
}
if (ModelState.IsValid)
{
_repository.Create(v);
return(RedirectToAction("Details", new { id = v.Id }));
}
return(View(v));
} // end Add( )
public async Task <ActionResult <VehicleDto> > Create(SaveVehicleDto saveVehicleDto)
{
var model = await _modelRepository.Details(saveVehicleDto.ModelId);
if (model == null)
{
return(BadRequest("Invalid ModelId"));
}
var user = await _userRepository.Details(_userAccessor.GetCurrentUsername());
var vehicle = Mapper.Map <SaveVehicleDto, Vehicle>(saveVehicleDto);
vehicle.User = user;
vehicle.LastUpdate = DateTime.Now;
_vehicleRepository.Create(vehicle);
await _unitOfWork.CompleteAsync();
vehicle = await _vehicleRepository.Details(vehicle.Id);
return(Mapper.Map <Vehicle, VehicleDto>(vehicle));
}
public virtual int Execute(int userId, ICreateVehicleCommand vehicleForm, HttpPostedFileBase photoFile)
{
if (vehicleForm == null)
{
throw new ArgumentNullException("vehicleForm");
}
var vehicle = vehicleForm.ConvertToEntity(userId);
_vehicleRepository.Create(userId, vehicle);
if (photoFile != null)
{
// the double reference between vehicle and photo is a potential source of pain
var photo = photoFile.ConvertToEntity();
_photoRepository.Create(vehicle.VehicleId, photo);
vehicle.PhotoId = photo.VehiclePhotoId;
_vehicleRepository.Update(vehicle);
}
return(vehicle.Id);
}
public IActionResult Create(VehicleCreateModel model)
{
foreach (VehicleType vehicleType in model.VehicleTypes)
{
if (vehicleTypeRepository.Exists(vehicleType))
{
ModelState.AddModelError(string.Empty, "VehicleType already exists");
}
if (ModelState.IsValid)
{
vehicleType.Id = vehicleTypeRepository.Create(vehicleType);
}
}
foreach (Vehicle vehicle in model.Vehicles)
{
if (vehicleRepository.Exists(vehicle))
{
ModelState.AddModelError(string.Empty, "Vehicle already exists");
}
if (ModelState.IsValid)
{
VehicleType previouslyStoredType = vehicleTypeRepository.GetByTitle(vehicle.VehicleType.Title);
if (previouslyStoredType != null)
{
vehicle.VehicleTypeId = previouslyStoredType.Id;
vehicleRepository.Create(vehicle);
}
}
}
if (ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
ViewData["CompanyId"] = new SelectList(companyRepository.GetAll(), "Id", "Title");
ViewData["VehicleTypeId"] = new SelectList(companyRepository.GetAll(), "Id", "Title");
return(View(model));
}
public IActionResult Post([FromBody] Vehicle model)
{
try
{
if (!ModelState.IsValid)
{
return(InvalidModelStateResult());
}
if (!validateEntity(model))
{
return(InvalidModelStateResult());
}
var modelResult = repository.Create(model);
var result = (new List <Vehicle>()
{
modelResult
}).Select(a => new
{
a.VehicleId,
a.VehicleNum,
a.VehicleTypeId,
VehicleTypeCode = a.VehicleType == null ? "" : a.VehicleType.VehicleTypeCode,
a.IsActive,
a.CustomerId,
a.HaulerId,
a.SupplierId
}).FirstOrDefault();
return(Accepted(result));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.CreateError));
}
}
public Vehicle AddVehicle(Vehicle vehicle)
{
if (vehicle.ID < 0 || vehicle.ID > 0)
{
throw new InvalidDataException("Cannot add vehicle with ID!");
}
if (vehicle.UniqueID == null || vehicle.UniqueID.Trim() == "")
{
throw new InvalidDataException("Cannot add vehicle without uniqID!");
}
if (vehicle.Brand == null || vehicle.Brand.Trim() == "")
{
throw new InvalidDataException("Cannot add vehicle without brand!");
}
if (vehicle.Type == null || vehicle.Type.Trim() == "")
{
throw new InvalidDataException("Cannot add vehicle without type!");
}
if (vehicle.User == null || vehicle.User.ID <= 0)
{
throw new InvalidDataException("Cannot add vehicle without user!");
}
return(_repo.Create(vehicle));
}
public Task <Vehicle> Create(Vehicle vehicle)
{
return(_vehicleRepository.Create(vehicle));
}
public Vehicle Create(Vehicle vehicle)
{
VehicleEntity result = _vehicleRepository.Create(_mapper.Map <VehicleEntity>(vehicle));
return(_mapper.Map <Vehicle>(result));
}
public async Task <Vehicle> Create(Vehicle vehicle)
{
return(await _vehicleRepository.Create(vehicle));
}
public Task <List <ReportFlatOwnersVehicleDetail> > UploadFlatOwnersVehicle(List <ReportFlatOwnersVehicleDetail> vehicles)
{
var taskResult = Task.Run(async() =>
{
using (var context = new DbContext())
{
//validate
foreach (var item in vehicles)
{
StringBuilder sb = new StringBuilder();
if (string.IsNullOrEmpty(item.Society))
{
sb.Append(",Society");
}
if (string.IsNullOrEmpty(item.Building))
{
sb.Append(",Building");
}
if (string.IsNullOrEmpty(item.Wing))
{
sb.Append(",Wing");
}
if (string.IsNullOrEmpty(item.Floor))
{
sb.Append(",Floor");
}
if (string.IsNullOrEmpty(item.Flat))
{
sb.Append(",Flat");
}
if (string.IsNullOrEmpty(item.FlatOwner))
{
sb.Append(",Flat Owner");
}
if (string.IsNullOrEmpty(item.FlatOwnerType))
{
sb.Append(",Flat Owner Type");
}
if (string.IsNullOrEmpty(item.Name))
{
sb.Append(",Name");
}
if (string.IsNullOrEmpty(item.Number))
{
sb.Append(",Number.");
}
if (!item.Type.HasValue)
{
sb.Append(",Type");
}
if (sb.Length > 0)
{
sb.Append(" is/are missing.");
sb.Append("<br />");
}
if (sb.Length > 0)
{
item.IsSuccess = false;
item.Message = sb.ToString().Trim(',');
continue;
}
var flatowner = (from msf in context.MapsSocietiesToFacilities
join f in context.Facilities on msf.FacilityId equals f.Id
join flr in context.Floors on f.Id equals flr.FacilityId
join fls in context.Flats on flr.Id equals fls.FloorId
join mffo in context.MapsFlatToFlatOwner on fls.Id equals mffo.FlatId
join fos in context.FlatOwners on mffo.FlatOwnerId equals fos.Id
where msf.Society.Name.Equals(item.Society, StringComparison.InvariantCultureIgnoreCase) &&
f.Name.Equals(item.Building, StringComparison.InvariantCultureIgnoreCase) &&
f.Wing.Equals(item.Wing, StringComparison.InvariantCultureIgnoreCase) &&
flr.Name.Equals(item.Floor, StringComparison.InvariantCultureIgnoreCase) &&
fls.Name.Equals(item.Flat, StringComparison.InvariantCultureIgnoreCase) &&
fos.Name.Equals(item.FlatOwner, StringComparison.InvariantCultureIgnoreCase) &&
mffo.FlatOwnerType == (item.FlatOwnerType.Equals("Owner", StringComparison.InvariantCultureIgnoreCase) ? 1 : 2)
select new
{
fo = fos,
flat = fls
})
.FirstOrDefault();
if (flatowner == null)
{
item.IsSuccess = false;
item.Message = string.Format("No flat found for {0}-{1}-{2}-{3}-{4}.", item.Society, item.Building, item.Wing, item.Floor, item.Flat);
continue;
}
var vehicle = new Vehicle()
{
Name = item.Name,
Number = item.Number,
Make = item.Make,
Type = item.Type,
FlatId = flatowner.flat.Id,
FlatOwnerId = flatowner.fo.Id
};
try
{
await _vehicleRepository.Create(vehicle);
}
catch (Exception ex)
{
item.IsSuccess = false;
item.Message = ex.Message;
continue;
}
item.IsSuccess = true;
item.Message = "Done";
}
return(vehicles);
}
});
return(taskResult);
}
public ActionResult <Vehicle> Create(Vehicle vehicle)
{
_vehicles.Create(vehicle);
return(CreatedAtRoute("GetVehicle", new { id = vehicle.Id.ToString() }, vehicle));
}
/// <summary> /// Add a new vehicle to the database. /// NOTE: In a real implementation, there would be logic here to resolve the Manufacturer (and probably other things as well, such as Model) /// from the Manufacturer table. Some kind logic would handle the "enter a new manufacturer" case, etc. /// </summary> /// <param name="vehicle"></param> public void AddVehicle(Vehicle vehicle) => _vehicleRepository.Create(vehicle);
public Vehicle CreateVehicle(Vehicle vehicle)
{
return(_vehicleRepository.Create(vehicle));
}
