public async Task <IActionResult> PutProduct(int id, Product product) { if (id != product.Id) { return(BadRequest()); } _context.Entry(product).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ProductExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PostInvoice(Invoice invoice) { try { // Getting and checking that CabinOwner owns the Cabin what is in Invoice if (User.IsInRole("CabinOwner")) { var cabinReservation = await _context.CabinReservation.Where(cabinReservation => cabinReservation.CabinReservationId == invoice.CabinReservationId) .Include(cabinReservation => cabinReservation.Cabin).ThenInclude(cabin => cabin.Person).FirstOrDefaultAsync(); if (cabinReservation.Cabin.Person.Email != User.Identity.Name) { return(Unauthorized()); } } _context.Invoice.Add(invoice); await _context.SaveChangesAsync(); return(NoContent()); } catch { return(StatusCode(500)); } }
public async Task <IActionResult> PutSession(int id, Session session) { if (id != session.ID) { return(BadRequest()); } _context.Entry(session).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!SessionExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutPerson(int id, Person person) { try { // Checks that User-role is Administrator or User in IdentityDB matches Person in CabinReservationsDB if (false == User.IsInRole("Administrator") && person.Email != User.Identity.Name) { return(Unauthorized()); } if (id != person.PersonId) { return(BadRequest()); } _context.Entry(person).State = EntityState.Modified; await _context.SaveChangesAsync(); return(NoContent()); } catch (DbUpdateConcurrencyException) { if (!PersonExists(id)) { return(NotFound()); } else { throw; } } }
public async Task <IActionResult> PutActivity(int id, Activity activity) { if (id != activity.ActivityId) { return(BadRequest()); } _context.Entry(activity).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ActivityExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <CabinImage> > PostCabinImage(CabinImage cabinImage) { try { // If CabinOwner, check that he can create Cabin only by own PersonId if (User.IsInRole("CabinOwner")) { var checkPerson = await _context.Person.Where(person => person.Email == User.Identity.Name).FirstOrDefaultAsync(); var cabin = await _context.Cabin.Where(cabin => cabin.CabinId == cabinImage.CabinId).FirstOrDefaultAsync(); if (cabin.PersonId != checkPerson.PersonId) { return(Unauthorized()); } } // Return BadRequest if cabin has already 4 images var cabinImages = await _context.CabinImage.Where(cImage => cImage.CabinId == cabinImage.CabinId).ToListAsync(); if (cabinImages.Count() >= 4) { return(BadRequest()); } _context.CabinImage.Add(cabinImage); await _context.SaveChangesAsync(); return(NoContent()); } catch { return(StatusCode(500)); } }
public async Task <ActionResult <Resort> > PostResort([FromBody] Resort resort) { try { _context.Resort.Add(resort); await _context.SaveChangesAsync(); return(NoContent()); } catch { return(StatusCode(400)); } }
public async Task <IActionResult> PutProduct(int id, Product product) { if (id != product.Id) { return(BadRequest()); } Product original = await _context.Product.AsNoTracking <Product>().FirstOrDefaultAsync(p => p.Id == id); AuthorizationResult authresult = await _authorizationService.AuthorizeAsync(User, original, "ProductOwner"); if (!authresult.Succeeded) { if (User.Identity.IsAuthenticated) { return(new ForbidResult()); } else { return(new ChallengeResult()); } } _context.Entry(product).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ProductExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <CabinReservation> > PostCabinReservation(CabinReservation cabinReservation) { try { // Last moment "kikkailua", had to do this because locally it works great, but when publishing it sets Start- and EndDates 1 day greater than selected // This may not work all cases/timezones //cabinReservation.ReservationStartDate = cabinReservation.ReservationStartDate.ToUniversalTime(); //cabinReservation.ReservationEndDate = cabinReservation.ReservationEndDate.ToUniversalTime(); cabinReservation.ReservationStartDate = cabinReservation.ReservationStartDate.AddHours(3); cabinReservation.ReservationEndDate = cabinReservation.ReservationEndDate.AddHours(3); cabinReservation.ReservationStartDate = cabinReservation.ReservationStartDate.Date; cabinReservation.ReservationEndDate = cabinReservation.ReservationEndDate.Date; if (cabinReservation.ReservationStartDate >= cabinReservation.ReservationEndDate) { return(BadRequest()); } // Getting list of days between ReservationStartDate - ReservationEndDate var suggestedDays = Enumerable.Range(0, 1 + cabinReservation.ReservationEndDate.Subtract(cabinReservation.ReservationStartDate).Days) .Select(offset => cabinReservation.ReservationStartDate.AddDays(offset)) .ToArray(); // Checking that Cabin is not reserved by given time foreach (var item in suggestedDays) { var checkAvailability = await _context.CabinReservation .Where(cabinRes => cabinRes.CabinId == cabinReservation.CabinId) .Where(cabinRes => cabinRes.ReservationStartDate.AddDays(1) == item || cabinRes.ReservationEndDate.AddDays(-1) == item) .FirstOrDefaultAsync(); if (checkAvailability != null) { return(BadRequest()); } } _context.Add(cabinReservation); if (User.IsInRole("CabinOwner") || User.IsInRole("Customer")) { cabinReservation.Person = await _context.Person.Where(person => person.Email == User.Identity.Name).FirstOrDefaultAsync(); cabinReservation.PersonId = cabinReservation.Person.PersonId; } else if (User.IsInRole("Administrator")) { cabinReservation.Person = await _context.Person.Where(person => person.PersonId == cabinReservation.PersonId).FirstOrDefaultAsync(); } else { return(Unauthorized()); } cabinReservation.ReservationBookingTime = DateTime.Now; // Counting Activities TotalPrice decimal activitiesTotalPrice = 0; if (cabinReservation.ActivityReservations != null) { foreach (var item in cabinReservation.ActivityReservations) { var activity = await _context.Activity.Where(activity => activity.ActivityId == item.ActivityId).FirstOrDefaultAsync(); activitiesTotalPrice += activity.ActivityPrice; } } // Creating and adding new Invoice to CabinReservation Invoice invoice = new Invoice(); var cabin = await _context.Cabin.Where(cabin => cabin.CabinId == cabinReservation.CabinId).FirstOrDefaultAsync(); decimal duration = (cabinReservation.ReservationEndDate - cabinReservation.ReservationStartDate).Days; invoice.DateOfExpiry = cabinReservation.ReservationEndDate.AddDays(30); invoice.InvoiceTotalAmount = (duration * cabin.CabinPricePerDay) + activitiesTotalPrice; cabinReservation.Invoices = new List <Invoice>(); cabinReservation.Invoices.Add(invoice); await _context.SaveChangesAsync(); return(NoContent()); } catch { return(StatusCode(500)); } }