CreateReservation([FromBody] ReservationPostDto reservation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var availability = await _context.Availabilities
.Include(a => a.Reservation)
.Include(a => a.Venue)
.FirstOrDefaultAsync(
a => a.Date == reservation.EventDate &&
a.VenueCode == reservation.VenueCode);
if (availability == null || availability.Reservation != null)
{
return(BadRequest("Venue is not available on the requested date."));
}
availability.Reservation = new Reservation
{
Reference = $"{availability.VenueCode}{availability.Date:yyyyMMdd}",
EventDate = availability.Date,
VenueCode = availability.VenueCode,
WhenMade = DateTime.Now,
StaffId = reservation.StaffId
};
await _context.SaveChangesAsync();
return(CreatedAtAction("GetReservation",
new { reference = availability.Reservation.Reference },
ReservationGetDto.FromModel(availability.Reservation)));
}
//POST: Events/ReserveVenue/5
public async Task <IActionResult> ConfirmReservation(int id, string VenueCode, int StaffId)
{
var @event = await _context.Events
.FirstOrDefaultAsync(m => m.Id == id);
if (@event == null)
{
return(NotFound());
}
if (@event.VenueCode != null)
{
HttpClient client1 = new HttpClient();
var VenueBuilder = new UriBuilder("http://localhost");
VenueBuilder.Port = 23652;
VenueBuilder.Path = "api/Reservations/" + @event.VenueCode;
client1.DefaultRequestHeaders.Accept.ParseAdd("application/json");
string url = VenueBuilder.ToString();
HttpResponseMessage response1 = await client1.DeleteAsync(url);
if (response1.IsSuccessStatusCode)
{
@event.VenueCode = null;
_context.Update(@event);
await _context.SaveChangesAsync();
}
}
HttpClient client = new HttpClient();
client.BaseAddress = new System.Uri("http://localhost:23652");
client.DefaultRequestHeaders.Accept.ParseAdd("application/json");
ReservationPostDto req = new ReservationPostDto
{
EventDate = @event.Date,
VenueCode = VenueCode,
StaffId = StaffId
};
HttpResponseMessage response = await client.PostAsJsonAsync("api/Reservations", req);
if (response.IsSuccessStatusCode)
{
var Reservation = await response.Content.ReadAsAsync <ReservationGetDto>();
@event.VenueCode = Reservation.Reference;
_context.Update(@event);
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> BookEvent([Bind("Id,VenueRef,Date,VenueName,VenueDescription,VenueCapacity,VenueCost,Title,Duration,TypeId,Type,Existing,OldRef")] EventVM booking)
{
var client = setupVenueClient();
string uri = "/api/Reservations";
string uriOldRef = uri + "/" + booking.OldRef;
ReservationPostDto res = new ReservationPostDto(booking.Date, booking.VenueRef);
try
{
if ((await client.GetAsync(uriOldRef)).IsSuccessStatusCode)
{
var deleteResponse = await client.DeleteAsync(uriOldRef);
deleteResponse.EnsureSuccessStatusCode();
}
var postResponse = await client.PostAsJsonAsync(uri, res);
postResponse.EnsureSuccessStatusCode();
if (booking.Existing) // need the ID!
{
var @event = await _context.Events.FindAsync(booking.Id);
@event.Title = booking.Title;
@event.Duration = booking.Duration;
@event.VenueRef = booking.VenueRef;
@event.VenueName = booking.VenueName;
@event.VenueDescription = booking.VenueDescription;
@event.VenueCapacity = booking.VenueCapacity;
@event.VenueCost = booking.VenueCost;
await _context.SaveChangesAsync();
}
else
{
// all relevant venue data saved locally to prevent the alternative of having to query the API constantly to display venue information
Event @event = new Event();
@event.Date = booking.Date;
@event.Title = booking.Title;
@event.Duration = booking.Duration;
@event.TypeId = booking.TypeId;
@event.Type = booking.Type;
@event.VenueRef = booking.VenueRef;
@event.VenueName = booking.VenueName;
@event.VenueDescription = booking.VenueDescription;
@event.VenueCapacity = booking.VenueCapacity;
@event.VenueCost = booking.VenueCost;
_context.Add(@event);
await _context.SaveChangesAsync();
}
}
catch (Exception)
{
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> BookVenue(int?eventId, string venueCode, string staffId)
{
if (eventId == null || venueCode == null || staffId == null)
{
return(BadRequest());
}
HttpClient client = getClient("23652");
var @event = await _context.Events.FindAsync(eventId);
HttpResponseMessage getAvailability = await client.GetAsync("api/Availability?eventType=" + @event.TypeId
+ "&beginDate=" + @event.Date.ToString("yyyy/MM/dd")
+ "&endDate=" + @event.Date.ToString("yyyy/MM/dd"));
var availability = await getAvailability.Content.ReadAsAsync <IEnumerable <availabilityDto> >();
decimal venueCost = (decimal)availability.FirstOrDefault().costPerHou;
@event.VenueCost = venueCost * @event.Duration.Value.Hours;
@event.VenueReference = availability.FirstOrDefault().name;
_context.Update(@event);
await _context.SaveChangesAsync();
DateTime eventDate = @event.Date;
ReservationPostDto reservation = new ReservationPostDto();
reservation.EventDate = eventDate;
reservation.StaffId = staffId;
reservation.VenueCode = venueCode;
string reference = venueCode + eventDate.ToString("yyyyMMdd");
HttpResponseMessage delete = await client.DeleteAsync("api/reservations/" + reference);
HttpResponseMessage post = await client.PostAsJsonAsync("api/reservations", reservation);
if (post.IsSuccessStatusCode)
{
HttpResponseMessage getReservation = await client.GetAsync("api/reservations/" + reference);
var x = await getReservation.Content.ReadAsAsync <Event>();
return(View("Reservation", x));
}
else
{
return(RedirectToAction(nameof(BookVenue), eventId));
}
}
public async Task <IActionResult> BookVenuePost([Bind("EventId,VenueCode,VenueName")] VenuesViewModel postVenue)
{
if (ModelState.IsValid)
{
try
{
var @event = await _dataAccess.GetEvents().FirstOrDefaultAsync(e => e.Id == postVenue.EventId);
if (@event == null)
{
return(NotFound());
}
if (@event.ReservationRef != null)
{
var r = await _venuesClient.DeleteReservation(@event);
}
ReservationPostDto postReservation = new ReservationPostDto
{
VenueCode = postVenue.VenueCode,
StaffId = "s",
EventDate = @event.Date,
};
var reserveVenue = await _venuesClient.AddReservation(postReservation);
@event.ReservationRef = reserveVenue.Reference;
@event.VenueName = postVenue.VenueName;
_context.Update(@event);
await _context.SaveChangesAsync();
}
catch
{
if (!EventExists(postVenue.EventId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(postVenue));
}
public async Task <IActionResult> ReserveVenueConfirm(int id, [Bind("Title,Date,Duration,TypeId,venues")] reserveVenueModel model)
{
HttpClient client = new HttpClient();
client.BaseAddress = new System.Uri("http://localhost:23652/");
client.DefaultRequestHeaders.Accept.ParseAdd("application/json");
var reserve = new ReservationPostDto
{
EventDate = model.Date,
//VenueCode = model.Venues. ,
StaffId = "1"
};
HttpResponseMessage response = await client.PostAsJsonAsync("api/reservations", reserve);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
EventVM eventVM = new EventVM(await _context.Events.FindAsync(id));
var client = setupVenueClient();
string uri = "/api/Reservations/" + eventVM.getBookingRef;
ReservationPostDto res = new ReservationPostDto(eventVM.Date, eventVM.VenueRef);
try
{
if ((await client.GetAsync(uri)).IsSuccessStatusCode)
{
var deleteResponse = await client.DeleteAsync(uri);
deleteResponse.EnsureSuccessStatusCode();
}
}
catch (Exception)
{
}
List <StaffingVM> staffings = new List <StaffingVM>();
var staffData = await _context.Staffing.Where(s => s.EventId == id).ToListAsync();
foreach (Staffing s in staffData)
{
staffings.Add(new StaffingVM(s));
}
foreach (StaffingVM s in staffings)
{
var staffing = await _context.Staffing.FindAsync(s.StaffId, s.EventId);
_context.Staffing.Remove(staffing);
await _context.SaveChangesAsync();
}
var @event = await _context.Events.FindAsync(id);
@event.IsActive = false;
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> ReserveVenue(int EventId, DateTime EventDate, string VenueCode)
{
if (EventDate == null || VenueCode == null)
{
return(NotFound());
}
var curEvent = await _context.Events
.FirstOrDefaultAsync(m => m.Id == EventId);
if (curEvent == null)
{
return(BadRequest());
}
HttpClient client = new HttpClient();
client.BaseAddress = new System.Uri("http://localhost:23652/");
var reservation = new ReservationPostDto
{
EventDate = EventDate,
VenueCode = VenueCode,
};
if (!String.IsNullOrEmpty(curEvent.VenueCode))
{
var reference = curEvent.VenueCode + EventDate.ToString("yyyy-MM-dd");
await client.DeleteAsync("api/reservations/" + reference);
}
curEvent.VenueCode = reservation.VenueCode;
_context.Update(curEvent);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <ReservationGetDto> CreateReservation(DateTime eventDate, string venueCode)
{
EnsureClient();
ReservationPostDto reservationDetails = new ReservationPostDto()
{
EventDate = eventDate,
StaffId = "1",
VenueCode = venueCode
};
ReservationGetDto reservation;
try {
var response = await _client.PostAsJsonAsync("api/reservations", reservationDetails);
response.EnsureSuccessStatusCode();
reservation = await response.Content.ReadAsAsync <ReservationGetDto>();
} catch (HttpRequestException ex)
{
_logger.LogError("Caught an error when creating a reservation. Exception: " + ex);
reservation = new ReservationGetDto();
}
return(reservation);
}
//To actually reserve a venue with check for if a venue is already booked.
//Done this way as i have the best udnerstanding of this method and i feel it allows for easier checking when attempting to reserve the venue.
public async Task <ActionResult> Reservations(int id, string reservations)
{
//Checks if the vent is valid.
var @event = await _context.Events.FirstOrDefaultAsync(a => a.Id == id);
if (@event == null)
{
return(BadRequest());
}
if (@event.reservations != null)
{
//Builds the url to find the avlability table in the venues project, this time filtering based on the reservation.
HttpClient clientWhenDeletingFirst = new HttpClient();
var RequestBuilder = new UriBuilder("http://localhost");
RequestBuilder.Port = 23652;
RequestBuilder.Path = "api/Reservations/" + @event.reservations;
String url = RequestBuilder.ToString();
clientWhenDeletingFirst.DefaultRequestHeaders.Accept.ParseAdd("application/json");
HttpResponseMessage responseWhenDeleting = await clientWhenDeletingFirst.DeleteAsync(url);
if (!responseWhenDeleting.IsSuccessStatusCode)
{
//If failed then displays an error.
ModelState.AddModelError("", "Previous reservation could not be removed.");
return(RedirectToAction(nameof(Index), "Events"));
}
//Updates the reservations.
@event.reservations = null;
_context.Update(@event);
await _context.SaveChangesAsync();
}
var client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:23652");
client.DefaultRequestHeaders.Accept.ParseAdd("application/json");
//client.Timeout = TimeSpan.FromSeconds(5);
//USes the post model using the data passed.
ReservationPostDto reg = new ReservationPostDto
{
EventDate = @event.Date,
VenueCode = reservations,
StaffId = "staff"
};
//Checks if the response is successful and if it is then it updates the database.
HttpResponseMessage response = await client.PostAsJsonAsync("api/Reservations", reg);
if (response.IsSuccessStatusCode)
{
var isSuccess = await response.Content.ReadAsAsync <ReservationGetDto>();
@event.reservations = isSuccess.Reference;
_context.Update(@event);
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index), "Events"));
}
public async Task <IActionResult> Reserve(int id, string venueRef)
{
var @event = await _context.Events.FirstOrDefaultAsync(m => m.Id == id);
if (@event == null)
{
return(BadRequest());
}
if (@event.venueRef != null)
{
HttpClient venueClient = new HttpClient();
var builder = new UriBuilder("http://localhost");
builder.Port = 23652;
builder.Path = "api/Reservations/" + @event.venueRef;
string url = builder.ToString();
venueClient.DefaultRequestHeaders.Accept.ParseAdd("application/json");
var venuesResponse = await venueClient.DeleteAsync(url);
if (!venuesResponse.IsSuccessStatusCode)
{
ModelState.AddModelError("", "Service unavailable");
return(RedirectToAction(nameof(ReserveVenue), @event.Id));
}
@event.venueRef = null;
_context.Update(@event);
await _context.SaveChangesAsync();
}
HttpClient client = new HttpClient();
client.BaseAddress = new System.Uri("http://localhost:23652");
client.DefaultRequestHeaders.Accept.ParseAdd("application/json");
var request = new ReservationPostDto
{
EventDate = @event.Date,
VenueCode = venueRef,
StaffId = "TODO"
};
var response = await client.PostAsJsonAsync("api/Reservations", request);
if (!response.IsSuccessStatusCode)
{
ModelState.AddModelError("", "Service unavailable");
return(RedirectToAction(nameof(ReserveVenue), @event.Id));
}
var reservationInfo = await response.Content.ReadAsAsync <ReservationGetDto>();
@event.venueRef = reservationInfo.Reference;
_context.Update(@event);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
/// <summary>
/// Reserving a venue for and event
/// </summary>
/// <param name="eventId"></param>
/// <param name="venueCode"></param>
/// <param name="staffId"></param>
/// <returns></returns>
public async Task <IActionResult> ReserveVenue(int?eventId, string venueCode, string staffId)
{
if (eventId == null || venueCode == null || staffId == null)
{
return(BadRequest());
}
var @event = await _context.Events.FindAsync(eventId);
HttpClient client = new HttpClient();
client.BaseAddress = new System.Uri("http://localhost:23652");
client.DefaultRequestHeaders.Accept.ParseAdd("application/json");
HttpResponseMessage getAvailability = await client.GetAsync("api/Availability?eventType=" + @event.TypeId
+ "&beginDate=" + @event.Date.ToString("yyyy/MM/dd")
+ "&endDate=" + @event.Date.ToString("yyyy/MM/dd"));
var availability = await getAvailability.Content.ReadAsAsync <IEnumerable <AvailableVenues> >();
decimal venueCost = (decimal)availability.FirstOrDefault(r => r.Code == venueCode).CostPerHour;
@event.VenueCost = venueCost * @event.Duration.Value.Hours;
@event.Venue = availability.FirstOrDefault(r => r.Code == venueCode).Name;
_context.Update(@event);
await _context.SaveChangesAsync();
DateTime eventDate = @event.Date;
ReservationPostDto reservation = new ReservationPostDto();
reservation.EventDate = eventDate;
reservation.StaffId = staffId;
reservation.VenueCode = venueCode;
@event.Description = availability.FirstOrDefault(r => r.Code == venueCode).Description;
@event.Capacity = availability.FirstOrDefault(r => r.Code == venueCode).Capacity;
@event.WhenMade = reservation.EventDate;
if (@event.Reference != null)
{
HttpResponseMessage delete = await client.DeleteAsync("api/reservations/" + @event.Reference);
}
@event.Reference = reservation.VenueCode + reservation.EventDate.ToString("yyyyMMdd");
_context.Update(@event);
await _context.SaveChangesAsync();
HttpResponseMessage post = await client.PostAsJsonAsync("api/reservations", reservation);
if (post.IsSuccessStatusCode)
{
HttpResponseMessage getReservation = await client.GetAsync("api/reservations/" + @event.Reference);
var getres = await getReservation.Content.ReadAsAsync <ReservationViewModel>();
return(View("Reservation", getres));
}
else
{
return(RedirectToAction(nameof(Details), eventId));
}
}
public async Task <IActionResult> GetVenues(int?id, string toReserve)
{
if (id == null)
{
return(NotFound());
}
var @event = await _context.Events
.FirstOrDefaultAsync(m => m.Id == id);
if (@event == null)
{
return(NotFound());
}
if (toReserve == null)
{
return(RedirectToAction("GetVenues", new { id }));
}
HttpClient client = new HttpClient();
client.BaseAddress = new System.Uri("http://localhost:23652");
client.DefaultRequestHeaders.Accept.ParseAdd("application/json");
var uri = "/api/reservations/";
if (@event.Reference == null)
{
var reservedPost = new ReservationPostDto
{
EventDate = @event.Date,
VenueCode = toReserve,
StaffId = "NULL"
};
if (reservedPost.VenueCode == null || reservedPost.StaffId == null)
{
return(RedirectToAction(nameof(Index)));
}
HttpResponseMessage response = await client.PostAsJsonAsync(uri, reservedPost);
if (response.IsSuccessStatusCode)
{
@event.Reference = $"{toReserve}{@event.Date:yyyyMMdd}";
_context.Update(@event);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
throw new Exception();
}
}
else
{
if (@event.Reference != $"{toReserve}{@event.Date:yyyyMMdd}")
{
var referenceDelete = @event.Reference;
HttpResponseMessage responseDelete = await client.DeleteAsync(uri + referenceDelete);
if (responseDelete.IsSuccessStatusCode)
{
var reservedPost = new ReservationPostDto
{
EventDate = @event.Date,
VenueCode = toReserve,
StaffId = "NULL"
};
HttpResponseMessage response = await client.PostAsJsonAsync(uri, reservedPost);
if (response.IsSuccessStatusCode)
{
@event.Reference = $"{toReserve}{@event.Date:yyyyMMdd}";
_context.Update(@event);
await _context.SaveChangesAsync();
RedirectToAction(nameof(Index));
}
else
{
throw new Exception();
}
}
}
}
return(RedirectToAction(nameof(Index)));
}
