public async Task <StatusCode> Delete(PassengerSeat entity)
{
var seat = await PassengerSeat.GetById(entity.Id);
if (seat != null)
{
await PassengerSeat.Delete(entity.Id);
return(StatusCode.Deleted);
}
return(StatusCode.DoesNotExist);
}
public async Task <StatusCode> Update(PassengerSeat entity)
{
var seat = await PassengerSeat.GetById(entity.Id);
if (seat != null)
{
Validation(entity);
await PassengerSeat.Update(entity.ToEntity());
return(StatusCode.Updated);
}
return(StatusCode.DoesNotExist);
}
private static void Can_MessageReceived(CanAdapter can, CanMessage message)
{
switch (message.ArbitrationId)
{
case 0x232:
DriverSeat.ParseStatusMessage(message);
break;
case 0x22A:
PassengerSeat.ParseStatusMessage(message);
break;
}
}
public TOPassengerSeat(PassengerSeat passengerSeat, DatabaseContext _context, int id)
{
PassengerSeatId = passengerSeat.PassengerSeatId;
FlightReservationDetailId = passengerSeat.FlightReservationDetail.FlightReservationDetailId;
Seat = new TOSeat(_context.Seats.Find(passengerSeat.SeatId));
Seat.FlightId = id;
Username = passengerSeat.Username;
Name = passengerSeat.Name;
Surname = passengerSeat.Surname;
Passport = passengerSeat.Passport;
Accepted = passengerSeat.Accepted;
AirlineScored = passengerSeat.AirlineScored;
FlightScored = passengerSeat.FlightScored;
}
public async Task <StatusCode> Create(PassengerSeat entity)
{
Validation(entity);
var passengerSeats = await PassengerSeat.GetById(entity.Id);
var isExist = passengerSeats != null;
if (isExist)
{
return(StatusCode.AlreadyExists);
}
await PassengerSeat.Create(entity.ToEntity());
return(StatusCode.Created);
}
private void Validation(PassengerSeat entity)
{
var validator = new Validator <PassengerSeat>();
}
public async Task <ActionResult <FlightReservation> > PostFlightReservation(TOFlightReservation flightReservation, int points)
{
TOFlight tempFlight = new TOFlight();
string userId = User.Claims.First(c => c.Type == "UserID").Value;
string username = User.Claims.First(c => c.Type == "Username").Value;
Common.Models.AppUser inviter = null;
using (HttpClient client = new HttpClient())
{
var httpRequest = new HttpRequestMessage(HttpMethod.Get,
"http://usermicroservice/api/AppUsers/GetUser/" + username);
HttpResponseMessage message = await client.SendAsync(httpRequest);
var temp = await message.Content.ReadAsStringAsync();
inviter = JsonSerializer.Deserialize <Common.Models.AppUser>(temp);
}
Common.Models.VehicleForEmail vehicle = null;
if (flightReservation.VehicleReservationId != 0)
{
using (HttpClient client = new HttpClient())
{
var httpRequest = new HttpRequestMessage(HttpMethod.Get,
"http://rentacarmicroservice/api/VehicleReservations/Vehicle/" + flightReservation.VehicleReservationId);
HttpResponseMessage message = await client.SendAsync(httpRequest);
var temp = await message.Content.ReadAsStringAsync();
vehicle = JsonSerializer.Deserialize <Common.Models.VehicleForEmail>(temp);
}
}
FlightReservation tempFlightReservation = new FlightReservation()
{
ReservationId = 0,
TimeOfCreation = DateTime.Now,
Creator = ((Common.Models.AppUser)inviter).UserName,
VehicleReservationId = flightReservation.VehicleReservationId,
FinalPrice = flightReservation.FinalPrice
};
flightReservation.FlightReservationDetails.ForEach(flightReservation => { ((Common.Models.AppUser)inviter).NumberOfPoint += (int)Math.Round(flightReservation.Flight.Distance); });
((Common.Models.AppUser)inviter).NumberOfPoint -= points;
using (var client = new HttpClient())
{
Common.Models.PointsClass p = new Common.Models.PointsClass {
Id = inviter.Id, Points = inviter.NumberOfPoint
};
client.BaseAddress = new Uri("http://usermicroservice/");
await client.PutAsJsonAsync("api/AppUsers/UpdatePoints", p);
}
_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 == ((Common.Models.AppUser)inviter).UserName)
{
passengerSeat.Accepted = true;
}
else
{
passengerSeat.Accepted = false;
}
_context.Entry(passengerSeat).State = EntityState.Added;
if (passengerSeat.Username != null && passengerSeat.Username != "" && passengerSeat.Username != ((Common.Models.AppUser)inviter).UserName)
{
Common.Models.AppUser user = null;
using (HttpClient client = new HttpClient())
{
var httpRequest = new HttpRequestMessage(HttpMethod.Get,
"http://usermicroservice/api/AppUsers/GetUser/" + passengerSeat.Username);
HttpResponseMessage message = await client.SendAsync(httpRequest);
var temp = await message.Content.ReadAsStringAsync();
user = JsonSerializer.Deserialize <Common.Models.AppUser>(temp);
}
MailingService.SendEMailInvite(((Common.Models.AppUser)inviter), (Common.Models.AppUser)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(((Common.Models.AppUser)inviter), flightReservation, vehicle);
return(Ok());
}
public static PassengerSeatEntity ToEntity(this PassengerSeat model) => Mapper.Map <PassengerSeatEntity>(model);
public static PassengerSeatViewModel ToViewModel(this PassengerSeat model) => Mapper.Map <PassengerSeatViewModel>(model);
public async Task <IActionResult> PutFastTicket(int id, [FromBody] JObject Obj, [FromQuery] int version)
{
TOFastTicket fastTicket = Obj["fastTicket"].ToObject <TOFastTicket>();
bool occupied = Obj["occupied"].ToObject <bool>();
if (id != fastTicket.Seat.SeatId)
{
return(BadRequest());
}
Flight tempFlight = await _context.Flights.FindAsync(fastTicket.Seat.FlightId);
var success = false;
if (tempFlight.Version != version)
{
return(Ok(new { success }));
}
tempFlight.Version++;
_context.Entry(tempFlight).State = EntityState.Modified;
FastTicket tempFastTicket = await _context.FastTickets.FindAsync(fastTicket.Seat.SeatId);
Seat seat = await _context.Seats.Include(seat => seat.Flight).ThenInclude(flight => flight.Airline).FirstAsync(seat => seat.SeatId == fastTicket.Seat.SeatId);
seat.Occupied = occupied;
_context.Entry(seat).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
string userId = User.Claims.First(c => c.Type == "UserID").Value;
var user = await _userManager.FindByIdAsync(userId);
if (occupied == true)
{
FlightReservation flightReservation = new FlightReservation()
{
ReservationId = 0,
Creator = user.UserName,
FinalPrice = fastTicket.NewPrice,
TimeOfCreation = DateTime.Now,
VehicleReservationId = 0
};
FlightReservationDetail flightReservationDetail = new FlightReservationDetail()
{
FlightReservation = flightReservation,
AirlineName = seat.Flight.Airline.Name,
FlightReservationDetailId = 0,
FlightId = seat.Flight.FlightId
};
PassengerSeat passengerSeat = new PassengerSeat()
{
PassengerSeatId = 0,
FlightReservationDetail = flightReservationDetail,
SeatId = seat.SeatId,
Username = user.UserName,
Accepted = true,
AirlineScored = false,
FlightScored = false,
Name = "",
Surname = "",
Passport = ""
};
flightReservationDetail.PassengerSeats = new List <PassengerSeat>();
flightReservationDetail.PassengerSeats.Add(passengerSeat);
flightReservation.FlightReservationDetails = new List <FlightReservationDetail>();
flightReservation.FlightReservationDetails.Add(flightReservationDetail);
_context.FlightReservations.Add(flightReservation);
_context.FastTickets.Remove(tempFastTicket);
await _context.SaveChangesAsync();
}
}
catch (DbUpdateConcurrencyException)
{
if (!FastTicketExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
success = true;
return(Ok(new { success }));
}
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());
}
