async Task <object> deleteVehicleReservation(int id)
{
VehicleReservation vehicleReservation = await _context.VehicleReservation.FindAsync(id);
var vehicle = await _context.Vehicles.Include(vehicle => vehicle.UnavailableDates).FirstOrDefaultAsync(vehicle => vehicle.VehicleId == vehicleReservation.VehicleId);
vehicle.UnavailableDates.ToList().ForEach(
unavailableDate =>
{
if (unavailableDate.Date.Date >= vehicleReservation.FromDate.Date && unavailableDate.Date.Date <= vehicleReservation.ToDate.Date)
{
_context.Remove(unavailableDate);
}
}
);
_context.Entry(vehicleReservation).State = EntityState.Deleted;
try
{
await _context.SaveChangesAsync();
return(Ok());
}
catch (Exception e)
{
return(BadRequest());
}
}
public async Task <Object> PostVehicleReservation(TOVehicleReservation toVehicleReservation, [FromQuery] int version)
{
string role = User.Claims.First(c => c.Type == "Roles").Value;
if (role != "regular")
{
return(BadRequest("You are not authorised to do this action"));
}
VehicleReservation vehicleReservation = new VehicleReservation();
vehicleReservation.FromTO(toVehicleReservation);
bool success = false;
Vehicle vehicle = await _context.Vehicles.Include(v => v.UnavailableDates).FirstOrDefaultAsync(v => v.VehicleId == vehicleReservation.VehicleId);
if (vehicle.Version != version)
{
//Provera da li je zbog edita ili rezervacije duple
return(Ok(new { success }));
}
_context.VehicleReservation.Add(vehicleReservation);
await _context.SaveChangesAsync();
//Treba popuniti Unavailable Dates
for (int i = 0; i < vehicleReservation.NumOfDays; i++)
{
vehicle.UnavailableDates.Add(new UnavailableDate()
{
DateId = 0,
Vehicle = vehicle,
Date = vehicleReservation.FromDate.AddDays(i)
});
}
vehicle.Version++;
await _context.SaveChangesAsync();
int id = vehicleReservation.ReservationId;
success = true;
return(Ok(new { id, success }));
}
public async Task <IActionResult> PutVehicleReservation(int id, TOVehicleReservation toVehicleReservation)
{
string role = User.Claims.First(c => c.Type == "Roles").Value;
if (role != "regular")
{
return(BadRequest("You are not authorised to do this action"));
}
VehicleReservation vehicleReservation = new VehicleReservation();
vehicleReservation.FromTO(toVehicleReservation);
if (id != vehicleReservation.ReservationId)
{
return(BadRequest());
}
_context.Entry(vehicleReservation).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleReservationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <FlightReservation> > PostFlightReservation(TOFlightReservation flightReservation, int points)
{
TOFlight tempFlight = new TOFlight();
string userId = User.Claims.First(c => c.Type == "UserID").Value;
var inviter = await _userManager.FindByIdAsync(userId);
VehicleReservation vehicleReservation = null;
Vehicle vehicle = null;
if (flightReservation.VehicleReservationId != 0)
{
vehicleReservation = await _context.VehicleReservation.FindAsync(flightReservation.VehicleReservationId);
vehicle = await _context.Vehicles.Include(vehicle => vehicle.RentACar).FirstOrDefaultAsync(vehicle => vehicle.VehicleId == vehicleReservation.VehicleId);
}
FlightReservation tempFlightReservation = new FlightReservation()
{
ReservationId = 0,
TimeOfCreation = DateTime.Now,
Creator = inviter.UserName,
VehicleReservationId = flightReservation.VehicleReservationId,
FinalPrice = flightReservation.FinalPrice
};
flightReservation.FlightReservationDetails.ForEach(flightReservation => { inviter.NumberOfPoint += (int)Math.Round(flightReservation.Flight.Distance); });
inviter.NumberOfPoint -= points;
await _userManager.UpdateAsync(inviter);
_context.FlightReservations.Add(tempFlightReservation);
await _context.SaveChangesAsync();
foreach (TOFlightReservationDetail tOFlightReservationDetail in flightReservation.FlightReservationDetails)
{
tempFlight = tOFlightReservationDetail.Flight;
FlightReservationDetail flightReservationDetail = new FlightReservationDetail()
{
FlightId = tOFlightReservationDetail.Flight.FlightId,
FlightReservation = tempFlightReservation,
FlightReservationDetailId = 0,
AirlineName = tOFlightReservationDetail.Flight.AirlineName
};
_context.Entry(flightReservationDetail).State = EntityState.Added;
await _context.SaveChangesAsync();
foreach (TOPassengerSeat tOPassengerSeat in tOFlightReservationDetail.PassengerSeats)
{
PassengerSeat passengerSeat = new PassengerSeat()
{
SeatId = tOPassengerSeat.Seat.SeatId,
Surname = tOPassengerSeat.Surname,
PassengerSeatId = 0,
Name = tOPassengerSeat.Name,
Passport = tOPassengerSeat.Passport,
Username = tOPassengerSeat.Username,
FlightReservationDetail = flightReservationDetail,
AirlineScored = false,
FlightScored = false,
};
if (passengerSeat.Username == "" || passengerSeat.Username == inviter.UserName)
{
passengerSeat.Accepted = true;
}
else
{
passengerSeat.Accepted = false;
}
_context.Entry(passengerSeat).State = EntityState.Added;
if (passengerSeat.Username != null && passengerSeat.Username != "" && passengerSeat.Username != inviter.UserName)
{
var user = await _userManager.FindByNameAsync(passengerSeat.Username);
flightReservation.FlightReservationDetails.ForEach(flightReservation => { user.NumberOfPoint += (int)Math.Round(flightReservation.Flight.Distance); });
await _userManager.UpdateAsync(user);
MailingService.SendEMailInvite(inviter, user, flightReservation, vehicle, tempFlightReservation.ReservationId);
}
Seat seat = await _context.Seats.FindAsync(passengerSeat.SeatId);
seat.Occupied = true;
_context.Entry(seat).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
await _context.SaveChangesAsync();
}
MailingService.SendEMailReceipt(inviter, flightReservation, vehicle);
return(Ok());
}
/// <summary>
/// Save NRT
/// </summary>
/// <param name="nrtVehicle"></param>
/// <returns></returns>
public long SaveNrt(NrtVehicle nrtVehicle)
{
NrtMain nrtMainDbVersion = nrtMainRepository.Find(nrtVehicle.NrtMainId);
RaStatus raStatus;
if (nrtVehicle.NrtMain.NrtStatusId == 2)
{
raStatus = raStatusRepository.FindByStatusKey(2);
}
else
{
raStatus = raStatusRepository.FindByStatusKey(1);
}
if (nrtMainDbVersion == null)
{
//NRT Main
nrtVehicle.NrtMain.IsActive = true;
nrtVehicle.NrtMain.IsDeleted =
nrtVehicle.NrtMain.IsPrivate = nrtVehicle.NrtMain.IsReadOnly = false;
nrtVehicle.NrtMain.RecLastUpdatedBy =
nrtVehicle.NrtMain.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
nrtVehicle.NrtMain.RecCreatedDt = nrtVehicle.NrtMain.RecLastUpdatedDt = DateTime.Now;
nrtVehicle.NrtMain.RowVersion = 0;
nrtVehicle.NrtMain.UserDomainKey = nrtMainRepository.UserDomainKey;
nrtVehicle.NrtMain.NrtStatusId = raStatus != null ? raStatus.RaStatusId : raStatus.RaStatusId;
nrtMainRepository.Add(nrtVehicle.NrtMain);
nrtMainRepository.SaveChanges();
//Vehicle Reservation
VehicleReservation vehicleReservation = new VehicleReservation();
vehicleReservation.IsActive = true;
vehicleReservation.IsDeleted =
vehicleReservation.IsPrivate = vehicleReservation.IsReadOnly = false;
vehicleReservation.RecLastUpdatedBy =
vehicleReservation.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
vehicleReservation.RecCreatedDt = vehicleReservation.RecLastUpdatedDt = DateTime.Now;
vehicleReservation.RowVersion = 0;
vehicleReservation.UserDomainKey = nrtMainRepository.UserDomainKey;
vehicleReservation.VehicleId = nrtVehicle.VehicleId;
vehicleReservation.StartDtTime = nrtVehicle.NrtMain.StartDtTime;
vehicleReservation.EndDtTime = nrtVehicle.NrtMain.EndDtTime;
vehicleReservation.NrtMainId = nrtVehicle.NrtMain.NrtMainId;
vehicleReservationRepository.Add(vehicleReservation);
vehicleReservationRepository.SaveChanges();
//NRT vehicle
nrtVehicle.IsActive = true;
nrtVehicle.IsDeleted =
nrtVehicle.IsPrivate = nrtVehicle.IsReadOnly = false;
nrtVehicle.RecLastUpdatedBy =
nrtVehicle.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
nrtVehicle.RecCreatedDt = nrtVehicle.RecLastUpdatedDt = DateTime.Now;
nrtVehicle.RowVersion = 0;
nrtVehicle.UserDomainKey = nrtMainRepository.UserDomainKey;
nrtVehicle.NrtVehicleId = nrtVehicle.VehicleId;
nrtVehicle.NrtMainId = nrtVehicle.NrtMain.NrtMainId;
//NRT Drivers
if (nrtVehicle.NrtDrivers != null)
{
foreach (var item in nrtVehicle.NrtDrivers)
{
item.IsActive = true;
item.IsDeleted = item.IsPrivate = item.IsReadOnly = false;
item.RecLastUpdatedBy = item.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
item.RecCreatedDt = item.RecLastUpdatedDt = DateTime.Now;
item.RowVersion = 0;
item.UserDomainKey = nrtMainRepository.UserDomainKey;
item.NrtVehicleId = nrtVehicle.NrtVehicleId;
//Chauffer Reservation
ChaufferReservation chaufferReservation = new ChaufferReservation();
chaufferReservation.IsActive = true;
chaufferReservation.IsDeleted =
chaufferReservation.IsPrivate = chaufferReservation.IsReadOnly = false;
chaufferReservation.RecLastUpdatedBy =
chaufferReservation.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
chaufferReservation.RecCreatedDt = chaufferReservation.RecLastUpdatedDt = DateTime.Now;
chaufferReservation.RowVersion = 0;
chaufferReservation.UserDomainKey = nrtMainRepository.UserDomainKey;
chaufferReservation.ChaufferId = (item.ChaufferId ?? 0);
chaufferReservation.StartDtTime = nrtVehicle.NrtMain.StartDtTime;
chaufferReservation.EndDtTime = nrtVehicle.NrtMain.EndDtTime;
chaufferReservation.NrtMainId = nrtVehicle.NrtMain.NrtMainId;
chaufferReservationRepository.Add(chaufferReservation);
chaufferReservationRepository.SaveChanges();
}
}
//NRT Vehicle movements
if (nrtVehicle.NrtVehicleMovements != null)
{
foreach (var item in nrtVehicle.NrtVehicleMovements)
{
item.IsActive = true;
item.IsDeleted = item.IsPrivate = item.IsReadOnly = false;
item.RecLastUpdatedBy = item.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
item.RecCreatedDt = item.RecLastUpdatedDt = DateTime.Now;
item.RowVersion = 0;
item.UserDomainKey = nrtMainRepository.UserDomainKey;
item.NrtVehicleId = nrtVehicle.NrtVehicleId;
item.VehicleCondition = "0011111";
}
}
//NRT Charges
if (nrtVehicle.NrtCharges != null)
{
foreach (var item in nrtVehicle.NrtCharges)
{
item.IsActive = true;
item.IsDeleted = item.IsPrivate = item.IsReadOnly = false;
item.RecLastUpdatedBy = item.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
item.RecCreatedDt = item.RecLastUpdatedDt = DateTime.Now;
item.RowVersion = 0;
item.UserDomainKey = nrtMainRepository.UserDomainKey;
item.NrtVehicleId = nrtVehicle.NrtVehicleId;
}
}
nrtVehicleRepository.Add(nrtVehicle);
nrtVehicleRepository.SaveChanges();
}
else
{
//NrtVehicle nrtVehicleDbVersion = nrtVehicleRepository.Find(nrtMainDbVersion.NrtMainId);
nrtMainDbVersion.CloseLocationId = nrtVehicle.NrtMain.CloseLocationId;
nrtMainDbVersion.EndDtTime = nrtVehicle.NrtMain.EndDtTime;
nrtMainDbVersion.NrtStatusId = raStatus.RaStatusId;
//Vehicle Reservation
if (nrtMainDbVersion.VehicleReservations != null)
{
foreach (var item in nrtMainDbVersion.VehicleReservations)
{
item.EndDtTime = nrtVehicle.NrtMain.EndDtTime;
}
}
if (nrtMainDbVersion.NrtVehicles != null)
{
foreach (var nrtVehicleDbVersion in nrtMainDbVersion.NrtVehicles)
{
#region NRT Drivers
if (nrtVehicle.NrtDrivers != null)
{
foreach (var item in nrtVehicle.NrtDrivers)
{
if (
nrtVehicleDbVersion.NrtDrivers.All(
x =>
x.NrtDriverId != item.NrtDriverId ||
item.NrtDriverId == 0))
{
item.IsActive = true;
item.IsDeleted = item.IsPrivate = item.IsReadOnly = false;
item.RecLastUpdatedBy = item.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
item.RecCreatedDt = item.RecLastUpdatedDt = DateTime.Now;
item.RowVersion = 0;
item.UserDomainKey = nrtMainRepository.UserDomainKey;
item.NrtVehicleId = nrtVehicle.NrtVehicleId;
nrtVehicleDbVersion.NrtDrivers.Add(item);
//Chauffer Reservation
ChaufferReservation chaufferReservation = new ChaufferReservation();
chaufferReservation.IsActive = true;
chaufferReservation.IsDeleted =
chaufferReservation.IsPrivate = chaufferReservation.IsReadOnly = false;
chaufferReservation.RecLastUpdatedBy =
chaufferReservation.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
chaufferReservation.RecCreatedDt = chaufferReservation.RecLastUpdatedDt = DateTime.Now;
chaufferReservation.RowVersion = 0;
chaufferReservation.UserDomainKey = nrtMainRepository.UserDomainKey;
chaufferReservation.ChaufferId = (item.ChaufferId ?? 0);
chaufferReservation.StartDtTime = nrtVehicle.NrtMain.StartDtTime;
chaufferReservation.EndDtTime = nrtVehicle.NrtMain.EndDtTime;
chaufferReservation.NrtMainId = nrtVehicle.NrtMain.NrtMainId;
chaufferReservationRepository.Add(chaufferReservation);
chaufferReservationRepository.SaveChanges();
}
}
}
//find missing items
List <NrtDriver> missingNrtDriverItems = new List <NrtDriver>();
foreach (NrtDriver dbversionNrtDriverItem in nrtVehicleDbVersion.NrtDrivers)
{
if (nrtVehicle.NrtDrivers != null && nrtVehicle.NrtDrivers.All(x => x.NrtDriverId != dbversionNrtDriverItem.NrtDriverId))
{
missingNrtDriverItems.Add(dbversionNrtDriverItem);
}
if (nrtVehicle.NrtDrivers == null)
{
missingNrtDriverItems.Add(dbversionNrtDriverItem);
}
}
//remove missing items
foreach (NrtDriver missingNrtDriverItem in missingNrtDriverItems)
{
NrtDriver dbVersionMissingItem = nrtVehicleDbVersion.NrtDrivers.First(x => x.NrtDriverId == missingNrtDriverItem.NrtDriverId);
if (dbVersionMissingItem.NrtDriverId > 0)
{
nrtVehicleDbVersion.NrtDrivers.Remove(dbVersionMissingItem);
nrtDriverRepository.Delete(dbVersionMissingItem);
nrtDriverRepository.SaveChanges();
}
}
#endregion
#region NRT Charges
if (nrtVehicle.NrtCharges != null)
{
foreach (var item in nrtVehicle.NrtCharges)
{
if (
nrtVehicleDbVersion.NrtCharges.All(
x =>
x.NrtChargeId != item.NrtChargeId ||
item.NrtChargeId == 0))
{
item.IsActive = true;
item.IsDeleted = item.IsPrivate = item.IsReadOnly = false;
item.RecLastUpdatedBy = item.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
item.RecCreatedDt = item.RecLastUpdatedDt = DateTime.Now;
item.RowVersion = 0;
item.UserDomainKey = nrtMainRepository.UserDomainKey;
item.NrtVehicleId = nrtVehicle.NrtVehicleId;
nrtVehicleDbVersion.NrtCharges.Add(item);
}
}
}
//find missing items
List <NrtCharge> missingNrtChargeItems = new List <NrtCharge>();
foreach (NrtCharge dbversionNrtChargeItem in nrtVehicleDbVersion.NrtCharges)
{
if (nrtVehicle.NrtCharges != null && nrtVehicle.NrtCharges.All(x => x.NrtChargeId != dbversionNrtChargeItem.NrtChargeId))
{
missingNrtChargeItems.Add(dbversionNrtChargeItem);
}
if (nrtVehicle.NrtCharges == null)
{
missingNrtChargeItems.Add(dbversionNrtChargeItem);
}
}
//remove missing items
foreach (NrtCharge missingNrtChargeItem in missingNrtChargeItems)
{
NrtCharge dbVersionMissingItem = nrtVehicleDbVersion.NrtCharges.First(x => x.NrtChargeId == missingNrtChargeItem.NrtChargeId);
if (dbVersionMissingItem.NrtChargeId > 0)
{
nrtVehicleDbVersion.NrtCharges.Remove(dbVersionMissingItem);
nrtChargeRepository.Delete(dbVersionMissingItem);
nrtChargeRepository.SaveChanges();
}
}
#endregion
//NRT Vehicle movements
if (nrtVehicleDbVersion.NrtVehicleMovements != null)
{
foreach (var vMovement in nrtVehicle.NrtVehicleMovements)
{
if (vMovement.MovementStatus)
{
bool flag = false;
foreach (var item in nrtVehicleDbVersion.NrtVehicleMovements)
{
if (item.MovementStatus)
{
flag = true;
item.DtTime = vMovement.DtTime;
item.FuelLevel = vMovement.FuelLevel;
item.Odometer = vMovement.Odometer;
item.OperationsWorkPlaceId = vMovement.OperationsWorkPlaceId;
item.VehicleStatusId = vMovement.VehicleStatusId;
item.VehicleCondition = "0011111";
}
}
//in case return vehicle new add
if (!flag)
{
vMovement.IsActive = true;
vMovement.IsDeleted = vMovement.IsPrivate = vMovement.IsReadOnly = false;
vMovement.RecLastUpdatedBy = vMovement.RecCreatedBy = nrtMainRepository.LoggedInUserIdentity;
vMovement.RecCreatedDt = vMovement.RecLastUpdatedDt = DateTime.Now;
vMovement.RowVersion = 0;
vMovement.UserDomainKey = nrtMainRepository.UserDomainKey;
vMovement.NrtVehicleId = nrtVehicle.NrtVehicleId;
vMovement.VehicleCondition = "0011111";
nrtVehicleDbVersion.NrtVehicleMovements.Add(vMovement);
}
}
}
}
}
nrtMainRepository.SaveChanges();
}
nrtVehicleRepository.SaveChanges();
}
return(nrtVehicle.NrtMain.NrtMainId);
}
