public async Task <ActionResult <Data.Models.Exercise> > CreateNewExercise(Data.Models.ExerciseForCreate newExercise)
        {
            Data.Entities.Exercise dbNewExercise = null;
            try
            {
                dbNewExercise = _mapper.Map <Data.Entities.Exercise>(newExercise);
            }
            catch (Exception ex)
            {
                return(BadRequest("Input is in invalid format: " + ex.Message));
            }

            if (dbNewExercise == null)
            {
                return(BadRequest("Input is in invalid format"));
            }

            await _repository.AddAsync <Data.Entities.Exercise>(dbNewExercise);

            await _repository.SaveChangesAsync();

            Data.Models.Exercise addedExercise = _mapper.Map <Data.Models.Exercise>(dbNewExercise);

            var url = _linkgenerator.GetPathByAction(HttpContext, "GetExerciseByExerciseId", "Exercises", addedExercise);

            return(this.Created(url, addedExercise));
        }
        public async Task <ActionResult <Data.Models.Exercise> > PatchExercise(int exerciseId, JsonPatchDocument <Data.Models.ExerciseForUpdate> patchDocument)
        {
            try
            {
                Data.Entities.Exercise dbExercise = await _repository.GetExerciseAsync(exerciseId);

                if (dbExercise == null)
                {
                    return(NotFound());
                }

                var updatedExercise = _mapper.Map <Data.Models.ExerciseForUpdate>(dbExercise);
                patchDocument.ApplyTo(updatedExercise, ModelState);

                _mapper.Map(updatedExercise, dbExercise);

                if (await _repository.SaveChangesAsync())
                {
                    Data.Models.Exercise savedExercise = _mapper.Map <Data.Models.Exercise>(await _repository.GetExerciseAsync(exerciseId));
                    return(Ok(savedExercise));
                }
                else
                {
                    return(StatusCode(StatusCodes.Status500InternalServerError, "Unable to save to database"));
                }
            }
            catch (Exception ex)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, "Unable to patch exercise " + ex.Message));
            }
        }
        public async Task <ActionResult <Data.Models.Exercise> > UpdateExercise(int exerciseId, Data.Models.ExerciseForUpdate updatedExercise)
        {
            try
            {
                Data.Entities.Exercise dbExercise = await _repository.GetExerciseAsync(exerciseId);

                if (dbExercise == null)
                {
                    return(NotFound());
                }

                _mapper.Map(updatedExercise, dbExercise);
                if (await _repository.SaveChangesAsync())
                {
                    Data.Models.Exercise savedExercise = _mapper.Map <Data.Models.Exercise>(dbExercise);
                    return(Ok(savedExercise));
                }
                else
                {
                    return(BadRequest("Failed to update."));
                }
            }
            catch (Exception ex)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, "Database exception: " + ex.Message));
            }
        }
        public async Task <IActionResult> DeleteExercise(int exerciseId)
        {
            try
            {
                Data.Entities.Exercise dbExercise = await _repository.GetExerciseAsync(exerciseId);

                if (dbExercise == null)
                {
                    return(NotFound());
                }

                _repository.Delete <Data.Entities.Exercise>(dbExercise);
                await _repository.SaveChangesAsync();

                return(NoContent());
            }
            catch (Exception ex)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, "Database exception: " + ex.Message));
            }
        }