public void WorkOutTest1()
{
string exName = "New exercise1";
StrTrain newEx = new StrTrain(exName);
newEx.Sets.Add(10);
newEx.Sets.Add(12);
newEx.Sets.Add(11);
newEx.Sets.Add(10);
newEx.Sets.Add(14);
string exNameOther = "New exercise2";
StrTrain newExOther = new StrTrain(exNameOther);
newExOther.Sets.Add(10);
newExOther.Sets.Add(10);
newExOther.Sets.Add(10);
newExOther.Sets.Add(10);
newExOther.Sets.Add(10);
WorkOut work = new WorkOut();
work.ExerciseList.Add(newEx);
work.ExerciseList.Add(newExOther);
work.ExerciseList.Add(new Cardio("Sprints123", new int[] { 40 }));
work.Date = new DateTime(2011, 3, 19);
work.Length = 50;
WorkOutRepository Repos1 = new WorkOutRepository();
//Repos1.Load();
// Repos1.Save(work);
}
public IHttpActionResult Post(int Id, string WorkOutTitle, string WorkOutNote, int CaloriesBurnPerMin, int CategoryId)
{
try
{
WorkOut model = new WorkOut()
{
CaloriesBurnPerMin = CaloriesBurnPerMin,
CategoryId = CategoryId,
Created = DateTime.Now,
WorkOutNote = WorkOutNote,
WorkOutTitle = WorkOutTitle,
WorkOutId = Id
};
if (dao.Update(model))
{
return(Ok("Record Updated Successfully"));
}
else
{
return(BadRequest("Error Occurred"));
}
}
catch (Exception ex)
{
return(BadRequest("Error Occurred"));
}
}
public workoutactive EndWorkOut(int Id, int WorkOutId)
{
try
{
workoutactive result = null;
WorkOut workout = db.WorkOutCollection.FirstOrDefault(a => a.WorkOutId == WorkOutId);
Workout_Active workoutactive = db.WorkOutsActive.FirstOrDefault(a => a.WorkOutId == WorkOutId && a.Id == Id);
if (workout != null && workoutactive != null)
{
result = new workoutactive()
{
Id = workoutactive.Id,
WorkOutId = workout.WorkOutId,
WorkOutComment = workoutactive.Comment,
WorkOutTitle = workout.WorkOutTitle,
StartDate = DateTime.Now,
StartTime = DateTime.Now.ToLocalTime().ToShortTimeString()
};
}
return(result);
}
catch (Exception ex)
{
return(new workoutactive());
}
}
private static void CreateWorkOuts()
{
Realm realm = Realm.GetInstance(GetConfigurationBase());
using (Transaction transaction = realm.BeginWrite())
{
try
{
foreach (int code in WorkOuts.Keys)
{
WorkOut workOut = realm.Find <WorkOut>(code);
if (workOut == null)
{
workOut = CreateWorkOut(realm, code);
}
}
transaction.Commit();
}
catch (Exception ex)
{
Debug.WriteLine("=== PROBLEM: {0}", ex.Message);
transaction.Rollback();
}
finally
{
realm.Dispose();
}
}
}
public async Task <IActionResult> PutWorkOut([FromRoute] int id, [FromBody] WorkOut workOut)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != workOut.Id)
{
return(BadRequest());
}
_context.Entry(workOut).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkOutExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static int ReturnFee(WorkOut w)
{
int price = 0;
XmlDbData xdb = XmlDbData.ReadData("WorkOutConfig");
if ((xdb != null) && (xdb.Tables != null))
{
XmlDbTable table;
if (xdb.Tables.TryGetValue("WorkOut", out table) && (table != null))
{
foreach (XmlDbRow row in table.Rows)
{
switch (w)
{
case WorkOut.Swim:
price = row.GetInt("swimfee");
break;
case WorkOut.WorkOut:
price = row.GetInt("workoutfee");
break;
default:
break;
}
}
}
}
return(price);
}
public void CreateWorkOut(WorkOutVM wo)
{
var workout = new WorkOut
{
WorkOutId = wo.Id,
WorkOutName = wo.Name
};
if (workout.WorkOutId == 0)
{
_repo.Add(workout);
}
else
{
_repo.Update(workout);
}
foreach (var exercise in wo.Exercises)
{
var we = new WorkOutExercise();
we.ExerciseId = exercise.ExerciseID;
we.WorkOutId = workout.WorkOutId;
_repo.Add(we);
}
}
public ActionResult DeleteConfirmed(int id)
{
WorkOut workOut = db.WorkOuts.Find(id);
db.WorkOuts.Remove(workOut);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,Content,Title,WeightChange,minAge,maxAge,Category,ForGender,ProgressTime,Link")] WorkOut workOut)
{
if (ModelState.IsValid)
{
db.Entry(workOut).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workOut));
}
private static WorkOut CreateWorkOut(Realm realm, int code)
{
WorkOut workOut = new WorkOut();
workOut.Code = code;
workOut.Description = WorkOuts[code];
realm.Add(workOut);
return(workOut);
}
public Task <bool> DeleteAsync(WorkOut item)
{
var delete = _database.Where(WorkOut => WorkOut.Id == item.Id).FirstOrDefault();
if (delete != null)
{
_database.Remove(delete);
return(Task.FromResult(true));
}
return(Task.FromResult(false));
}
public ActionResult Create([Bind(Include = "Id,Content,Title,WeightChange,minAge,maxAge,Category,ForGender,ProgressTime,Link")] WorkOut workOut)
{
if (ModelState.IsValid)
{
db.WorkOuts.Add(workOut);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workOut));
}
public async Task <IActionResult> Post([FromBody] WorkOut workOut)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.WorkOutList.Add(workOut);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetWorkOut", new { id = workOut.Id }, workOut));
}
public bool Delete(int Id)
{
try
{
WorkOut WorkOut = db.WorkOutCollection.Find(Id);
db.WorkOutCollection.Remove(WorkOut);
db.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public bool Add(WorkOut model)
{
try
{
model.Created = DateTime.Now;
db.WorkOutCollection.Add(model);
db.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public async Task <WorkOut> AddAsync(WorkOut item)
{
var results = new List <ValidationResult>();
var validation = new ValidationContext(item);
if (Validator.TryValidateObject(item, validation, results))
{
return(await _client.For <WorkOut>().Set(item).InsertEntryAsync());
}
else
{
throw new ValidationException();
}
}
// GET: WorkOuts/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
WorkOut workOut = db.WorkOuts.Find(id);
if (workOut == null)
{
return(HttpNotFound());
}
return(View(workOut));
}
/// <summary>
/// Add a new workout and save all to file
/// </summary>
/// <param name="work"></param>
public void Save(WorkOut work)
{
if (!(workoutRepository.allWorkOuts == null))
{
Load();
}
#warning Insert logic to check for existing date
workoutRepository.AddToCollection(work);
using (StreamWriter stream = File.CreateText(DataFile)) //rewrites the file each time
{
stream.Write(JsonConvert.SerializeObject(workoutRepository.allWorkOuts));
}
}
public Task <WorkOut> AddAsync(WorkOut item)
{
var results = new List <ValidationResult>();
var validation = new ValidationContext(item);
if (Validator.TryValidateObject(item, validation, results))
{
item.Id = _database.Max(WorkOut => WorkOut.Id) + 1;
_database.Add(item);
return(Task.FromResult(item));
}
else
{
throw new ValidationException();
}
}
public async Task <WorkOut> UpdateAsync(WorkOut item)
{
var results = new List <ValidationResult>();
var validation = new ValidationContext(item);
if (Validator.TryValidateObject(item, validation, results))
{
await _client.For <WorkOut>().Key(item.Id).Set(item).UpdateEntryAsync();
return(item);
}
else
{
throw new ValidationException();
}
}
public Task <WorkOut> UpdateAsync(WorkOut item)
{
var results = new List <ValidationResult>();
var validation = new ValidationContext(item);
if (Validator.TryValidateObject(item, validation, results))
{
var dbItem = _database.Where(WorkOut => WorkOut.Id == item.Id).First();
if (!dbItem.Complete && item.Complete)
{
dbItem.MarkComplete();
}
dbItem.Description = item.Description;
return(Task.FromResult(dbItem));
}
else
{
throw new ValidationException();
}
}
public workoutactive StartWorkOut(int Id)
{
try
{
WorkOut workout = db.WorkOutCollection.FirstOrDefault(a => a.WorkOutId == Id);
workoutactive result = new workoutactive()
{
WorkOutId = workout.WorkOutId,
WorkOutComment = "",
WorkOutTitle = workout.WorkOutTitle,
StartDate = DateTime.Now,
StartTime = DateTime.Now.ToLocalTime().ToShortTimeString()
};
return(result);
}
catch (Exception ex)
{
return(new workoutactive());
}
}
public async Task <IActionResult> Patch([FromODataUri] int id, [FromBody] WorkOut workOut)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != workOut.Id)
{
return(BadRequest());
}
var check = _context.WorkOutList.Where(item => item.Id == workOut.Id).First();
if (!check.Complete && workOut.Complete)
{
check.MarkComplete();
}
check.Description = workOut.Description;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkOutExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public bool Update(WorkOut model)
{
try
{
WorkOut editWorkout = db.WorkOutCollection.Find(model.WorkOutId);
if (editWorkout != null)
{
editWorkout.WorkOutTitle = model.WorkOutTitle;
editWorkout.WorkOutNote = model.WorkOutNote;
editWorkout.CategoryId = model.CategoryId;
model.Updated = DateTime.Now;
db.Entry(editWorkout).CurrentValues.SetValues(model);
db.SaveChanges();
}
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public int AddWorkout(AddWorkoutModelRequest objAddWorkoutModelRequest, Int64 UserId)
{
WorkOut objWork = new WorkOut()
{
UserId = objAddWorkoutModelRequest.UserId,
Description = objAddWorkoutModelRequest.Description,
DateOfWorkout = objAddWorkoutModelRequest.DateOfWorkout,
StartTime = objAddWorkoutModelRequest.StartTime,
FinishTime = objAddWorkoutModelRequest.FinishTime,
WorkoutNotes = objAddWorkoutModelRequest.WorkoutNotes,
Createdate = System.DateTime.Now,
CreatedBy = UserId,
IsActive = true,
RowStatus = true,
StatusId = 2,
AutoFinishTime = objAddWorkoutModelRequest.AutoFinishTime,
ScheduleWorkout = false
};
_objFriendFitDBEntity.WorkOuts.Add(objWork);
_objFriendFitDBEntity.SaveChanges();
return(1);
}
// GET: WorkOuts/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
WorkOut workOut = db.WorkOuts.Find(id);
if (workOut == null)
{
return(HttpNotFound());
}
WorkOutViewModel model = new WorkOutViewModel();
model.WorkOut = workOut;
int category = db.WorkOuts.Find(id).Category;
model.DietPlans = db.DietPlans.Where(d => d.Category == category).ToList();
model.Exercises = db.Exercises.ToList();
model.DayPerWeeks = db.DayPerWeeks.ToList();
model.Schedules = db.Schedules.ToList();
model.Resources = db.Resources.ToList();
return(View(model));
}
public async Task <bool> DeleteAsync(WorkOut item)
{
await _client.For <WorkOut>().Key(item.Id).DeleteEntryAsync();
return(true);
}
private void SaveWorkOut(object obj)
{
viewModelDataService.Save(TempWorkOut);
TempWorkOut = new WorkOut();
#warning NEED TO CLEAR DATE AND LENGTH BOX
}
public static int ReturnFee(WorkOut w)
{
int price = 0;
XmlDbData xdb = XmlDbData.ReadData("WorkOutConfig");
if ((xdb != null) && (xdb.Tables != null))
{
XmlDbTable table;
if (xdb.Tables.TryGetValue("WorkOut", out table) && (table != null))
{
foreach (XmlDbRow row in table.Rows)
{
switch (w)
{
case WorkOut.Swim:
price = row.GetInt("swimfee");
break;
case WorkOut.WorkOut:
price = row.GetInt("workoutfee");
break;
default:
break;
}
}
}
}
return price;
}
public Task <WorkOut> UpdateAsync(WorkOut item)
{
throw new NotImplementedException();
}
public Task <bool> DeleteAsync(WorkOut item)
{
throw new NotImplementedException();
}
