public async Task <IActionResult> PutScheduleExercise(int id, ScheduleExercise ScheduleExercise)
        {
            if (id != ScheduleExercise.ScheduleExerciseId)
            {
                return(BadRequest());
            }

            _context.Entry(ScheduleExercise).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ScheduleExerciseExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <ActionResult <ScheduleExercise> > PostScheduleExercise(AddSExerciseIn model)
        {
            var email            = GetEmail();
            var scheduleExercise = new ScheduleExercise();

            scheduleExercise.UserEmail          = email;
            scheduleExercise.ExerciseId         = model.exerciseId;
            scheduleExercise.ScheduleTrainingId = model.scheduleTrainingId;
            scheduleExercise.Order = await scheduleExerciseRepository.GetMaxOrderForScheduleExerciseAsync(model.scheduleTrainingId, email) + 1;

            _context.ScheduleExercises.Add(scheduleExercise);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetScheduleExercise", new { id = scheduleExercise.ScheduleExerciseId }, scheduleExercise));
        }
        public async Task <ActionResult> SwapExercise(SwapSExerciseIn model)
        {
            var email          = GetEmail();
            var exerciseDelete = await scheduleExerciseRepository.GetScheduleExerciseAsync(model.ScheduleExerciseId, email);

            var newExercise = new ScheduleExercise
            {
                ScheduleTrainingId = exerciseDelete.ScheduleTrainingId,
                Started            = false,
                UserEmail          = email,
                Order      = exerciseDelete.Order,
                ExerciseId = model.ExerciseId
            };

            await _context.AddAsync(newExercise);

            await _context.SaveChangesAsync();

            var series           = new List <ScheduleSeries>();
            var seriesInExercise = await seriesRepository.GetSeriesForExerciseAsync(newExercise.ExerciseId, email);

            foreach (var s in seriesInExercise)
            {
                series.Add(new ScheduleSeries
                {
                    ScheduleExerciseId = newExercise.ScheduleExerciseId,
                    Distance           = s.Distance,
                    Finish             = false,
                    Load      = s.Load,
                    Name      = s.Name,
                    Order     = s.Order,
                    Repeats   = s.Repeats,
                    RestTime  = s.RestTime,
                    Time      = s.Time,
                    UserEmail = email,
                });
            }
            await _context.AddRangeAsync(series);

            _context.Remove(exerciseDelete);
            await _context.SaveChangesAsync();

            return(Ok());
        }