private void ButtonAgregarEliminar_Click(object sender, RoutedEventArgs e)
{
WorkoutModel workout = DataGridWorkout.SelectedItem as WorkoutModel;
if (workout != null)
{
GRDialogConsultation _var = new GRDialogConsultation();
_var.Message = "Eliminar Registro Selecionado?";
if (_var.ShowDialog() == true)
{
int id = workout.Id;
var result = _workout.DeleteUpdate(id);
if (result)
{
MyCollection.Remove(workout);
DataGridWorkout.ItemsSource = MyCollection.OrderBy(a => a.Name);
DataGridWorkout.Items.Refresh();
lblTotalReg.Content = "Cantidad de Registro: " + MyCollection.Count;
}
}
}
else
{
GRDialogInformation _msg = new GRDialogInformation();
_msg.Message = "Debe Seleccionar un Registro";
_msg.ShowDialog();
}
}
public bool Update(WorkoutModel aModel)
{
bool result = false;
//await Task.Run(() =>
//{
try
{
var getToUpdate = context.Workout.First(a => a.Id == aModel.Id);
getToUpdate.Code = aModel.CodigoWorkout;
getToUpdate.Name = aModel.Name;
getToUpdate.Description = aModel.Description;
getToUpdate.Active = aModel.Active;
getToUpdate.Parent = aModel.Parent == 0 ? null : aModel.Parent; //aModel.Parent;
getToUpdate.Color = aModel.Color;
getToUpdate.DateUpdated = aModel.DateUpdated;
context.Entry(getToUpdate).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
return(true);
}
catch (Exception ex)
{
result = false;
}
//});
return(result);
}
public async Task <IActionResult> Post(WorkoutModel workoutModel)
{
try
{
var userId = User.GetUserId();
if (!ModelState.IsValid)
{
return(BadRequest());
}
var workout = mapper.Map <Workout>(workoutModel);
workout.ApplicationUserId = userId;
await workoutRepository.AddWorkoutAsync(workout);
if (await workoutRepository.CommitAsync())
{
workoutModel = mapper.Map <WorkoutModel>(workout);
return(Ok(workoutModel));
}
return(BadRequest());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Internal Server Error"));
}
}
public static Workout MapToWorkout(this WorkoutModel workoutModel)
{
var workout = new Workout()
{
TemplateId = new Guid(workoutModel.Template.Id),
NumberOfRepetitions = workoutModel.NumberOfRepetitions,
IsSuccessfull = workoutModel.Successfull,
AverageRepetitionDuration = workoutModel.AverageRepetitionDuration,
AverageRepetitionAcceleration = workoutModel.AverageVelocity,
AverageTilt = workoutModel.AverageTilt,
Date = workoutModel.Date,
Duration = workoutModel.Duration
};
foreach (var value in workoutModel.AccelerationValues)
{
workout.AccelerationValues += value.Value + "," + value.Timestamp + ";";
}
foreach (var value in workoutModel.VelocityValues)
{
workout.VelocityValues += value.Value + "," + value.Timestamp + ";";
}
foreach (var value in workoutModel.TiltValues)
{
workout.TiltValues += value.Value + "," + value.Timestamp + ";";
}
return(workout);
}
public int Add(WorkoutModel aModel)
{
int result = 0;
//await Task.Run(() =>
//{
try
{
Workout aNew = new Workout
{
Code = aModel.CodigoWorkout,
Name = aModel.Name,
Description = aModel.Description,
Active = true,
Parent = aModel.Parent == 0? null: aModel.Parent,
Color = aModel.Color,
DateCreated = DateTime.Now
};
context.Workout.Add(aNew);
context.SaveChanges();
result = aNew.Id;
}
catch (Exception ex)
{
result = 0;
}
//});
return(result);
}
/// <summary>
/// Initializes class instance.
/// </summary>
public DetailsPageViewModel()
{
_workoutModel = WorkoutModel.Instance;
_workoutModel.FinishWorkout();
WorkoutData workoutData = _workoutModel.WorkoutData;
HeaderData = new DetailsHeaderData
{
StartTime = workoutData.StartTime,
LocalTime = workoutData.LocalTime,
Title = "Workout\ndetails"
};
int[] bpmRangeOccurrences = workoutData.BpmRangeOccurrences;
ElapsedTime = string.Format("{0:hh\\.mm\\\'ss}", workoutData.ElapsedTime);
Distance = (workoutData.Distance / 1000).ToString("F2") + " " + SettingsService.Instance.Distance.Unit;
AveragePace = workoutData.Pace.ToString("F2") + " min/" + SettingsService.Instance.Distance.Unit;
Intensity = Array.LastIndexOf(bpmRangeOccurrences, bpmRangeOccurrences.Max()).ToString();
InitCommands();
AddEventListeners();
}
public ActionResult <AllWorkouts> GetAllWorkouts(long id)
{
var userName = User.Claims.Single(a => a.Type == ClaimTypes.NameIdentifier).Value;
var workout = _context.Workouts
.Include(i => i.Exercises).ThenInclude(i => i.Sets)
.Where(i => i.Id == id && i.UserData.User == userName).First();
if (workout == null)
{
return(NotFound("workout not found"));
}
WorkoutModel responseWorkout = new WorkoutModel
{
Id = workout.Id,
Name = workout.WorkoutName,
Exercises = workout.Exercises.Select(i => new ExerciseModel
{
ExerciseName = i.Name,
Id = i.Id,
Type = i.ExerciseType,
Sets = i.Sets.Select(j => new SetModel
{
Id = j.Id,
RepCount = j.RepCount,
Weights = j.Weight
}).ToList()
}).ToList()
};
return(Ok(responseWorkout));
}
public ActionResult Index(WorkoutModel workoutModel)
{
if (ModelState.IsValid)
{
return(View("CreateWorkout", workoutModel));
}
return(View());
}
public ActionResult DeleteConfirmed(int id)
{
WorkoutModel workoutModel = db.WorkoutModels.Find(id);
db.WorkoutModels.Remove(workoutModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void SelectWorkout(WorkoutModel workoutmodel)
{
if (workoutmodel == null)
{
return;
}
SelectedWorkout = null;
}
private async void OnItemSelected(object sender, SelectedItemChangedEventArgs e)
{
if (e.SelectedItem != null)
{
WorkoutModel model = (WorkoutModel)e.SelectedItem;
((ListView)sender).SelectedItem = null;
await Navigation.PushModalAsync(new ExercisesPage(model));
}
}
public ExercisesPage(WorkoutModel model)
{
ExercisesViewModel em = new ExercisesViewModel(model);
em.Navigation = Navigation;
base.Appearing += (o, e) => em.OnAppearing(o, e);
BindingContext = em;
InitializeComponent();
}
public WorkoutOverviewDetailViewModel(WorkoutModel item = null)
{
this.SubWorkoutList = new ObservableCollection <SubWorkoutItemViewModel>();
this.Title = item?.Text;
this.ItemDetail = item;
this.LoadSubWorkouts();
}
public ActionResult Edit([Bind(Include = "Id,maxReps,maxWeight,Name,Notes,Date")] WorkoutModel workoutModel)
{
if (ModelState.IsValid)
{
db.Entry(workoutModel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workoutModel));
}
public ActionResult Details(int id)
{
new WorkoutsRepository().AddView(id);
WorkoutModel model = new WorkoutModel(new WorkoutsRepository().Get(id));
model.BodyParts = new BodyPartsRepository().GetByWorkout(id);
model.Tools = new ToolsRepository().GetByWorkout(id);
return(View(model));
}
public static WorkoutModel Convert(DbWorkoutModel inputModel)
{
WorkoutModel outputModel = new WorkoutModel();
outputModel.titleWorkout = inputModel.Title;
outputModel.trainingId = inputModel.trainingId;
outputModel.lastTrainingDate = inputModel.lastTrainingDate;
return(outputModel);
}
public AbstractModel ListOfTaskName(WorkoutModel workoutModel)
{
//get workout by name
workout _workout = findWorkout(workoutModel.workoutName);
if (_workout == null)
{
return(ResultHelper.boolResult(false, "Workout not exist !!!"));
}
return(ResultHelper.tasksRrssult(workoutModel.workoutName));
}
public ActionResult Create([Bind(Include = "Id,maxReps,maxWeight,Name,Notes,Date")] WorkoutModel workoutModel)
{
if (ModelState.IsValid)
{
db.WorkoutModels.Add(workoutModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workoutModel));
}
public WorkoutDetailPage(WorkoutModel workout)
{
if (workout == null)
{
throw new ArgumentNullException();
}
BindingContext = workout;
InitializeComponent();
}
public ActionResult Create(WorkoutModel workout)
{
if (ModelState.IsValid)
{
workoutContainer.Add(workout, Convert.ToInt32(HttpContext.Session.GetInt32("UserId")));
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public NewItemPage()
{
InitializeComponent();
Item = new WorkoutModel
{
Text = "Item name",
Description = "This is an item description."
};
BindingContext = this;
}
// receives the changed workout and updates current listview and sendable object
void ChangedWorkoutCell(WorkoutModel watchObject)
{
for (int i = 0; i < Workouts.Count; i++)
{
if (Workouts[i].Name == watchObject.Name)
{
Workouts.RemoveAt(i);
Workouts.Insert(i, watchObject);
CollectionToNewWatchModel(Workouts, globalWatchModelHold);
return;
}
}
}
public Task Post([FromBody] WorkoutModel model, CancellationToken token)
{
return(_mediator.Send(new CreateWorkoutCommand
{
UserId = User.Claims.Single(x => x.Type == "Id").Value,
CreatedTime = DateTime.Now,
Description = model.Description,
MoodLevel = (MoodLevelEnum)model.Mood,
FatigueLevel = (FatigueLevelEnum)model.Fatigue,
ExecutionTime = model.DateOfWorkout,
ExerciseExecutions = model.Exercises,
WorkoutName = model.Name
}, token));
}
// GET: WorkoutModels/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
WorkoutModel workoutModel = db.WorkoutModels.Find(id);
if (workoutModel == null)
{
return(HttpNotFound());
}
return(View(workoutModel));
}
public async Task <IActionResult> Patch(string workoutName, [FromBody] WorkoutModel model, CancellationToken token)
{
await _mediator.Send(new UpdateWorkoutCommand
{
WorkoutName = workoutName,
UserId = User.Claims.Single(x => x.Type == "Id").Value,
MoodLevel = (MoodLevelEnum)model.Mood,
FatigueLevel = (FatigueLevelEnum)model.Fatigue,
ExecutionTime = model.DateOfWorkout,
ExerciseExecutions = model.Exercises
}, token);
return(Ok());
}
/// <summary>
/// Initializes class instance.
/// </summary>
public DetailsPageViewModel()
{
_workoutModel = WorkoutModel.Instance;
_workoutModel.FinishWorkout();
WorkoutData workoutData = _workoutModel.WorkoutData;
HeaderData = new DetailsHeaderData
{
StartTime = workoutData.StartTime,
LocalTime = workoutData.LocalTime,
Title = "Workout\ndetails"
};
int[] bpmRangeOccurrences = workoutData.BpmRangeOccurrences;
ItemsData = new List <DetailsItemData>
{
new DetailsItemData
{
Name = "time",
Value = string.Format("{0:hh\\.mm\\\'ss}", workoutData.ElapsedTime),
Icon = "images/details_time_icon.png"
},
new DetailsItemData
{
Name = "distance",
Value = (workoutData.Distance / 1000).ToString("F2") + " " + SettingsService.Instance.Distance.Unit,
Icon = "images/details_distance_icon.png"
},
new DetailsItemData
{
Name = "average pace",
Value = workoutData.Pace.ToString("F2") + " min/" + SettingsService.Instance.Distance.Unit,
Icon = "images/details_average_pace_icon.png"
},
new DetailsItemData
{
Name = "intensity",
Value = Array.LastIndexOf(bpmRangeOccurrences, bpmRangeOccurrences.Max()).ToString(),
Icon = "images/details_intensity_icon.png",
IsActionButtonVisible = true
}
};
InitCommands();
AddEventListeners();
}
public void Add(WorkoutModel workout, int userId)
{
using (SqlConnection connection = new SqlConnection(AppSettingsJson.GetConnectionstring()))
{
connection.Open();
string query = @"insert into [Workouts] (Name, Skillevel, Category, Time, CaloriesBurned) values ('" + workout.Name + "','" +
workout.Skillevel + "','" + workout.Category + "','" + workout.Time + "', '" + workout.Time * 4 + "')";
SqlCommand qry = new SqlCommand(query, connection);
qry.ExecuteNonQuery();
string userExerciseQuery = @"insert into [User_Workout] (UserId, WorkoutId) values ('" + userId + "','" + workout.Id + "')";
SqlCommand userExerciseQry = new SqlCommand(userExerciseQuery, connection);
userExerciseQry.ExecuteNonQuery();
}
}
public void AddWorkout()
{
WorkoutModel selectedWorkout = SelectedWorkout;
NotifyOfPropertyChange(() => CanAddWorkout);
try
{
WorkoutHistory.Add(SelectedWorkout.WorkoutName, Convert.ToDateTime(WorkoutDate));
AddWorkoutSuccessful = "Workout Added Successfully";
}
catch (Exception ex)
{
AddWorkoutSuccessful = ex.Message;
}
}
WorkoutModel SaveEdit()
{
WorkoutModel sendBackObject = new WorkoutModel();
sendBackObject.Name = WorkoutName;
sendBackObject.Rep = "Reps: " + RepString;
foreach (var item in tempList)
{
if (string.IsNullOrEmpty(item.WeightAmount))
{
item.WeightAmount = "0";
}
sendBackObject.Weight += item.WeightAmount + " | ";
}
return(sendBackObject);
}
public AbstractModel DeleteWorkout(WorkoutModel workoutModel)
{
WorkoutModel decryptedModel = new WorkoutModel();
decryptedModel.userName = CryptHelper.Decrypt(workoutModel.userName);
decryptedModel.workoutName = CryptHelper.Decrypt(workoutModel.workoutName);
//try to delete workout
bool didDeleteWorkout = deleteWorkout(decryptedModel.userName, decryptedModel.workoutName);
if (didDeleteWorkout)
{
return(ResultHelper.boolResult(true, "Deleting Workout success"));
}
return(ResultHelper.boolResult(false, "Deleting Workout failure"));
}
