public async Task <ActionResult <Viewing> > PostViewing(Viewing viewing)
{
_context.Viewings.Add(viewing);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetViewing", new { id = viewing.ViewingId }, viewing));
}
public async Task <IActionResult> PutViewing(int id, [FromBody] Viewing viewing)
{
if (id != viewing.ViewingId)
{
return(BadRequest());
}
_context.Entry(viewing).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ViewingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Switches to the first view that has something the user can actually select in it.
/// </summary>
/// <returns></returns>
private Viewing ShowChoosableView()
{
Viewing startingView = mViewing;
bool hasChoosable = false;
while (!hasChoosable)
{
foreach (Item item in Items)
{
if (IsChoosable(item))
{
hasChoosable = true;
break;
}
}
// try the next view
if (!hasChoosable)
{
SwitchView();
// bail if we wrapped around
if (mViewing == startingView)
{
break;
}
}
}
return(mViewing);
}
private void SetView(Choosing choosing, Viewing view)
{
bool changed = false;
if (mChoosing != choosing)
{
mChoosing = choosing;
if (choosing == Choosing.Nothing)
{
Screen.Focus(null);
}
else
{
Screen.Focus(this);
}
changed = true;
}
if (mViewing != view)
{
mViewing = view;
changed = true;
}
if (changed)
{
Repaint();
}
}
public async Task <IActionResult> ViewingActivity(int?id)
{
if (id == null)
{
return(NotFound());
}
var activeProfile = await Context.UserProfiles.FirstOrDefaultAsync(i => i.IsActive == true);
var video = await Context.Videos.FirstOrDefaultAsync(v => v.VideoId == id);
var profileActivity = new Viewing
{
DateView = DateTime.Now,
UserProfile = activeProfile,
UserProfileId = activeProfile.UserProfileId,
Video = video,
VideoId = video.VideoId
};
Context.Viewings.Add(profileActivity);
Context.SaveChanges();
return(RedirectToAction("VideoDetails", "Video", new { id = video.VideoId }));
}
public void Handle(BookViewingCommand command, string buyerId)
{
var property = _context.Properties.Find(command.PropertyId);
if (property != null)
{
DateTime requestedDateTime = new DateTime(command.RequestedDate.Year,
command.RequestedDate.Month,
command.RequestedDate.Day,
command.RequestedTime.Hour,
command.RequestedTime.Minute,
0);
var viewing = new Viewing
{
RequestedDateTime = requestedDateTime,
BuyerUserId = buyerId
};
if (property.Viewings == null)
{
property.Viewings = new List <Viewing>();
}
property.Viewings.Add(viewing);
_context.SaveChanges();
}
}
public async Task <IActionResult> Edit(int id, [Bind("ViewNo,ClientId,PropertyId,ViewDate,Comment")] Viewing viewing)
{
if (id != viewing.ViewNo)
{
return(NotFound());
}
if (ModelState.IsValid)
{
int result = await _service.Edit(id, viewing);
if (result == 0)
{
ViewData["BackController"] = "Viewings";
ViewData["BackAction"] = "Index";
ViewData["ErrorMessage"] = "Entity which you tried to modify doesn't exist anymore";
return(View("DbUpdateError"));
}
return(RedirectToAction("Index"));
}
ViewData["ClientId"] = new SelectList(_service.Clients(), "ClientId", "ClientPassportNo", viewing.ClientId);
ViewData["PropertyId"] = new SelectList(_service.Properties(), "PropertyId", "PropertyNo", viewing.PropertyId);
return(View(viewing));
}
public async Task <int> Update(Viewing viewing)
{
var viewingToModify = _context.Viewings.Find(viewing.ID);
viewingToModify.StartDate = viewing.StartDate;
viewingToModify.EndDate = viewing.EndDate;
viewingToModify.UpdatedDate = viewing.UpdatedDate;
viewingToModify.UserUpdatorId = viewing.UserUpdatorId;
viewingToModify.IsActive = viewing.IsActive;
viewingToModify.ViewingHost =
await _context.siteUsers.FirstOrDefaultAsync
(u => u.ID == viewing.ViewingHost.ID);
viewingToModify.Customer =
await _context.Customers.FirstOrDefaultAsync
(u => u.ID == viewing.Customer.ID);
viewingToModify.Listing =
await _context.Listing.FirstOrDefaultAsync
(u => u.ID == viewing.Listing.ID);
var entry = _context.Entry(viewingToModify);
entry.State = EntityState.Modified;
return(await _context.SaveChangesAsync());
}
public void Handle(RequestViewingCommand command)
{
var property = _context.Properties.Find(command.PropertyId);
DateTime viewingDateTime = default(DateTime);
DateTime.TryParseExact(string.Format("{0} {1}", command.ViewingDate, command.ViewingTime), "dd/MM/yyyy HH:mm",
CultureInfo.InvariantCulture, DateTimeStyles.None, out viewingDateTime);
var viewing = new Viewing
{
RequestDate = viewingDateTime,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
RequestUserId = command.RequestedUserId
};
if (property.Viewings == null)
{
property.Viewings = new List <Viewing>();
}
property.Viewings.Add(viewing);
_context.SaveChanges();
}
public IHttpActionResult PutViewing(int id, Viewing viewing)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != viewing.ViewingID)
{
return(BadRequest());
}
db.Entry(viewing).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ViewingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,SeatsLeft,Time,MovieID,AuditoriumID")] Viewing viewing)
{
if (id != viewing.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(viewing);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ViewingExists(viewing.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AuditoriumID"] = new SelectList(_context.Auditoriums, "ID", "ID", viewing.AuditoriumID);
ViewData["MovieID"] = new SelectList(_context.Movies, "ID", "ID", viewing.MovieID);
return(View(viewing));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Notes,PersonID,RealEstateID,ViewDate,ViewTime,ViewingType")] Viewing viewing)
{
if (id != viewing.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(viewing);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ViewingExists(viewing.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
ViewData["ViewingTypes"] = new SelectList(new[] { "Single", "Block" });
ViewData["Members"] = new SelectList(_context.Persons, "ID", "FullName");
ViewData["RealEstateIDs"] = new SelectList(_context.RealEstates, "ID", "AddressLine1");
return(View(viewing));
}
public async Task <ActionResult> Create(ViewingViewModel model)
{
if (ModelState.IsValid)
{
try
{
if (model.ListingId == 0)
{
model = await GetDefaultViewModelEntry();
model.PickedListingPostalCode = "No Listing is Picked";
ModelState.AddModelError(string.Empty, "Please pick a Listing");
return(View(model));
}
var modelState = ModelState;
var viewingToCreate = new Viewing();
viewingToCreate = await _viewingService
.GetViewingFromViewModel(model);
if (await _viewingService.IsViewingValid
(viewingToCreate, ModelState))
{
var currentLoggedUserId = User.Identity.GetUserId();
var currentLoggedUserRes = await UserIdentityManager
.GetUserById(currentLoggedUserId);
viewingToCreate.CreatedDate = DateTime.Now;
viewingToCreate.UpdatedDate = DateTime.Now;
viewingToCreate.UserCreatorId =
currentLoggedUserRes.registeredUser.ID;
viewingToCreate.UserUpdatorId =
currentLoggedUserRes.registeredUser.ID;
viewingToCreate.IsActive = true;
var result = await _viewingRepo.Create
(viewingToCreate);
return(RedirectToAction("Index"));
}
else
{
model = await GetDefaultViewModelEntry();
return(View(model));
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
}
}
return(View(model));
}
public Viewing GetViewingById(int id)
{
Viewing viewing = _context.Viewings.Include("Movie").Include("Salon").FirstOrDefault(v => v.ViewingId == id);
viewing.FormatedStartTime = viewing.StartTime.ToString("dddd HH:mm");
return(viewing);
}
public bool CreateViewing(Viewing viewing)
{
_context.Viewings.Add(viewing);
_context.SaveChanges();
_context.Entry(viewing).Reference(v => v.Movie).Load();
viewing.Movie.IsPlaying = true;
_context.SaveChanges();
return(true);
}
public async Task <IActionResult> BookingConfirmation(Viewing viewing)
{
var salon = await _context.SalonList.Where(s => s.Id == viewing.SalonId).ToListAsync();
viewing.Salon = salon[0];
var receipt = viewing;
return(View(receipt));
}
public async Task <int> Create(Viewing viewing)
{
using (var context = new ApplicationDbContext())
{
context.Viewings.Attach(viewing);
context.Viewings.Add(viewing);
return(await context.SaveChangesAsync());
}
}
public IHttpActionResult GetViewing(int id)
{
Viewing viewing = db.Viewings.Find(id);
if (viewing == null)
{
return(NotFound());
}
return(Ok(viewing));
}
public IActionResult CreateViewing(int movieId, int salonId, DateTime startTime)
{
var viewing = new Viewing {
MovieId = movieId, SalonId = salonId, StartTime = startTime
};
sqlTheaterData.CreateViewing(viewing);
TempData["Message"] = "Viewing was successfully added";
return(RedirectToAction("Index"));
}
public IHttpActionResult PostViewing(Viewing viewing)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Viewings.Add(viewing);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = viewing.ViewingID }, viewing));
}
public void Handle(BookViewingCommand command)
{
var viewvg = new Viewing
{
Date = command.DateV,
PropertyId = command.PropertyId,
VisitorId = command.VisitorId
};
_context.Viewings.Add(viewvg);
_context.SaveChanges();
}
public async Task <IActionResult> Create([Bind("ID,SeatsLeft,Time,MovieID,AuditoriumID")] Viewing viewing)
{
if (ModelState.IsValid)
{
_context.Add(viewing);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["AuditoriumID"] = new SelectList(_context.Auditoriums, "ID", "ID", viewing.AuditoriumID);
ViewData["MovieID"] = new SelectList(_context.Movies, "ID", "ID", viewing.MovieID);
return(View(viewing));
}
public async Task <IActionResult> Create([Bind("ID,Notes,PersonID,RealEstateID,ViewDate,ViewTime,ViewingType")] Viewing viewing)
{
if (ModelState.IsValid)
{
_context.Add(viewing);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewData["ViewingTypes"] = new SelectList(new[] { "Single", "Block" });
ViewData["Members"] = new SelectList(_context.Persons, "ID", "FullName");
ViewData["RealEstateIDs"] = new SelectList(_context.RealEstates, "ID", "AddressLine1");
return(View(viewing));
}
public async Task <IActionResult> Book(int id, [Bind("ID,SeatsLeft,Time,MovieID,AuditoriumID")] Viewing viewing)
{
int tickets = 0;
if (id != viewing.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
int NewSeats = (from s in _context.Viewings where s.ID == id select s.SeatsLeft).First() - viewing.SeatsLeft;
if (viewing.SeatsLeft > 0 && viewing.SeatsLeft <= 12)
{
if (NewSeats >= 0)
{
try
{
tickets = viewing.SeatsLeft;
viewing.SeatsLeft = NewSeats;
_context.Update(viewing);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ViewingExists(viewing.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Confirmation), new { id, tickets, saveChangesError = true }));
}
else
{
ModelState.AddModelError("", "Not enough seats left.");
}
}
else
{
ModelState.AddModelError("", "Can only book 1 to 12 tickets at a time.");
}
}
ViewData["AuditoriumID"] = new SelectList(_context.Auditoriums, "ID", "ID", viewing.AuditoriumID);
ViewData["MovieID"] = new SelectList(_context.Movies, "ID", "ID", viewing.MovieID);
return(View(viewing));
}
public IHttpActionResult DeleteViewing(int id)
{
Viewing viewing = db.Viewings.Find(id);
if (viewing == null)
{
return(NotFound());
}
db.Viewings.Remove(viewing);
db.SaveChanges();
return(Ok(viewing));
}
public void Handle(BookViewingCommand command)
{
var viewing = new Viewing
{
Appointment = command.Appointment,
PropertyId = command.PropertyId,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
BuyerUserId = command.BuyerUserId
};
_context.Viewings.Add(viewing);
_context.SaveChanges();
}
public static void RenderTo(this Scene scene, Image <Rgba32> image)
{
var v = new RectangleF(0, 0, image.Width, image.Height);
var w = new RectangleF(-2.0f, 2.0f, 4.0f, 4.0f);
//var w = new RectangleF(-4.0f, 4.0f, 8.0f, 8.0f);
var v2w = new ViewportToWindowTransform(w, v);
var viewing = Viewing.ViewingTransform(
scene.Eye,
scene.Center,
scene.Up
);
image.RenderTo(v2w, (float)scene.ViewingDistance, viewing, scene.Eye,
scene.Objects, scene.Lights, scene.AmbientLight);
}
public void Handle(BookViewingCommand command)
{
var property = _context.Properties.Find(command.PropertyId);
var viewing = new Viewing
{
ViewingAt = command.ViewingAt,
CreatedAt = DateTime.Now,
BuyerId = command.BuyerId,
PropertyId = command.PropertyId
};
_context.Viewings.Add(viewing);
_context.SaveChanges();
}
public ViewingViewModel GetViewingViewModelFromModel(Viewing view)
{
var viewmodel = new ViewingViewModel();
viewmodel.AgentId = view.ViewingHost.ID;
viewmodel.ListingId = view.Listing.ID;
viewmodel.CustomerID = view.Customer.ID;
viewmodel.ViewingStart = view.StartDate.AddMinutes(-TRAVEL_TIME);
viewmodel.ViewingDuration = (int)(view.EndDate.TimeOfDay.TotalMinutes
- view.StartDate.TimeOfDay.TotalMinutes) - (TRAVEL_TIME);
viewmodel.ReadonlyViewingModel = view;
return(viewmodel);
}
public bool ValidateViewingAvailability
(List <Viewing> viewingsInDb, Viewing viewingToCheckFor)
{
foreach (var currDate in viewingsInDb)
{
var isAvailable = (viewingToCheckFor.StartDate < currDate.StartDate &&
viewingToCheckFor.EndDate < currDate.StartDate)
||
(viewingToCheckFor.EndDate > currDate.EndDate &&
viewingToCheckFor.StartDate > currDate.EndDate);
if (!isAvailable)
{
return(false);
}
}
return(true);
}
