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(); }