public void CreateVehicleModel(IVehicleModel model)
{
var vehicleMake = context.VehicleMakes.First(c => c.Id == model.MakeId);
vehicleMake.VehicleModels.Add(AutoMapper.Mapper.Map <VehicleModel>(model));
context.SaveChanges();
}
public ActionResult EditPost(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
IVehicleModel ModelToUpdate = Service.FindModel(id);
if (TryUpdateModel(ModelToUpdate, "",
new string[] { "ModelName", "ModelsMaker" }))
{
try
{
Service.UpdateModel(ModelToUpdate);
return(RedirectToAction("Index"));
}
catch (DataException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
ViewBag.MakeID = new SelectList(Service.GetMakers(), "MakeID", "MakerName", ModelToUpdate.MakeID);
return(View(AutoMapper.Mapper.Map <MakerViewModel>(ModelToUpdate)));
}
public async Task UpdateModel(IVehicleModel vehicle)
{
VehicleModel update = mapper.Map <VehicleModel>(vehicle);
context.VehicleModels.Update(update);
await context.SaveChangesAsync();
}
public async Task <VehicleModel> CreateVehicleModel(IVehicleModel <VehicleMake> modelToCreate)
{
var modelExists = await vehicleModelRespository.ReadModelById(modelToCreate.Id) != null;
if (modelExists)
{
return(null);
}
var makeEntity = await vehicleMakeRespository.GetById(modelToCreate.Make.Id);
var newMakeEntityValues = mapper.Map <VehicleMakeEntity>(modelToCreate.Make);
if (makeEntity != null)
{
await UpdateAsync(newMakeEntityValues);
}
else
{
await AddAsync(newMakeEntityValues);
}
modelToCreate.Make.Id = newMakeEntityValues.Id;
var modelEntityToCreate = mapper.Map <VehicleModelEntity>(modelToCreate);
await AddAsync(modelEntityToCreate);
await CommitAsync();
var createdModel = await vehicleModelRespository.ReadModelById(modelEntityToCreate.Id);
return(createdModel);
}
public Sampler(Random random, ITrack track, IVehicleModel vehicleModel, double goalBias)
{
this.random = random;
this.track = track;
this.vehicleModel = vehicleModel;
this.goalBias = goalBias;
}
public RRTPlanner(
double goalBias,
int maximumNumberOfIterations,
IWorldDefinition world,
Random random,
TimeSpan timeStep,
IGoal goal)
{
if (goalBias > 0.5)
{
throw new ArgumentOutOfRangeException($"Goal bias must be at most 0.5 (given {goalBias}).");
}
this.goalBias = goalBias;
this.maximumNumberOfIterations = maximumNumberOfIterations;
this.vehicleModel = world.VehicleModel;
this.motionModel = world.MotionModel;
this.track = world.Track;
this.collisionDetector = world.CollisionDetector;
this.random = random;
this.timeStep = timeStep;
this.goal = goal;
this.actions = world.Actions;
distances = new DistanceMeasurement(track.Width, track.Height);
ExploredStates = exploredStates;
}
public WayPointsFollowingRRTPlanner(
double goalBias,
int maximumNumberOfIterations,
IVehicleModel vehicleModel,
IMotionModel motionModel,
ITrack track,
ICollisionDetector collisionDetector,
Random random,
TimeSpan timeStep,
IActionSet actions,
IReadOnlyList <IGoal> wayPoints)
{
if (goalBias > 0.5)
{
throw new ArgumentOutOfRangeException($"Goal bias must be at most 0.5 (given {goalBias}).");
}
this.goalBias = goalBias;
this.maximumNumberOfIterations = maximumNumberOfIterations;
this.vehicleModel = vehicleModel;
this.motionModel = motionModel;
this.track = track;
this.collisionDetector = collisionDetector;
this.random = random;
this.timeStep = timeStep;
this.wayPoints = wayPoints;
this.actions = actions;
distances = new DistanceMeasurement(track.Width, track.Height);
wayPointsReached = 0;
ExploredStates = exploredStates;
}
public async Task InsertModel(IVehicleModel vehicle)
{
VehicleModel create = mapper.Map <VehicleModel>(vehicle);
context.VehicleModels.Add(create);
await context.SaveChangesAsync();
}
public async Task <IVehicleModel> UpdateVehicleModelAsync(int id, IVehicleModel changedModel)
{
var model = await UnitOfWork.VehicleModelRepository.Update(id, Mapper.Map <Vehicle.DAL.Entities.VehicleModelEntity>(changedModel));
await UnitOfWork.CommitAsync();
return(Mapper.Map <IVehicleModel>(model));
}
public async Task <IVehicleModel> AddVehicleModelAsync(IVehicleModel newModel)
{
await UnitOfWork.VehicleModelRepository.Add(Mapper.Map <Vehicle.DAL.Entities.VehicleModelEntity>(newModel));
await UnitOfWork.CommitAsync();
return(newModel);
}
public async Task <IVehicleModel> FindById(object id)
{
VehicleModelEntity entity = await dbSet.FindAsync(id);
IVehicleModel model = _mapper.Map <VehicleModel>(entity);
return(model);
}
public async Task <IVehicleModel> FindById(object id)
{
VehicleModelEntityModel entity = await _genericRepository.FindById(id);
IVehicleModel model = iMapper.Map <VehicleModel>(entity);
return(model);
}
/// <summary>
/// Instert new vehicle.
/// </summary>
/// <param name="vehicleModel">Vehicle model.</param>
/// <returns>Updates database.</returns>
public Task InsertVehicleAsync(IVehicleModel vehicleModel)
{
vehicleModel.Id = Guid.NewGuid();
vehicleModel.Abrv = vehicleModel.Name.Substring(0, 3);
vehicleContext.VehicleModels.Add(mapper.Map <DAL.Entities.VehicleModel>(vehicleModel));
return(vehicleContext.SaveChangesAsync());
}
public async Task <IVehicleModel> AddModelAsync(IVehicleModel model)
{
var createdModel = await unitOfWork.Models.AddAsync(model);
await unitOfWork.CommitAsync();
return(createdModel);
}
public ModelServicesAsync(
IRepository repository,
IUnitOfWork unitOfWork,
IVehicleModel vehicleModel)
{
_repository = repository ?? throw new ArgumentNullException(nameof(IRepository));
_unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(IUnitOfWork));
VehicleModel = vehicleModel ?? throw new ArgumentNullException(nameof(IVehicleModel));
}
public BoundingSphereCollisionDetector(ITrack track, IVehicleModel vehicleModel)
{
this.track = track;
var u = vehicleModel.Length / 2;
var v = vehicleModel.Width / 2;
diagonal = Math.Sqrt(u * u + v * v);
}
public void InsertVehicleModel(IVehicleModel model)
{
var validationResult = validator.Validate(model);
if (!validationResult.IsValid)
{
logger.LogInformation(validationResult.ToString());
return;
}
logger.LogInformation("vehicle inserted");
}
public async Task <VehicleModel> UpdateModel(IVehicleModel <VehicleMake> modelUpdates)
{
var modelEntityUpdates = mapper.Map <VehicleModelEntity>(modelUpdates);
var modelToUpdateEntity = await Update(modelEntityUpdates);
await SaveAsync();
var updatedModel = await ReadModelById(modelToUpdateEntity.Id);
return(updatedModel);
}
public void Delete(IVehicleModel vehicleModel)
{
try
{
VehicleModelEntityModel entityToDelete = iMapper.Map <VehicleModelEntityModel>(vehicleModel);
_genericRepository.Delete(entityToDelete);
}
catch (Exception)
{
throw;
}
}
public async Task <IVehicleModel> AddVehicleModelAsync(IVehicleModel vehicleModel)
{
if (vehicleModel != null)
{
var vehicleModelEntity = Mapper.Map <VehicleModelEntity>(vehicleModel);
vehicleModelEntity.Abrv = vehicleModelEntity.Name.ToLower();
await Context.VehicleModels.AddAsync(vehicleModelEntity);
await Context.SaveChangesAsync();
}
return(vehicleModel);
}
public async Task <IHttpActionResult> GetVehicleModelByID(int id)
{
IVehicleModel vehicleModel = await _vehicleModelService.GetVehicleModelByIDAsync(id);
if (vehicleModel == null)
{
return(NotFound());
}
VehicleModelViewModel vehicleModelViewModel = _mapper.Map <VehicleModelViewModel>(vehicleModel);
return(Ok(vehicleModelViewModel));
}
public async Task <bool> Create(IVehicleModel vehicleModel)
{
try
{
VehicleModelEntity entity = _mapper.Map <VehicleModelEntity>(vehicleModel);
dbSet.Add(entity);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Update method,
/// updates/edits a VehicleModel using VehicleModel Repository.
/// </summary>
/// <param name="entity">Model, type of IVehicleModel.</param>
/// <returns>Returns boolean to controller, so controller knows if VehicleModel was updated or not.</returns>
public async Task <Boolean> UpdateVehicleModelAsync(IVehicleModel entity)
{
if (await repository.GetVehicleModelAsync(entity.Id) != null)
{
await repository.UpdateVehicleModelAsync(entity);
return(true);
}
else
{
return(false);
}
}
public async Task <IHttpActionResult> DeleteVehicleModel(int id)
{
IVehicleModel vehicleModel = await _vehicleService.FindVehicleModel(id);
if (vehicleModel == null)
{
return(NotFound());
}
await _vehicleService.DeleteVehicleModel(id);
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IVehicleModel> UpdateVehicleModelAsync(IVehicleModel vehicleModel)
{
if (vehicleModel != null)
{
var vehicleModelEntity = Mapper.Map <VehicleModelEntity>(vehicleModel);
vehicleModelEntity.DateModified = DateTime.UtcNow;
var vehicleModelEntityEntry = Context.VehicleModels.Attach(vehicleModelEntity);
vehicleModelEntityEntry.State = EntityState.Modified;
await Context.SaveChangesAsync();
return(vehicleModel);
}
return(null);
}
public async Task <bool> Edit(IVehicleModel vehicleModel)
{
try
{
VehicleModelEntityModel entity = iMapper.Map <VehicleModelEntityModel>(vehicleModel);
await _genericRepository.Edit(entity);
return(true);
}
catch
{
return(false);
}
}
public void SaveChanges(IVehicleModel vehicleModel)
{
if (vehicleModel.Id == 0)
{
context.Add(mapper.Map <VehicleModel>(vehicleModel));
context.SaveChanges();
}
else
{
var vehicle = context.VehicleModels.Attach(mapper.Map <VehicleModel>(vehicleModel));
vehicle.State = EntityState.Modified;
context.SaveChanges();
}
}
public async Task <bool> CreateVehicleModel(IVehicleModel vehicleModel)
{
try
{
await _repository.Create(vehicleModel);
await uow.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public async Task <bool> EditVehicleModel(IVehicleModel vehicleModel)
{
try
{
await _vehicleModelRepository.Edit(vehicleModel);
await _unitOfWork.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public static void StoreResult(ITrack track, IVehicleModel vehicle, ISummary summary, string imageFilePath, string fileName)
{
var serializableSummary = new SerialzableSimulationResult
{
SimulationTime = summary.SimulationTime.TotalSeconds,
Result = summary.Result,
Log = summary.Log.Select(SerializableEventFactory.From),
Track = SerializableTrack.From(track.TileSize, track.Circuit, track.OccupancyGrid),
VehicleModel = vehicle,
TrackImageFilePath = imageFilePath
};
var json = JsonConvert.SerializeObject(serializableSummary, CustomJsonSerializationSettings.Default);
File.WriteAllText(fileName, json);
}
public AutomobileControl(IVehicleModel paramModel, IVehicleView paramView)
{
this.Model = paramModel;
this.View = paramView;
}
/// <summary>
/// Updates the VehicleModel async.
/// </summary>
/// <param name="vehicleModel"></param>
/// <returns></returns>
public virtual async Task<int> UpdateAsync(IVehicleModel vehicleModel)
{
return await Repository.UpdateAsync(vehicleModel);
}
public void SetModel(IVehicleModel paramValue)
{
this.Model = paramValue;
}
public SlowpokeControl(IVehicleModel paramModel, IVehicleView paramView)
{
this.Model = paramModel;
this.View = paramView;
}
/// <summary>
/// Updates the VehicleModel async.
/// </summary>
/// <param name="vehicleModel"></param>
/// <returns></returns>
public virtual async Task<int> UpdateAsync(IVehicleModel vehicleModel)
{
return await Repository.UpdateAsync<VehicleModel>(Mapper.Map<VehicleModel>(vehicleModel));
}
/// <summary>
/// Saves the VehicleModel to the database async.
/// </summary>
/// <param name="vehicleModel"></param>
/// <returns></returns>
public virtual async Task<int> AddAsync(IVehicleModel vehicleModel)
{
IUnitOfWork unitOfWork = CreateUnitOfWork();
var vehicleMake = Repository.GetWhere<VehicleMake>().Where(x => x.Id == vehicleModel.VehicleMakeId).Select(x => x.Name).FirstOrDefault();
await unitOfWork.AddAsync<VehicleModel>(Mapper.Map<VehicleModel>(vehicleModel));
return await unitOfWork.CommitAsync();
}
/// <summary>
/// Updates a single VehicleModel entity.
/// </summary>
/// <param name="id"></param>
/// <param name="updatedItem"></param>
/// <returns></returns>
public void Update(Guid id, IVehicleModel updatedItem)
{
var item = genericRepository.GetSet<VehicleModel>().SingleOrDefault(p => p.Id == id);
// Sets the corresponding foreign key.
var make = genericRepository.GetContext().VehicleMakes.Find(id);
updatedItem.MakeId = item.MakeId;
genericRepository.Update(item, Mapper.Map<VehicleModel>(updatedItem));
}
/// <summary>
/// Creates new VehicleModel entity.
/// </summary>
/// <param name="model"></param>
/// <param name="id"></param>
/// <returns></returns>
public void Create(IVehicleModel model, Guid id)
{
var make = genericRepository.GetContext().VehicleMakes.Find(id);
model.MakeId = make.Id;
genericRepository.Create(Mapper.Map<VehicleModel>(model));
}
/// <summary>
/// Updates a single VehicleModel entity.
/// </summary>
/// <param name="id"></param>
/// <param name="updatedItem"></param>
/// <returns></returns>
public void Update(Guid id, IVehicleModel updatedItem)
{
vehicleModelRepository.Update(id, updatedItem);
}
public void Update(IVehicleModel paramModel)
{
this.UpdateInterface(paramModel);
}
public void UpdateInterface(IVehicleModel auto)
{
this.label1.Text = auto.Name + " heading " + auto.Direction.ToString() + " at speed: " + auto.Speed.ToString();
this.pBar.Value = (auto.Speed>0)? auto.Speed*100/auto.MaxSpeed : auto.Speed*100/auto.MaxReverseSpeed;
}
public void WireUp(IVehicleControl paramControl, IVehicleModel paramModel)
{
if(Model != null)
{
Model.RemoveObserver(this);
}
Model = paramModel;
Control = paramControl;
Control.SetModel(Model);
Control.SetView(this);
Model.AddObserver(this);
}
/// <summary>
/// Updates a single VehicleModel entity.
/// </summary>
/// <param name="model"></param>
/// <param name="id"></param>
/// <returns></returns>
public void Create(IVehicleModel model, Guid id)
{
vehicleModelRepository.Create(model, id);
}
