public async Task <IHttpActionResult> PutSchedule(int id, Schedule schedule)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != schedule.ID)
{
return(BadRequest());
}
db.Entry(schedule).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ScheduleExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PutCustomer(string id, Customer customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != customer.ID)
{
return(BadRequest());
}
db.Entry(customer).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PostReservation(ReservationModel reservationModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string customerID = RequestContext.Principal.Identity.GetUserId();
if (ReservationExists(reservationModel.ScheduleID, customerID))
{
return(BadRequest("Rezerwacja już istnieje"));
}
if (!DecrementScheduleAvailablePlaces(reservationModel.ScheduleID))
{
return(BadRequest("Wszystkie miejsca są już zajęte"));
}
var reservation = new Reservations
{
CustomerID = customerID,
ScheduleID = reservationModel.ScheduleID
};
db.Reservations.Add(reservation);
await db.SaveChangesAsync();
return(Ok("Dodano rezerwację"));
}
public async Task <IActionResult> Create([Bind("Id,MemberId,Date,Amount")] Payment payment)
{
if (ModelState.IsValid)
{
_context.Add(payment);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(payment));
}
public async Task <IActionResult> Create([Bind("Id,Name,Phone,Email,BirthDate")] Member member)
{
if (ModelState.IsValid)
{
_context.Add(member);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(member));
}
public async Task <IActionResult> Create([Bind("Id,Name,StartTime,EndTime")] FitnessGroup fitnessGroup)
{
if (ModelState.IsValid)
{
_context.Add(fitnessGroup);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(fitnessGroup));
}
public async Task <ActionResult> Create([Bind(Include = "Id,TrainingTimeStart")] TrainingSession trainingSession)
{
if (ModelState.IsValid)
{
db.TrainingSessions.Add(trainingSession);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(trainingSession));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,LastName,Price,TrainingLength,Description")] Coach coach)
{
if (ModelState.IsValid)
{
db.Coaches.Add(coach);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(coach));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,LastName,EMail,PhoneNumber")] Client client)
{
if (ModelState.IsValid)
{
db.Clients.Add(client);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(client));
}
public async Task <IActionResult> UpdateMembership([FromBody] Membership membership)
{
using (var context = new GymDbContext())
{
context.Memberships.Update(membership);
await context.SaveChangesAsync();
return(Ok());
}
}
public async Task <IActionResult> UpdateClass([FromBody] Class class_)
{
using (var context = new GymDbContext())
{
context.Classes.Update(class_);
await context.SaveChangesAsync();
return(Ok());
}
}
public async Task <IActionResult> UpdateWorkoutEquipment([FromBody] WorkoutEquipment workoutequipment)
{
using (var context = new GymDbContext())
{
context.WorkoutEquipments.Update(workoutequipment);
await context.SaveChangesAsync();
return(Ok());
}
}
public async Task <IActionResult> UpdateTraining([FromBody] Training training)
{
using (var context = new GymDbContext())
{
context.Trainings.Update(training);
await context.SaveChangesAsync();
return(Ok());
}
}
public async Task <IActionResult> UpdateUser([FromBody] User user)
{
using (var context = new GymDbContext())
{
context.Users.Update(user);
await context.SaveChangesAsync();
return(Ok());
}
}
public async Task <IActionResult> Create([Bind("FitId,MemberId")] FitnessAndMembers fitnessAndMembers)
{
try
{
if (ModelState.IsValid)
{
_context.Add(fitnessAndMembers);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["FitId"] = new SelectList(_context.FitnessGroups, "Id", "Name", fitnessAndMembers.FitId);
ViewData["MemberId"] = new SelectList(_context.Members, "Id", "Name", fitnessAndMembers.MemberId);
return(View(fitnessAndMembers));
}
catch (Exception)
{
return(View("InvalidCreate"));
}
}
public async Task <IActionResult> CreateTrainingRoom([FromBody] TrainingRoom trainingRoom)
{
using (var context = new GymDbContext())
{
context.TrainingRooms.Add(trainingRoom);
await context.SaveChangesAsync();
return(Ok());
}
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = model.Email,
Email = model.Email,
TwoFactorEnabled = true
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var customer = new Customer()
{
ID = user.Id,
Email = model.Email,
Name = model.Name,
Surname = model.Surname
};
db.Customers.Add(customer);
await db.SaveChangesAsync();
await UserManager.AddToRoleAsync(user.Id, "User");
}
else
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task <IActionResult> DeleteClass([FromQuery] string name)
{
using (var context = new GymDbContext())
{
var class_ = await context.Classes.FirstOrDefaultAsync(x => x.Name == name);
if (class_ != null)
{
context.Classes.Remove(class_);
await context.SaveChangesAsync();
}
return(Ok());
}
}
public async Task <IActionResult> DeleteTraining([FromQuery] string className, [FromQuery] string trainerFc)
{
using (var context = new GymDbContext())
{
var training = await context.Trainings.FirstOrDefaultAsync(x => (x.ClassName == className) && (x.TrainerFC == trainerFc));
if (training != null)
{
context.Trainings.Remove(training);
await context.SaveChangesAsync();
}
return(Ok());
}
}
public async Task <IActionResult> DeleteTrainer([FromQuery] string fc)
{
using (var context = new GymDbContext())
{
var trainer = await context.Trainers.FirstOrDefaultAsync(x => x.FC == fc);
if (trainer != null)
{
context.Trainers.Remove(trainer);
await context.SaveChangesAsync();
}
return(Ok());
}
}
public async Task <IActionResult> DeleteWorkoutEquipment([FromQuery] string name)
{
using (var context = new GymDbContext())
{
var workoutequipment = await context.WorkoutEquipments.FirstOrDefaultAsync(x => x.Name == name);
if (workoutequipment != null)
{
context.WorkoutEquipments.Remove(workoutequipment);
await context.SaveChangesAsync();
}
return(Ok());
}
}
public async Task <IActionResult> DeleteTrainingRoom([FromQuery] string name)
{
using (var context = new GymDbContext())
{
var trainingRoom = await context.TrainingRooms.FirstOrDefaultAsync(x => x.Name == name);
if (trainingRoom != null)
{
context.TrainingRooms.Remove(trainingRoom);
await context.SaveChangesAsync();
}
return(Ok());
}
}
public async Task <IActionResult> DeleteMembership([FromQuery] string className, [FromQuery] string userFc)
{
using (var context = new GymDbContext())
{
var membership = await context.Memberships.FirstOrDefaultAsync(x => (x.ClassName == className) && (x.UserFC == userFc));
if (membership != null)
{
context.Memberships.Remove(membership);
await context.SaveChangesAsync();
}
return(Ok());
}
}
public async Task <IActionResult> DeleteTrainingProgram([FromQuery] int id)
{
using (var context = new GymDbContext())
{
var trainingprogram = await context.TrainingPrograms.FirstOrDefaultAsync(x => x.Id == id);
if (trainingprogram != null)
{
context.TrainingPrograms.Remove(trainingprogram);
await context.SaveChangesAsync();
}
return(Ok());
}
}
