public List <WorkoutSet> GetWorkOutSets(WorkoutVM workoutVM, Workout workout)
{
List <WorkoutSet> workoutSets = new List <WorkoutSet>();
foreach (var exercise in workoutVM.AllExercises)
{
List <int> sets = exercise.SetsAndReps
.Split(new char[] { ' ', ',' })
.Where(x => !string.IsNullOrEmpty(x))
.Select(x => int.Parse(x))
.ToList();
for (int i = 0; i < sets.Count; i++)
{
WorkoutSet workoutSet = new WorkoutSet();
workoutSet.Reps = sets[i];
workoutSet.SetOrder = i + 1;
workoutSet.ExerciseId = exercise.ExerciseID;
workoutSet.DateCreated = DateTime.Now;
workoutSet.Workout = workout;
workoutSet.ExerciseId = exercise.ExerciseID;
workoutSet.Active = true;
workoutSets.Add(workoutSet);
}
}
return(workoutSets);
}
public HttpResponseMessage DeleteWorkoutSet(long id)
{
try
{
// Выбираем сет с переданным идентификатором и созданный пользователем
WorkoutSet workoutSet = unitOfWork.WorkoutSetRepository.Get(
f => (f.WorkoutSetId == id && f.WorkoutDiaryEntry.CreateUserId == currentUserId),
null,
iW => iW.WorkoutDiaryEntry,
iE => iE.WorkoutDiaryEntry.Exercise)
.SingleOrDefault();
// Записи нет в БД
if (workoutSet == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
//WorkoutSet workoutSet = unitOfWork..Get(
// f => (f.WorkoutSetId == id && f.WorkoutDiaryEntry.CreateUserId == currentUserId),
// null)
// .SingleOrDefault();
workoutSet.WorkoutDiaryEntry.CreationInfo.LastModifiedTimeUTC = TimeHelper.DateTimeUtcNow;
// Удаляем запись
unitOfWork.WorkoutSetRepository.Delete(workoutSet);
// Меняем значение последнего редактирования родительской записи
unitOfWork.Save();
}
catch (Exception ex)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public WorkoutSet AddWorkoutSet(WorkoutSet workoutSet)
{
_appDbContext.WorkoutSets.Add(workoutSet);
_appDbContext.SaveChanges();
var newWorkOutSet = _appDbContext.WorkoutSets
.Where(x => x.Id == workoutSet.Id)
.Include(x => x.Excercise)
.FirstOrDefault();
return(newWorkOutSet);
}
public IActionResult AddNewWorkoutSet([FromBody] WorkoutSet workoutSet)
{
if (workoutSet == null)
{
return(BadRequest());
}
if (workoutSet.TimeStamp == default(DateTime))
{
workoutSet.TimeStamp = DateTime.Now;
}
_workoutSetRepository.AddWorkoutSet(workoutSet);
return(Ok(workoutSet));
}
public WorkoutSet EditWorkoutSet(WorkoutSet workoutSet)
{
var update = _appDbContext.WorkoutSets.FirstOrDefault(x => x.Id == workoutSet.Id);
if (update == null)
{
throw new InvalidOperationException("Cannot find set to be updated!");
}
update.Reps = workoutSet.Reps;
update.Weight = workoutSet.Weight;
_appDbContext.SaveChanges();
var retrieve = _appDbContext.WorkoutSets
.Include(x => x.Excercise)
.FirstOrDefault(x => x.Id == update.Id);
return(retrieve);
}
// Inserts new set
public int insertWorkoutSet(WorkoutSet set)
{
try
{
string connString = ConfigurationManager.ConnectionStrings["SwimDBConnectionString"].ConnectionString;
conn = new SqlConnection(ConfigurationManager.ConnectionStrings["SwimDBConnectionString"].ConnectionString);
conn.Open();
cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = "insertWorkoutSet";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@strokeID", set.Stroke.ID);
cmd.Parameters.Add("@repeats", set.Repeats);
cmd.Parameters.Add("@distance", set.WorkoutSetDistance);
cmd.Parameters.Add("@description", set.Description);
cmd.Parameters.Add("@paceTime", set.PaceTime);
cmd.Parameters.Add("@restPeriod", set.RestPeriod);
cmd.Parameters.Add("@E1", set.E1);
cmd.Parameters.Add("@E2", set.E2);
cmd.Parameters.Add("@E3", set.E3);
cmd.Parameters.Add("@S1", set.S1);
cmd.Parameters.Add("@S2", set.S2);
cmd.Parameters.Add("@S3", set.S3);
cmd.Parameters.Add("@REC", set.REC);
cmd.Parameters.Add("@duration", set.SingleDuration);
int setId = (int)cmd.ExecuteScalar();
conn.Close();
return(setId);
}
catch (Exception e)
{
return(-1);
}
}
public IActionResult UpdateWorkoutSet(WorkoutSet workoutSet)
{
if (workoutSet == null || workoutSet.Id == Guid.Empty)
{
return(BadRequest());
}
try
{
_workoutSetRepository.EditWorkoutSet(workoutSet);
}
catch (InvalidOperationException ex)
{
Console.WriteLine(ex);
return(BadRequest(ex));
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(Ok(workoutSet));
}
public ActionResult editSet(FormCollection form) //Code not relevant now, as now there's a better way to update the model.
{
Strokes_BLL strokes = new Strokes_BLL();
WorkoutSet workoutSet = new WorkoutSet();
workoutSet.Repeats = int.Parse(form["item.Repeats"]);
workoutSet.ID = int.Parse(form["item.ID"]);
workoutSet.WorkoutSetDistance = int.Parse(form["item.WorkoutSetDistance"]);
workoutSet.SingleDuration = int.Parse(form["item.SingleDuration"]);
workoutSet.OrderNum = int.Parse(form["item.OrderNum"]);
workoutSet.PaceTime = int.Parse(form["item.PaceTime"]);
workoutSet.Description = form["item.Description"];
workoutSet.Stroke = strokes.getStrokes(int.Parse(form["strokeSelect"]));
List <WorkoutSet> _workoutSets = Session["WorkoutSetList"] as List <WorkoutSet>;
_workoutSets[workoutSet.OrderNum - 1] = workoutSet;
// _workoutSets.Add(new WorkoutSet(_workoutSets.Count + 1));
Session["WorkoutSetList"] = _workoutSets;
return(Json(new { success = true }));
}
}//end of getWorkOutPlanIds method
public WorkoutPlan getWorkOutPlan(int id)
{
WorkoutPlan workoutplan = new WorkoutPlan();
List <WorkoutSet> listOfSets = new List <WorkoutSet>();
try{
conn = new SqlConnection(ConfigurationManager.ConnectionStrings["SwimDBConnectionString"].ConnectionString);
conn.Open();
cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = "getworkoutplan";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@workoutplanID", id);
reader = cmd.ExecuteReader();
workoutplan.ID = id;
while (reader.Read())
{
if (workoutplan.Date == null || workoutplan.Date == "")
{
workoutplan.Date = reader["planDate"].ToString();
}
WorkoutSet WOSet = new WorkoutSet();
WorkoutStroke stroke = new WorkoutStroke();
WOSet.ID = Convert.ToInt32(reader["Set_Id"]);
stroke.ID = Convert.ToInt32(reader["Stroke_Id"]);
stroke.Name = reader["Name"].ToString();
stroke.Description = reader["Stroke_Desc"].ToString();
//listOfValues.Add("Member_Id", reader["Member_Id"].ToString());
WOSet.OrderNum = Convert.ToInt32(reader["memberOrder"]);
// listOfValues.Add("planDate",reader["planDate"].ToString());
WOSet.Repeats = Convert.ToInt32(reader["repeats"]);
WOSet.WorkoutSetDistance = Convert.ToInt32(reader["distance"]);
WOSet.Description = reader["Set_Desc"].ToString();
WOSet.PaceTime = Convert.ToInt32(reader["paceTime"]);
WOSet.RestPeriod = Convert.ToInt32(reader["restPeriod"]);
WOSet.Stroke = stroke;
WOSet.E1 = Convert.ToInt32(reader["E1"]);
WOSet.E2 = Convert.ToInt32(reader["E2"]);
WOSet.E3 = Convert.ToInt32(reader["E3"]);
WOSet.S1 = Convert.ToInt32(reader["S1"]);
WOSet.S2 = Convert.ToInt32(reader["S2"]);
WOSet.S3 = Convert.ToInt32(reader["S3"]);
WOSet.REC = Convert.ToInt32(reader["REC"]);
WOSet.SingleDuration = Convert.ToInt32(reader["duration"]);
listOfSets.Add(WOSet);
}
workoutplan.WorkoutSet = listOfSets;
conn.Close();
}
catch (Exception)
{
// List<string> listOfValues = new List<string>();
// listOfValues.Add("Error");
// listOfSets.Add();
return(null);
}
return(workoutplan);
}
public ActionResult StartSet([FromRoute] int workoutId, int workoutSetId, bool lastSet, int currentExerciseId, int workoutSessionId)
{
if (workoutSessionId == 0)
{
WorkoutSession workoutSession = new WorkoutSession {
DateCreated = DateTime.Now
};
_context.WorkoutSession.Add(workoutSession);
_context.SaveChanges();
workoutSessionId = workoutSession.WorkoutSessionId;
}
int exerciseId = 0;
Exercise exercise = null;
List <WorkoutToExercise> wtes = _context.WorkoutToExercise
.Where(we => we.WorkoutId == workoutId && we.Active)
.OrderBy(wte => wte.Order).ToList();
List <Exercise> exercises = _context.Exercise
.Where(e => wtes.Select(wte => wte.ExerciseId)
.Contains(e.ExerciseId)).ToList();
bool workoutComplete = false;
if (workoutSetId == 0) //firstSet
{
exerciseId = wtes.OrderBy(x => x.Order).First().ExerciseId;
}
else if (lastSet) //last set -- need next exercise
{
int currentOrder = wtes.Where(wte => wte.ExerciseId == currentExerciseId).First().Order;
WorkoutToExercise workoutToExercise = wtes.Where(wte => wte.Order == currentOrder + 1).FirstOrDefault();
if (workoutToExercise == null)
{
workoutComplete = true;
}
else
{
exerciseId = wtes.Where(wte => wte.Order == currentOrder + 1).FirstOrDefault().ExerciseId;//is null posible here?
}
}
else
{
exerciseId = currentExerciseId;
}
if (workoutComplete)
{
return(View("WorkoutComplete"));
}
exercise = exercises.Where(e => e.ExerciseId == exerciseId).Single();
var workoutSets = _context.WorkoutSet
.Where(ws => ws.WorkoutId == workoutId && ws.ExerciseId == exerciseId && ws.Active)
.OrderBy(x => x.SetOrder).ToList();
WorkoutSet currentWorkoutSet = null;
bool nextSetIsLast = false;
WorkoutSet nextWorkoutSet = null;
SetViewModel setViewModel = null;
WorkoutSetResult previousResult = null;
if (workoutSetId == 0 || lastSet)
{
workoutSetId = workoutSets.Where(ws => ws.ExerciseId == exercise.ExerciseId).OrderBy(ws => ws.SetOrder).First().WorkoutSetId;
nextWorkoutSet = workoutSets.Where(ws => ws.WorkoutSetId == workoutSetId).First();
nextSetIsLast = nextWorkoutSet.SetOrder == workoutSets.Select(ws => ws.SetOrder).Max();
previousResult = GetLastWorkoutSetResult(nextWorkoutSet.WorkoutSetId);
if (workoutSessionId == 0 && (DateTime.Now - previousResult.DateCreated).TotalMinutes < 60)
{
workoutSessionId = previousResult.WorkoutSessionId;
}
setViewModel = new SetViewModel(previousResult);
setViewModel.Exercise = exercise;
setViewModel.WorkoutSet = nextWorkoutSet;
setViewModel.WorkoutId = workoutId;
setViewModel.IsLastSet = nextSetIsLast;
setViewModel.PreviousWorkoutSetResult = previousResult;
ModelState.SetModelValue("workoutSessionId", new ValueProviderResult(new Microsoft.Extensions.Primitives.StringValues(workoutSessionId.ToString()), CultureInfo.InvariantCulture));
return(View("Set", setViewModel));
}
currentWorkoutSet = workoutSets.Where(ws => ws.WorkoutSetId == workoutSetId).First();
nextWorkoutSet = workoutSets.Where(ws => ws.ExerciseId == exerciseId && ws.SetOrder > currentWorkoutSet.SetOrder).First();
nextSetIsLast = nextWorkoutSet.SetOrder == workoutSets.Select(ws => ws.SetOrder).Max();
previousResult = GetLastWorkoutSetResult(nextWorkoutSet.WorkoutSetId);
if (workoutSessionId == 0 && (DateTime.Now - previousResult.DateCreated).TotalMinutes < 60)
{
workoutSessionId = previousResult.WorkoutSessionId;
}
setViewModel = new SetViewModel(previousResult);
setViewModel.Exercise = exercise;
setViewModel.WorkoutSet = nextWorkoutSet;
setViewModel.WorkoutId = workoutId;
setViewModel.IsLastSet = nextSetIsLast;
setViewModel.PreviousWorkoutSetResult = previousResult;
ModelState.SetModelValue("workoutSessionId", new ValueProviderResult(new Microsoft.Extensions.Primitives.StringValues(workoutSessionId.ToString()), CultureInfo.InvariantCulture));
return(View("Set", setViewModel));
}
public ActionResult StartSet([FromRoute] int workoutId, int workoutSetId, bool lastSet, int currentExerciseId, int workoutSessionId)
{
//check if session is active
//if so, get workoutid, workoutsetid, lastset, current
int exerciseId = 0;
Exercise exercise = null;
List <WorkoutToExercise> wtes = _context.WorkoutToExercise
.Where(we => we.WorkoutId == workoutId && we.Active)
.OrderBy(wte => wte.Order).ToList();
List <Exercise> exercises = _context.Exercise
.Where(e => wtes.Select(wte => wte.ExerciseId)
.Contains(e.ExerciseId)).ToList();
//get last session
WorkoutSession lastWorkoutSession = null;
WorkoutSet currentWorkoutSet = null;
WorkoutSet nextWorkoutSet = null;
List <WorkoutSet> workoutSets = null;
bool needToGetCurrentSessionInfo = false;
if (workoutSessionId == 0)
{
lastWorkoutSession = _context.WorkoutSession.Where(ws => (DateTime.Now - ws.DateCreated).TotalHours < 1).FirstOrDefault();
if (lastWorkoutSession != null)
{
needToGetCurrentSessionInfo = true;
}
}
List <WorkoutSetResult> workoutSetResults = null;
if (lastWorkoutSession != null)
{
workoutSetResults = _context.WorkoutSetResult.Where(wsr => wsr.WorkoutSessionId == lastWorkoutSession.WorkoutSessionId).ToList();
}
//need to check if session started with different workout
//if(workoutSetResults.Where(wsr => wsr.))
//{
//}
if (needToGetCurrentSessionInfo)
{
wtes = _context.WorkoutToExercise
.Where(we => we.WorkoutId == workoutId && we.Active)
.OrderBy(wte => wte.Order).ToList();
var lastCompletedWorkoutSetResult = workoutSetResults.OrderByDescending(wsr => wsr.WorkoutSetResultId).First();
workoutSetId = lastCompletedWorkoutSetResult.WorkoutSetId;
var currentWorkoutSetHere = _context.WorkoutSet
.Where(ws => ws.WorkoutSetId == workoutSetId)
.Single();
//is lastCompletedWorkoutSetResult the last set?
currentExerciseId = currentWorkoutSetHere.ExerciseId;
var workoutSetsHere = _context.WorkoutSet.Where(ws => ws.WorkoutId == workoutId && ws.ExerciseId == currentExerciseId).ToList();
if (workoutSetsHere.Count == 0) //user has started session, but switched workouts.what if workout edited in middle of session?
{
workoutSetId = 0;
lastSet = false;
currentExerciseId = 0;
}
else if (workoutSetsHere.Count == 1)
{
lastSet = true;
}
else
{
lastSet = workoutSetsHere.OrderByDescending(wsh => wsh.SetOrder).First().WorkoutSetId == workoutSetId;
}
}
if (workoutSessionId == 0 && lastWorkoutSession != null)
{
workoutSessionId = lastWorkoutSession.WorkoutSessionId;
}
if (workoutSessionId == 0)
{
WorkoutSession workoutSession = new WorkoutSession {
DateCreated = DateTime.Now
};
_context.WorkoutSession.Add(workoutSession);
_context.SaveChanges();
workoutSessionId = workoutSession.WorkoutSessionId;
}
bool workoutComplete = false;
if (workoutSetId == 0) //firstSet
{
exerciseId = wtes.First().ExerciseId;
}
else if (lastSet) //last set -- need next exercise
{
int currentOrder = wtes.Where(wte => wte.ExerciseId == currentExerciseId).First().Order;
WorkoutToExercise workoutToExercise = wtes.FirstOrDefault(wte => wte.Order > currentOrder);
if (workoutToExercise == null)
{
workoutComplete = true;
}
else
{
exerciseId = workoutToExercise.ExerciseId;//is null posible here?
}
}
else
{
exerciseId = currentExerciseId;
}
if (workoutComplete)
{
return(View("WorkoutComplete"));
}
exercise = exercises.Where(e => e.ExerciseId == exerciseId).Single();
workoutSets = _context.WorkoutSet
.Where(ws => ws.WorkoutId == workoutId && ws.ExerciseId == exerciseId && ws.Active)
.OrderBy(x => x.SetOrder).ToList();
bool nextSetIsLast = false;
SetViewModel setViewModel = null;
PreviousSetResult previousResult = null;
if (workoutSetId == 0 || lastSet)
{
workoutSetId = workoutSets.Where(ws => ws.ExerciseId == exercise.ExerciseId).OrderBy(ws => ws.SetOrder).First().WorkoutSetId;
nextWorkoutSet = workoutSets.Where(ws => ws.WorkoutSetId == workoutSetId).First();
nextSetIsLast = nextWorkoutSet.SetOrder == workoutSets.Select(ws => ws.SetOrder).Max();
previousResult = GetLastWorkoutSetResult(nextWorkoutSet.WorkoutSetId, workoutSessionId);
if (previousResult.WorkoutSetResult != null && (DateTime.Now - previousResult.WorkoutSetResult.DateCreated).TotalMinutes < 60)
{
workoutSessionId = previousResult.WorkoutSetResult.WorkoutSessionId;
}
setViewModel = new SetViewModel(previousResult);
setViewModel.Exercise = exercise;
setViewModel.WorkoutSet = nextWorkoutSet;
setViewModel.WorkoutId = workoutId;
setViewModel.IsLastSet = nextSetIsLast;
ModelState.SetModelValue("workoutSessionId", new ValueProviderResult(new Microsoft.Extensions.Primitives.StringValues(workoutSessionId.ToString()), CultureInfo.InvariantCulture));
return(View("Set", setViewModel));
}
currentWorkoutSet = workoutSets.Where(ws => ws.WorkoutSetId == workoutSetId).First();
nextWorkoutSet = workoutSets.Where(ws => ws.ExerciseId == exerciseId && ws.SetOrder > currentWorkoutSet.SetOrder).First();
nextSetIsLast = nextWorkoutSet.SetOrder == workoutSets.Select(ws => ws.SetOrder).Max();
previousResult = GetLastWorkoutSetResult(nextWorkoutSet.WorkoutSetId, workoutSessionId);
if (previousResult.WorkoutSetResult != null && (DateTime.Now - previousResult.WorkoutSetResult.DateCreated).TotalMinutes < 60)
{
workoutSessionId = previousResult.WorkoutSetResult.WorkoutSessionId;
}
setViewModel = new SetViewModel(previousResult);
setViewModel.Exercise = exercise;
setViewModel.WorkoutSet = nextWorkoutSet;
setViewModel.WorkoutId = workoutId;
setViewModel.IsLastSet = nextSetIsLast;
ModelState.SetModelValue("workoutSessionId", new ValueProviderResult(new Microsoft.Extensions.Primitives.StringValues(workoutSessionId.ToString()), CultureInfo.InvariantCulture));
return(View("Set", setViewModel));
}
public void RemoveWorkoutSet(WorkoutSet workoutSet)
{
_appDbContext.WorkoutSets.Remove(workoutSet);
_appDbContext.SaveChanges();
}
