public void GetTitle_NullRide_ShouldReturn_RideId()
        {
            var workout = new Workout()
            {
                Id = "someId"
            };

            var title = WorkoutHelper.GetTitle(workout);

            title.Should().Be("someId");
        }
        public void GetTitle_NullInstructor_ShouldReturn_EmptyInstructorName()
        {
            var workout = new Workout()
            {
                Ride = new Ride()
                {
                    Title = "My Title"
                }
            };

            var title = WorkoutHelper.GetTitle(workout);

            title.Should().Be("My_Title");
        }
        public void GetTitle_ShouldReturn_RideTitle()
        {
            var workout = new Workout()
            {
                Ride = new Ride()
                {
                    Title      = "My Title",
                    Instructor = new Instructor()
                    {
                        Name = "My Name"
                    }
                }
            };

            var title = WorkoutHelper.GetTitle(workout);

            title.Should().Be("My_Title_with_My_Name");
        }
        public async Task DownloadLatestWorkoutDataAsync()
        {
            if (_config.Peloton.NumWorkoutsToDownload <= 0)
            {
                return;
            }

            using var tracing = Tracing.Trace(nameof(DownloadLatestWorkoutDataAsync));

            await _pelotonApi.InitAuthAsync();

            var recentWorkouts = await _pelotonApi.GetWorkoutsAsync(_config.Peloton.NumWorkoutsToDownload);

            var completedWorkouts = recentWorkouts.data.Where(w =>
            {
                if (w.Status == "COMPLETE")
                {
                    return(true);
                }
                Log.Debug("Skipping in progress workout. {@WorkoutId} {@WorkoutStatus} {@WorkoutType}", w.Id, w.Status, w.Fitness_Discipline);
                return(false);
            });

            var filteredWorkouts = completedWorkouts.Where(w =>
            {
                if (!_config.Peloton.ExcludeWorkoutTypes?.Contains(w.Fitness_Discipline) ?? true)
                {
                    return(true);
                }
                Log.Debug("Skipping excluded workout type. {@WorkoutId} {@WorkoutStatus} {@WorkoutType}", w.Id, w.Status, w.Fitness_Discipline);
                return(false);
            });

            var workingDir = _config.App.DownloadDirectory;

            _fileHandler.MkDirIfNotExists(workingDir);

            foreach (var recentWorkout in filteredWorkouts)
            {
                var workoutId = recentWorkout.Id;

                SyncHistoryItem syncRecord = _dbClient.Get(recentWorkout.Id);
                if ((syncRecord?.DownloadDate is object))
                {
                    Log.Debug("Workout {@WorkoutId} already downloaded, skipping.", recentWorkout.Id);
                    continue;
                }

                using var workoutTimer = WorkoutDownloadDuration.NewTimer();

                var workoutTask        = _pelotonApi.GetWorkoutByIdAsync(recentWorkout.Id);
                var workoutSamplesTask = _pelotonApi.GetWorkoutSamplesByIdAsync(recentWorkout.Id);

                await Task.WhenAll(workoutTask, workoutSamplesTask);

                var workout        = workoutTask.GetAwaiter().GetResult();
                var workoutSamples = workoutSamplesTask.GetAwaiter().GetResult();

                dynamic data = new JObject();
                data.Workout        = workout;
                data.WorkoutSamples = workoutSamples;

                var        workoutTitle     = string.Empty;
                P2GWorkout deSerializedData = null;
                try
                {
                    deSerializedData = JsonSerializer.Deserialize <P2GWorkout>(data.ToString(), new JsonSerializerOptions()
                    {
                        PropertyNameCaseInsensitive = true
                    });
                    workoutTitle = WorkoutHelper.GetUniqueTitle(deSerializedData.Workout);

                    if (_config.Format.Json && _config.Format.SaveLocalCopy)
                    {
                        SaveRawData(data, workoutTitle);
                    }
                } catch (Exception e)
                {
                    _failedCount++;
                    var title = "workout_failed_to_deserialize_" + _failedCount;
                    Log.Error("Failed to deserialize workout from Peloton. You can find the raw data from the workout here: @FileName", title, e);
                    SaveRawData(data, title);
                    return;
                }

                Log.Debug("Write peloton workout details to file for {@WorkoutId}.", workoutId);
                File.WriteAllText(Path.Join(workingDir, $"{workoutTitle}.json"), data.ToString());


                var syncHistoryItem = new SyncHistoryItem(deSerializedData.Workout)
                {
                    DownloadDate = DateTime.Now,
                };

                _dbClient.Upsert(syncHistoryItem);
            }
        }
Example #5
0
        protected override Tuple <string, ICollection <Mesg> > Convert(Workout workout, WorkoutSamples workoutSamples)
        {
            // MESSAGE ORDER MATTERS
            var messages = new List <Mesg>();

            var startTime = GetStartTimeUtc(workout);
            var endTime   = GetEndTimeUtc(workout);
            var title     = WorkoutHelper.GetTitle(workout);
            var sport     = GetGarminSport(workout);
            var subSport  = GetGarminSubSport(workout);

            if (sport == Sport.Invalid)
            {
                Log.Warning("Unsupported Sport Type - Skipping {@Sport}", workout.Fitness_Discipline);
                return(new Tuple <string, ICollection <Mesg> >(string.Empty, null));
            }

            var fileIdMesg = new FileIdMesg();

            fileIdMesg.SetSerialNumber(_serialNumber);
            fileIdMesg.SetTimeCreated(startTime);
            fileIdMesg.SetManufacturer(_manufacturerId);
            fileIdMesg.SetProduct(_productId);
            fileIdMesg.SetType(Dynastream.Fit.File.Activity);
            messages.Add(fileIdMesg);

            var eventMesg = new EventMesg();

            eventMesg.SetTimestamp(startTime);
            eventMesg.SetData(0);
            eventMesg.SetEvent(Event.Timer);
            eventMesg.SetEventType(EventType.Start);
            eventMesg.SetEventGroup(0);
            messages.Add(eventMesg);

            var deviceInfoMesg = new DeviceInfoMesg();

            deviceInfoMesg.SetTimestamp(startTime);
            deviceInfoMesg.SetSerialNumber(_serialNumber);
            deviceInfoMesg.SetManufacturer(_manufacturerId);
            deviceInfoMesg.SetProduct(_productId);
            deviceInfoMesg.SetSoftwareVersion(_softwareVersion);
            deviceInfoMesg.SetDeviceIndex(0);
            deviceInfoMesg.SetSourceType(SourceType.Local);
            deviceInfoMesg.SetProductName("PelotonToGarmin");             // Max 20 Chars
            messages.Add(deviceInfoMesg);

            var userProfileMesg = new UserProfileMesg();

            userProfileMesg.SetPowerSetting(DisplayPower.PercentFtp);
            messages.Add(userProfileMesg);

            var sportMesg = new SportMesg();

            sportMesg.SetSport(sport);
            sportMesg.SetSubSport(subSport);
            messages.Add(sportMesg);

            var zoneTargetMesg = new ZonesTargetMesg();

            zoneTargetMesg.SetFunctionalThresholdPower((ushort)workout.Ftp_Info.Ftp);
            zoneTargetMesg.SetPwrCalcType(PwrZoneCalc.PercentFtp);
            var maxHr = GetUserMaxHeartRate(workoutSamples);

            if (maxHr is object)
            {
                zoneTargetMesg.SetMaxHeartRate(maxHr.Value);
                zoneTargetMesg.SetHrCalcType(HrZoneCalc.PercentMaxHr);
            }
            messages.Add(zoneTargetMesg);

            var trainingMesg = new TrainingFileMesg();

            trainingMesg.SetTimestamp(startTime);
            trainingMesg.SetTimeCreated(startTime);
            trainingMesg.SetSerialNumber(_serialNumber);
            trainingMesg.SetManufacturer(_manufacturerId);
            trainingMesg.SetProduct(_productId);
            trainingMesg.SetType(Dynastream.Fit.File.Workout);
            messages.Add(trainingMesg);

            AddMetrics(messages, workoutSamples, startTime);

            var workoutSteps = new List <WorkoutStepMesg>();
            var laps         = new List <LapMesg>();

            if (workoutSamples.Target_Performance_Metrics?.Target_Graph_Metrics?.FirstOrDefault(w => w.Type == "cadence")?.Graph_Data is object)
            {
                var stepsAndLaps = GetWorkoutStepsAndLaps(workoutSamples, startTime, sport, subSport);
                workoutSteps = stepsAndLaps.Values.Select(v => v.Item1).ToList();
                laps         = stepsAndLaps.Values.Select(v => v.Item2).ToList();
            }
            else
            {
                laps = GetWorkoutLaps(workoutSamples, startTime, sport, subSport).ToList();
            }

            var workoutMesg = new WorkoutMesg();

            workoutMesg.SetWktName(title.Replace(_spaceSeparator, " "));
            workoutMesg.SetCapabilities(32);
            workoutMesg.SetSport(sport);
            workoutMesg.SetSubSport(subSport);
            workoutMesg.SetNumValidSteps((ushort)workoutSteps.Count);
            messages.Add(workoutMesg);

            // add steps in order
            foreach (var step in workoutSteps)
            {
                messages.Add(step);
            }

            // Add laps in order
            foreach (var lap in laps)
            {
                messages.Add(lap);
            }

            messages.Add(GetSessionMesg(workout, workoutSamples, startTime, endTime, (ushort)laps.Count));

            var activityMesg = new ActivityMesg();

            activityMesg.SetTimestamp(endTime);
            activityMesg.SetTotalTimerTime(workoutSamples.Duration);
            activityMesg.SetNumSessions(1);
            activityMesg.SetType(Activity.Manual);
            activityMesg.SetEvent(Event.Activity);
            activityMesg.SetEventType(EventType.Stop);

            var timezoneOffset = (int)TimeZoneInfo.Local.GetUtcOffset(base.GetEndTimeUtc(workout)).TotalSeconds;
            var timeStamp      = (uint)((int)endTime.GetTimeStamp() + timezoneOffset);

            activityMesg.SetLocalTimestamp(timeStamp);

            messages.Add(activityMesg);

            return(new Tuple <string, ICollection <Mesg> >(title, messages));
        }
Example #6
0
        protected void Convert(string format)
        {
            if (!_fileHandler.DirExists(_config.App.DownloadDirectory))
            {
                Log.Information("No download directory found. Nothing to do. {@File}", _config.App.DownloadDirectory);
                return;
            }

            var files = _fileHandler.GetFiles(_config.App.DownloadDirectory);

            if (files.Length == 0)
            {
                Log.Information("No files to convert in download directory. Nothing to do.");
                return;
            }

            if (_config.Garmin.Upload)
            {
                _fileHandler.MkDirIfNotExists(_config.App.UploadDirectory);
            }

            // Foreach file in directory
            foreach (var file in files)
            {
                using var workoutTimer = WorkoutsConverted.WithLabels(format).NewTimer();

                // load file and deserialize
                P2GWorkout workoutData = null;
                try
                {
                    workoutData = _fileHandler.DeserializeJson <P2GWorkout>(file);
                }
                catch (Exception e)
                {
                    Log.Error(e, "Failed to load and parse workout data {@File}", file);
                    _fileHandler.MoveFailedFile(file, _config.App.FailedDirectory);
                    continue;
                }

                using var tracing = Tracing.Trace("Convert")
                                    .WithWorkoutId(workoutData.Workout.Id)
                                    .WithTag(TagKey.Format, format);

                // call internal convert method
                T   converted    = default;
                var workoutTitle = WorkoutHelper.GetUniqueTitle(workoutData.Workout);
                try
                {
                    converted = Convert(workoutData.Workout, workoutData.WorkoutSamples);
                } catch (Exception e)
                {
                    Log.Error(e, "Failed to convert workout data {@Workout} {@File}", workoutTitle, file);
                }

                if (converted is null)
                {
                    _fileHandler.MoveFailedFile(file, _config.App.FailedDirectory);
                    continue;
                }

                // write to output dir
                var path = Path.Join(_config.App.WorkingDirectory, $"{workoutTitle}.{format}");
                try
                {
                    Save(converted, path);
                }
                catch (Exception e)
                {
                    Log.Error(e, "Failed to write {@Format} file for {@Workout}", format, workoutTitle);
                    continue;
                }

                // copy to local save
                if (_config.Format.SaveLocalCopy)
                {
                    try
                    {
                        _fileHandler.MkDirIfNotExists(_config.App.TcxDirectory);
                        _fileHandler.MkDirIfNotExists(_config.App.FitDirectory);
                        var dir = format == "fit" ? _config.App.FitDirectory : _config.App.TcxDirectory;

                        var backupDest = Path.Join(dir, $"{workoutTitle}.{format}");
                        _fileHandler.Copy(path, backupDest, overwrite: true);
                        Log.Information("Backed up file {@File}", backupDest);
                    }
                    catch (Exception e)
                    {
                        Log.Error(e, "Failed to backup {@Format} file for {@Workout}", format, workoutTitle);
                        continue;
                    }
                }

                // copy to upload dir
                if (_config.Garmin.Upload && _config.Garmin.FormatToUpload == format)
                {
                    try
                    {
                        var uploadDest = Path.Join(_config.App.UploadDirectory, $"{workoutTitle}.{format}");
                        _fileHandler.Copy(path, uploadDest, overwrite: true);
                        Log.Debug("Prepped {@Format} file {@Path} for upload.", format, uploadDest);
                    }
                    catch (Exception e)
                    {
                        Log.Error(e, "Failed to copy {@Format} file for {@Workout}", format, workoutTitle);
                        continue;
                    }
                }

                // update db item with conversion date
                SyncHistoryItem syncRecord = _dbClient.Get(workoutData.Workout.Id);
                if (syncRecord is null)
                {
                    syncRecord = new SyncHistoryItem(workoutData.Workout)
                    {
                        DownloadDate = System.DateTime.Now,
                    };
                }

                syncRecord.ConvertedToFit = syncRecord.ConvertedToFit || format == "fit";
                syncRecord.ConvertedToTcx = syncRecord.ConvertedToTcx || format == "tcx";
                _dbClient.Upsert(syncRecord);
            }
        }
        protected ConvertStatus Convert(FileFormat format, P2GWorkout workoutData)
        {
            using var tracing = Tracing.Trace($"{nameof(IConverter)}.{nameof(Convert)}.Workout")?
                                .WithWorkoutId(workoutData.Workout.Id)
                                .WithTag(TagKey.Format, format.ToString());

            var status = new ConvertStatus();

            // call internal convert method
            T   converted    = default;
            var workoutTitle = WorkoutHelper.GetUniqueTitle(workoutData.Workout);

            try
            {
                converted = Convert(workoutData.Workout, workoutData.WorkoutSamples);
            }
            catch (Exception e)
            {
                _logger.Error(e, "Failed to convert workout data to format {@Format} {@Workout}", format, workoutTitle);
                status.Success      = false;
                status.ErrorMessage = "Failed to convert workout data.";
                tracing?.AddTag("excetpion.message", e.Message);
                tracing?.AddTag("exception.stacktrace", e.StackTrace);
                tracing?.AddTag("convert.success", false);
                tracing?.AddTag("convert.errormessage", status.ErrorMessage);
                return(status);
            }

            // write to output dir
            var path = Path.Join(_config.App.WorkingDirectory, $"{workoutTitle}.{format}");

            try
            {
                _fileHandler.MkDirIfNotExists(_config.App.WorkingDirectory);
                Save(converted, path);
                status.Success = true;
            }
            catch (Exception e)
            {
                status.Success      = false;
                status.ErrorMessage = "Failed to save converted workout for upload.";
                _logger.Error(e, "Failed to write {@Format} file for {@Workout}", format, workoutTitle);
                tracing?.AddTag("excetpion.message", e.Message);
                tracing?.AddTag("exception.stacktrace", e.StackTrace);
                tracing?.AddTag("convert.success", false);
                tracing?.AddTag("convert.errormessage", status.ErrorMessage);
                return(status);
            }

            // copy to local save
            try
            {
                SaveLocalCopy(path, workoutTitle);
            }
            catch (Exception e)
            {
                _logger.Error(e, "Failed to backup {@Format} file for {@Workout}", format, workoutTitle);
            }

            // copy to upload dir
            if (_config.Garmin.Upload && _config.Garmin.FormatToUpload == format)
            {
                try
                {
                    var uploadDest = Path.Join(_config.App.UploadDirectory, $"{workoutTitle}.{format}");
                    _fileHandler.MkDirIfNotExists(_config.App.UploadDirectory);
                    _fileHandler.Copy(path, uploadDest, overwrite: true);
                    _logger.Debug("Prepped {@Format} for upload: {@Path}", format, uploadDest);
                }
                catch (Exception e)
                {
                    _logger.Error(e, "Failed to copy {@Format} file for {@Workout}", format, workoutTitle);
                    status.Success      = false;
                    status.ErrorMessage = $"Failed to save file for {@format} and workout {workoutTitle} to Upload directory";
                    tracing?.AddTag("excetpion.message", e.Message);
                    tracing?.AddTag("exception.stacktrace", e.StackTrace);
                    tracing?.AddTag("convert.success", false);
                    tracing?.AddTag("convert.errormessage", status.ErrorMessage);
                    return(status);
                }
            }

            return(status);
        }
Example #8
0
        public HttpResponseMessage Put([FromBody] WorkoutDiaryEntryDTO workoutDiaryEntryDTO)
        {
            try
            {
                // Выбираем запись из БД для обновления
                var workoutDiaryEntry = unitOfWork.WorkoutDiaryEntryRepository.Get(
                    f =>
                    (f.CreateUserId == currentUserId &&
                     f.WorkoutDiaryEntryId == workoutDiaryEntryDTO.WorkoutDiaryEntryId),
                    null,
                    iE => iE.Exercise,
                    iS => iS.Sets)
                                        .SingleOrDefault();

                // Записи нет в БД FT
                if (workoutDiaryEntry == null)
                {
                    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
                }

                var workoutDiaryEntryUpdateObj = Mapper.Map <WorkoutDiaryEntry>(workoutDiaryEntryDTO);
                foreach (WorkoutSet newSet in workoutDiaryEntryUpdateObj.Sets)
                {
                    var oldSet = workoutDiaryEntry.Sets.Where(
                        i => i.WorkoutSetId == newSet.WorkoutSetId)
                                 .SingleOrDefault();
                    if (oldSet == null)
                    {
                        // Сета нет в БД. Добавляем.
                        unitOfWork.WorkoutSetRepository.Insert(new WorkoutSet
                        {
                            Duration            = newSet.Duration,
                            Distance            = newSet.Distance,
                            IsCompleted         = newSet.IsCompleted,
                            Order               = newSet.Order,
                            Reps                = newSet.Reps,
                            Rest                = newSet.Rest,
                            Weight              = newSet.Weight,
                            WorkoutDiaryEntryId = workoutDiaryEntry.WorkoutDiaryEntryId
                        });
                    }
                    else
                    {
                        // Сет есть в БД. Обновляем.
                        oldSet.Distance    = newSet.Distance;
                        oldSet.Duration    = newSet.Duration;
                        oldSet.IsCompleted = newSet.IsCompleted;
                        oldSet.Order       = newSet.Order;
                        oldSet.Reps        = newSet.Reps;
                        oldSet.Rest        = newSet.Rest;
                        oldSet.Weight      = newSet.Weight;
                    }
                }
                workoutDiaryEntry.DateUTC = workoutDiaryEntryUpdateObj.DateUTC;

                #region __Подсчитываем количество сожженных калорий__
                if (workoutDiaryEntry.Exercise.MET.HasValue && workoutDiaryEntry.Exercise.MET.Value != 0)
                {
                    var setsDuration = workoutDiaryEntry.Sets.Select(s => s.Duration).Sum();
                    if (setsDuration > 0)
                    {
                        // Получаем информацию о пользователе для подсчета сожженных калорий (вес, возраст)
                        var userProfile = unitOfWork.UserProfileRepository.Get(
                            f => (f.UserId == currentUserId),
                            null,
                            i => i.Weights)
                                          .SingleOrDefault();
                        // Пользователя нет в БД
                        if (userProfile == null)
                        {
                            throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
                        }

                        if (userProfile.Weights.Any())
                        {
                            var weight = userProfile.Weights.OrderByDescending(d => d.Date).First().Weight;
                            if (weight > 0)
                            {
                                workoutDiaryEntry.BurnedCalories =
                                    WorkoutHelper.GetBurnedCalories(workoutDiaryEntry.Exercise.MET.Value, weight, setsDuration);
                            }
                        }
                    }
                }
                #endregion

                // Информация о изменении
                workoutDiaryEntry.CreationInfo.LastModifiedTimeUTC = TimeHelper.DateTimeUtcNow;

                // Обновляем запись
                unitOfWork.WorkoutDiaryEntryRepository.Update(workoutDiaryEntry);
                unitOfWork.Save();

                //Преобразовываем обратно, чтобы вернуть клиенту
                workoutDiaryEntryDTO = Mapper.Map <WorkoutDiaryEntryDTO>(workoutDiaryEntry);
            }
            catch (System.Data.Entity.Validation.DbEntityValidationException ex)
            {
                // Retrieve the error messages as a list of strings.
                var errorMessages = ex.EntityValidationErrors
                                    .SelectMany(x => x.ValidationErrors)
                                    .Select(x => x.ErrorMessage);
                // Join the list to a single string.
                var fullErrorMessage = string.Join("; ", errorMessages);

                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError));
            }
            catch (Exception ex)
            {
                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
            }

            return(Request.CreateResponse <WorkoutDiaryEntryDTO>(HttpStatusCode.OK, workoutDiaryEntryDTO));
        }
Example #9
0
        public HttpResponseMessage Post([FromBody] WorkoutDiaryEntryDTO workoutDiaryEntryDTO)
        {
            var currentTime = TimeHelper.UnixMsNow;

            // Информация о создании
            workoutDiaryEntryDTO.CreateUserId = currentUserId;
            workoutDiaryEntryDTO.CreationInfo.CreationTime         =
                workoutDiaryEntryDTO.CreationInfo.LastModifiedTime = currentTime;

            try
            {
                var workoutDiaryEntry = Mapper.Map <WorkoutDiaryEntry>(workoutDiaryEntryDTO);

                // Для избежания повторного добавления упражнения -
                // обнуляем его (сохраняя во временной переменной)и
                // выставляем индекс упражнения в записи
                Exercise tempExercise = null;
                if (workoutDiaryEntry.Exercise != null)
                {
                    // Запоминаем упражнение
                    tempExercise = workoutDiaryEntry.Exercise;
                    // Устанавлиавем идентификатор упражнения
                    workoutDiaryEntry.ExerciseId = workoutDiaryEntry.Exercise.ExerciseId;

                    #region __Подсчитываем количество сожженных калорий__
                    if (workoutDiaryEntry.Exercise.MET.HasValue && workoutDiaryEntry.Exercise.MET.Value != 0)
                    {
                        var setsDuration = workoutDiaryEntry.Sets.Select(s => s.Duration).Sum();
                        if (setsDuration > 0)
                        {
                            // Получаем информацию о пользователе для подсчета сожженных калорий (вес, возраст)
                            var userProfile = unitOfWork.UserProfileRepository.Get(
                                f => (f.UserId == currentUserId),
                                null,
                                i => i.Weights)
                                              .SingleOrDefault();
                            // Пользователя нет в БД
                            if (userProfile == null)
                            {
                                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
                            }

                            if (userProfile.Weights.Any())
                            {
                                var weight = userProfile.Weights.OrderByDescending(d => d.Date).First().Weight;
                                if (weight > 0)
                                {
                                    workoutDiaryEntry.BurnedCalories =
                                        WorkoutHelper.GetBurnedCalories(workoutDiaryEntry.Exercise.MET.Value, weight, setsDuration);
                                }
                            }
                        }
                    }
                    #endregion

                    // Обнуляем упражнение, чтобы не обновлялось в БД
                    workoutDiaryEntry.Exercise = null;
                }

                // Добавляем запись в базу
                unitOfWork.WorkoutDiaryEntryRepository.Insert(workoutDiaryEntry);
                unitOfWork.Save();

                // Восстанавливаем упражение, чтобы вернуть клиенту
                if (tempExercise != null)
                {
                    workoutDiaryEntry.Exercise = tempExercise;
                }
                // Преобразовываем обратно, чтобы вернуть клиенту
                workoutDiaryEntryDTO = Mapper.Map <WorkoutDiaryEntryDTO>(workoutDiaryEntry);
            }
            catch (Exception ex)
            {
                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
            }

            return(Request.CreateResponse <WorkoutDiaryEntryDTO>(HttpStatusCode.Created, workoutDiaryEntryDTO));
        }