public async Task <IActionResult> Edit(int id, [Bind("RefuelID,VehicleID,RefuelDate,Amount,Price")] Refuel refuel)
{
if (id != refuel.RefuelID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(refuel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RefuelExists(refuel.RefuelID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["VehicleID"] = new SelectList(_context.Vehicle, "ID", "Name", refuel.VehicleID);
return(View(refuel));
}
public async Task <Refuel> UpdateAsync(Refuel refuel)
{
refuelRepository.Update(refuel);
await refuelRepository.UnitOfWork.SaveChangesAsync();
return(refuel);
}
public GamePlayEvents()
{
JobCancelled = new Cancelled();
JobDelivered = new Delivered();
FinedEvent = new Fined();
TollgateEvent = new Tollgate();
TrainEvent = new Transport();
FerryEvent = new Transport();
RefuelEvent = new Refuel();
}
private void OnSaveCommand()
{
var vehicle = _repository.Get(Vehicle.Id);
Refuel refuel = MapToModel(vehicle);
vehicle.Fuellings.Add(refuel);
_repository.Update(vehicle);
_navigationService.GoBack();
}
public async Task <IActionResult> Create([Bind("RefuelID,VehicleID,RefuelDate,Amount,Price")] Refuel refuel)
{
if (ModelState.IsValid)
{
_context.Add(refuel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["VehicleID"] = new SelectList(_context.Vehicle, "ID", "Name", refuel.VehicleID);
return(View(refuel));
}
public async Task HandleAsync(CreateRefuel command)
{
var car = await _carRepository.GetAsync(command.CarId);
if (car is null)
{
throw new Exception($"Car with id {command.CarId} does not exists");
}
var refuel = new Refuel(command.Id, command.CarId, command.Date,
command.Liters, command.LiterPrice, command.Mielage);
await _refuelRepository.AddAsync(refuel);
}
public async Task <Refuel> CreateAsync(Refuel refuel)
{
if (refuel.Id != 0)
{
throw new ArgumentException("The 'Id' must be different from 0.");
}
refuel = refuelRepository.Add(refuel);
await refuelRepository.UnitOfWork.SaveChangesAsync();
return(refuel);
}
public async Task <IActionResult> DeleteRefuelAsync(int id)
{
Refuel refuel = await _refuelService.GetByIdAsync(id);
if (refuel == null)
{
return(NotFound(new { Message = $"Refuel with Id {id} not found" }));
}
await _refuelService.DeleteAsync(refuel);
return(NoContent());
}
public IActionResult GetRefuel(int id)
{
Refuel _refuel = _refuelService.Get(id);
if (_refuel != null)
{
return(Ok(_refuel));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> CreateRefuelAsync([FromBody] RefuelItem refuelItem)
{
Refuel refuel = _mapper.Map <Refuel>(refuelItem);
try
{
refuel = await _refuelService.CreateAsync(refuel);
}
catch (Exception exception)
{
BadRequest(exception);
}
return(Ok(_mapper.Map <RefuelViewModel>(refuel)));
}
public async Task <IActionResult> UpdateRefuelAsync([FromBody] RefuelItem refuelItem)
{
Refuel refuel = await _refuelService.GetByIdAsync(refuelItem.Id);
if (refuel == null)
{
return(NotFound(new { Message = $"Refuel with Id {refuelItem.Id} not found" }));
}
_mapper.Map(refuelItem, refuel);
await _refuelService.UpdateAsync(refuel);
return(Ok(_mapper.Map <RefuelViewModel>(refuel)));
}
public async Task <IActionResult> AddRefuel([Bind("Id,Station,Amount,Price, RefuelDate")] Refuel refuel)
{
if (ModelState.IsValid)
{
if (refuel.Id == 0)
{
_db.Add(refuel);
}
else
{
_db.Update(refuel);
}
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(refuel));
}
public IActionResult RegisterRefuel([FromBody] RegisterRefuelViewModel viewModel)
{
try
{
if (ModelState.IsValid)
{
Vehicle _vehicle = _vehicleService.GetByLicensePlate(viewModel.VehicleLicensePlate);
Driver _driver = _driverService.GetByCPF(viewModel.DriverCPF);
GasStation _gasStation = _gasStationService.GetByCnpj(viewModel.GasStationCNPJ);
Refuel refuel = new Refuel()
{
TotalValue = viewModel.TotalValue,
LiterValue = viewModel.LiterValue,
Liters = viewModel.Liters,
FuelType = viewModel.FuelType,
RefuelDate = viewModel.RefuelDate,
Driver = _driver,
Vehicle = _vehicle,
GasStation = _gasStation
};
string _refuelFeedback = refuel.Validate();
if (_refuelFeedback == "ok")
{
return(Created("", _refuelService.Insert(refuel)));
}
else
{
return(BadRequest(_refuelFeedback));
}
}
else
{
return(BadRequest());
}
}
catch (Exception ex)
{
return(BadRequest(ex.InnerException));
}
}
public async Task <ApiResult <bool> > AddRefuel([FromBody] DTO.Refuel refuel)
{
if (!int.TryParse(HttpContext.User.Identity.Name, out int userId))
{
return(ApiResult(false, "Не указан идентификатор пользователя!"));
}
var driver = await dbContext
.Employees
.FirstOrDefaultAsync(x => x.UserId == userId);
if (driver == null)
{
return(ApiResult(false, "Не удалось найти сотрудника!"));
}
var refuelModel = await dbContext.Refuels.FirstOrDefaultAsync(x => x.Id == refuel.Id);
if (refuelModel == null)
{
refuelModel = new Refuel();
dbContext.Refuels.Add(refuelModel);
}
refuel.Adapt(refuelModel);
refuelModel.Date = DateTime.Now;
refuelModel.DriverId = driver.Id;
try
{
await dbContext.SaveChangesAsync();
}
catch (Exception ex)
{
return(ApiResult(false, $"{ex.Message}\n{ex.InnerException?.Message}"));
}
return(ApiResult(true));
}
public JsonResult SaveFuel(Refuel refuel)
{
var fuelTrackerLogic = new FuelTrackerLogic();
var saveResult = fuelTrackerLogic.SaveRefeul(refuel.CarId, refuel.FuelBefore, refuel.FuelAmount);
var result = new Result();
if (saveResult == true)
{
result.Status = "SUCCESS";
result.Message = "Save Complete.";
}
else
{
result.Status = "FAILED";
result.Message = "Save Failed, please try again.";
}
return(Json(new
{
Result = result
}, JsonRequestBehavior.AllowGet));
}
private void _updateTimer_Elapsed(object sender)
{
var scsTelemetry = SharedMemory.Update <SCSTelemetry>();
// check if sdk is NOT running
if (!scsTelemetry.SdkActive && !paused)
{
// if so don't check so often the data
var tsInterval = new TimeSpan(0, 0, 0, 0, DefaultPausedUpdateInterval);
_updateTimer.Change(tsInterval.Add(tsInterval), tsInterval);
paused = true;
// if sdk not active we don't need to do something
return;
}
if (paused && scsTelemetry.SdkActive)
{
// ok sdk is active now
paused = false;
resume(); // going back to normal update rate
}
var time = scsTelemetry.Timestamp;
Data?.Invoke(scsTelemetry, time != lastTime);
//TODO: make it nicer thats a lot of code for such less work
// Job start event
if (wasOnJob != scsTelemetry.SpecialEventsValues.OnJob)
{
wasOnJob = scsTelemetry.SpecialEventsValues.OnJob;
if (scsTelemetry.SpecialEventsValues.OnJob)
{
JobStarted?.Invoke(this, new EventArgs());
}
}
if (cancelled != scsTelemetry.SpecialEventsValues.JobCancelled)
{
cancelled = scsTelemetry.SpecialEventsValues.JobCancelled;
if (scsTelemetry.SpecialEventsValues.JobCancelled)
{
JobCancelled?.Invoke(this, new EventArgs());
}
}
if (delivered != scsTelemetry.SpecialEventsValues.JobDelivered)
{
delivered = scsTelemetry.SpecialEventsValues.JobDelivered;
if (scsTelemetry.SpecialEventsValues.JobDelivered)
{
JobDelivered?.Invoke(this, new EventArgs());
}
}
if (fined != scsTelemetry.SpecialEventsValues.Fined)
{
fined = scsTelemetry.SpecialEventsValues.Fined;
if (scsTelemetry.SpecialEventsValues.Fined)
{
Fined?.Invoke(this, new EventArgs());
}
}
if (tollgate != scsTelemetry.SpecialEventsValues.Tollgate)
{
tollgate = scsTelemetry.SpecialEventsValues.Tollgate;
if (scsTelemetry.SpecialEventsValues.Tollgate)
{
Tollgate?.Invoke(this, new EventArgs());
}
}
if (ferry != scsTelemetry.SpecialEventsValues.Ferry)
{
ferry = scsTelemetry.SpecialEventsValues.Ferry;
if (scsTelemetry.SpecialEventsValues.Ferry)
{
Ferry?.Invoke(this, new EventArgs());
}
}
if (train != scsTelemetry.SpecialEventsValues.Train)
{
train = scsTelemetry.SpecialEventsValues.Train;
if (scsTelemetry.SpecialEventsValues.Train)
{
Train?.Invoke(this, new EventArgs());
}
}
if (refuel != scsTelemetry.SpecialEventsValues.Refuel)
{
refuel = scsTelemetry.SpecialEventsValues.Refuel;
if (scsTelemetry.SpecialEventsValues.Refuel)
{
Refuel?.Invoke(this, new EventArgs());
}
}
lastTime = time;
}
public async Task <int> Update(Refuel refuel)
{
_ctx.Refuels.Update(refuel);
return(await _ctx.SaveChangesAsync());
}
public async Task <int> Delete(Refuel refuel)
{
_ctx.Refuels.Remove(refuel);
return(await _ctx.SaveChangesAsync());
}
public RefuelAddedDomainEvent(Refuel refuel)
{
Refuel = refuel;
}
public async Task DeleteAsync(Refuel refuel)
{
refuelRepository.Remove(refuel);
await refuelRepository.UnitOfWork.SaveChangesAsync();
}
public async Task AddAsync(Refuel refuel) => await _refuels.InsertOneAsync(refuel);
public Refuel Add(Refuel refuel)
{
return(_context.Refuels.Add(refuel).Entity);
}
public void Remove(Refuel refuel)
{
_context.Refuels.Remove(refuel);
}
public void Update(Refuel refuel)
{
_context.Entry(refuel).State = EntityState.Modified;
}
