public UC_ExerciseSelection(Training currentTraining)
{
InitializeComponent();
CurrentTraining = currentTraining;
this.Loaded += UC_ExerciseSelection_Loaded;
}
public void OpenDistanceChecker(Patient _currentPatient, Training _currentTraining)
{
using (DistanceWindow distanceWindow = new DistanceWindow(_currentPatient, _currentTraining, null))
{
distanceWindow.mainWindow = this;
this.Content = distanceWindow;
}
}
public void OpenExerciseWindow(Patient _currentPatient, Training _currentTraining)
{
using (ExerciseView _exerciseView = new ExerciseView(_currentPatient, _currentTraining))
{
_exerciseView.MainWindow = this;
_exerciseView.GoBackToTreatmentScreen += OpenTreatmentWindow;
this.Content = _exerciseView;
}
}
public UC_TrainingSelection(Patient currentPatient, Training currentTraining)
{
InitializeComponent();
_currentPatient = currentPatient;
_currentTraining = currentTraining;
DataContext = _currentTraining;
}
public DistanceWindow(Patient currentPatient, Training currentTraining, VideoTherapy.TrainingMenu trainingMenu)
{
InitializeComponent();
this.currentPatient = currentPatient;
this.currentTraining = currentTraining;
this.trainingMenu = trainingMenu;
//SetKinectConnection();
this.Loaded += DistanceWindow_Loaded;
}
public TrainingMenu(Patient currentPatient, Training currentTraining)
{
InitializeComponent();
_currentPatient = currentPatient;
_currentTraining = currentTraining;
this.Loaded += TrainingMenu_Loaded;
splash = new VT_Splash();
//splash.ErrorEvent+=
worker = new BackgroundWorker();
worker.DoWork += Worker_DoWork;
worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
}
///<summary>
///get current training moition quality score
///</summary>
public static int GetTrainingQuailty(Training CurrentTraining)
{
float avg = 0;
int numOfExe = 0;
foreach (var key in CurrentTraining.Playlist.Keys)
{
Exercise exercise = CurrentTraining.Playlist[key][1];
if (exercise.ExerciseScore != null && exercise.IsTraceable)
{
avg += (exercise.ExerciseScore.MoitionQuality * 100);
numOfExe++;
}
}
return (numOfExe != 0) ? (int) (avg / numOfExe) : 0;
}
public void OpenTrainingWindow(Patient _currentPatient, Training _selectedTraining)
{
//OpenningWindow.Children.Clear();
//OpenningWindow.Background = null;
using (TrainingMenu _trainingMenu = new TrainingMenu(_currentPatient, _selectedTraining))
{
_trainingMenu.MainWindow = this;
_trainingMenu.CloseApp += CloseApp;
_trainingMenu.LogOut += LogOut;
this.Content = _trainingMenu;
//OpenningWindow.Children.Add(_trainingMenu);
}
}
private void _trainingSelection_StartPlaylist(Training currentTraining)
{
if (_currentTraining.IsTraceableTraining)
{
userInDistanceSemaphore = new SemaphoreSlim(1);
userInDistanceSemaphore.Wait();
worker.RunWorkerAsync();
using (DistanceWindow distance = new DistanceWindow(_currentPatient, currentTraining, this))
{
this.Content = distance;
Console.WriteLine("distance wait finish");
//distance.trainingMenu = this;
}
//MainWindow.OpenDistanceChecker(_currentPatient, _currentTraining);
}
else
{
MainWindow.OpenExerciseWindow(_currentPatient, _currentTraining);
}
//barrier.SignalAndWait();
}
public ExerciseView(Patient currentPatient, Training currentTraining)
{
InitializeComponent();
CurrentPatient = currentPatient;
CurrentTraining = currentTraining;
this.Loaded += ExerciseView_Loaded;
}
/// <summary>
/// Parse from json content to current patient training
/// </summary>
/// <param name="_JSONcontent">The response json</param>
/// <param name="_training">The _training object</param>
public static void GettingPatientTraining2(Training _training, string _JSONcontent)
{
dynamic d =
(JsonConvert.DeserializeObject<IDictionary<string, object>>(_JSONcontent));
//checking errors
bool checkError = checkForErrors((int)d["code"]);
if (checkError)
{
ErrorEvent(null, new ErrorMessege(((ServerCode)d["code"].code).ToString(), (int)d["code"].code));
return;
}
_training.Playlist = new Dictionary<int, List<Exercise>>();
int numOfExercises = 1;
//iterat over the exercise session
foreach (var item in d["data"].sessions)
{
//Creating demo exercise
Exercise demoExercise = new Exercise();
demoExercise.ExerciseName = item.exerciseLabel;
demoExercise.ExerciseId = item.exerciseId;
demoExercise.ExerciseThumbs = item.exerciseThumbnail;
string tt = item.exerciseVideoDemo;
demoExercise.VideoPath = new Uri(HttpsReplaceToHttp.ReplaceHttpsToHttp(tt));
demoExercise.ExerciseNum = numOfExercises;
demoExercise.isDemo = true;
demoExercise.SessionId = item.sessionId;
demoExercise.Mode = Exercise.ExerciseMode.Demo;
int temp = item.sessionId;
_training.Playlist[temp] = new List<Exercise>();
_training.Playlist[temp].Add(demoExercise);
numOfExercises++;
//duplicate the exercise if there are repeats for him by therapist
//sessRepeats - number of duplicates exercise
int x = item.sessRepeats;
for (int i = 1; i <= x; i++)
{
Exercise newExercise = new Exercise();
newExercise.ExerciseName = item.exerciseLabel;
newExercise.ExerciseId = item.exerciseId;
newExercise.ExerciseThumbs = item.exerciseThumbnail;
tt = item.exerciseVideo;
newExercise.VideoPath = new Uri(HttpsReplaceToHttp.ReplaceHttpsToHttp(tt));
newExercise.Repetitions = item.exerciseCycles;
newExercise.ExerciseNum = numOfExercises;
newExercise.SessionId = item.sessionId;
newExercise.IsTraceable = item.isTrackable;
newExercise.Mode = (bool) item.isTrackable ? Exercise.ExerciseMode.Traceable : Exercise.ExerciseMode.NonTraceable;
//todo - should be from server
newExercise.VideoComplianceValue = 2;
newExercise.SuccessRate = 0.5f;
//for future download for not duplicate the same file
if (i != 1)
{
newExercise.Mode = newExercise.Mode == Exercise.ExerciseMode.Traceable ? Exercise.ExerciseMode.TraceableDuplicate : Exercise.ExerciseMode.NonTraceableDuplicate;
newExercise.isDuplicate = true;
}
numOfExercises++;
_training.Playlist[temp].Add(newExercise);
}
}
foreach (var exercises in _training.Playlist.Values)
{
if (exercises[1].IsTraceable)
{
_training.IsTraceableTraining = true;
break;
}
}
}
/// <summary>
/// Parse from json content to training list
/// <param name="_JSONcontent">The response json</param>
/// </summary>
public static List<Training> CreateTrainingList(string _JSONcontent)
{
List<Training> trainingList = new List<Training>();
Dictionary<int, object> trainingListJson = JsonConvert.DeserializeObject<Dictionary<int, object>>(_JSONcontent);
//List<object> trainingListJson = JsonConvert.DeserializeObject<List<object>>(_JSONcontent);
foreach (object item in trainingListJson.Values)
{
Training newTraining = new Training();
object temp;
int tempInt;
float tempFloat1, tempFloat2;
Dictionary<string, object> currentObj = JsonConvert.DeserializeObject<Dictionary<string, object>>(item.ToString());
trainingList.Add(newTraining);
newTraining.TrainingNumber = trainingList.IndexOf(newTraining) + 1;
currentObj.TryGetValue("label", out temp);
newTraining.TrainingName = temp.ToString();
currentObj.TryGetValue("id", out temp);
Int32.TryParse(temp.ToString(), out tempInt);
newTraining.TrainingId = tempInt;
currentObj.TryGetValue("thumbnail", out temp);
newTraining.TrainingThumbs = temp.ToString();
//todo - yoav need to change the api
currentObj.TryGetValue("lastTrainedDate", out temp);
if (!temp.ToString().Equals("[]"))
{
Dictionary<string, string> tempDate = JsonConvert.DeserializeObject<Dictionary<string, string>>(temp.ToString());
DateTime tempDateTime;
DateTime.TryParse(tempDate["date"].ToString(), out tempDateTime);
newTraining.LastViewed = tempDateTime;
}
else
{
newTraining.LastViewed = null;
}
//add scoring!!
Dictionary<string, float> scoringDic = JsonConvert.DeserializeObject<Dictionary<string, float>>(currentObj["session_usage"].ToString());
scoringDic.TryGetValue("num_repeatition_done", out tempFloat1);
scoringDic.TryGetValue("num_repeatition_total", out tempFloat2);
if (tempFloat1 == 0)
{
newTraining.TrainingScore = 0;
}
else
{
newTraining.TrainingScore = (int)(tempFloat1 / tempFloat2 * 100);
}
//newTraining.TrainingCompliance = (int)(scoringDic["num_repeatition_done"] / scoringDic["num_repeatition_total"] * 100);
scoringDic.TryGetValue("motion_quality", out tempFloat1);
newTraining.TrainingQuality = (int)(tempFloat1 * 100);
//newTraining.TrainingScore = (int)(scoringDic["motion_quality"] * 100);
//check if there is calEvents exist
object tempCalEvents;
currentObj.TryGetValue("calEventsUsage", out tempCalEvents);
if (tempCalEvents is JObject)
{
Dictionary<string, int> calEvents = JsonConvert.DeserializeObject<Dictionary<string, int>>(tempCalEvents.ToString());
calEvents.TryGetValue("total", out tempInt);
newTraining.Repetitions = tempInt;
//newTraining.Repetitions = Int32.Parse(calEvents["total"].ToString());
calEvents.TryGetValue("completed", out tempInt);
newTraining.TrainingCompleted = tempInt;
//newTraining.TrainingCompleted = Int32.Parse(calEvents["completed"].ToString());
}
object calGuid;
currentObj.TryGetValue("cal_guid", out calGuid);
newTraining.CalGuid = calGuid.ToString();
object calEvent;
currentObj.TryGetValue("next_cal_event_id", out calEvent);
newTraining.CalEventId = calEvent.ToString();
//check if this training is the upcoming one
Object checkUpComming = false;
currentObj.TryGetValue("upcomingEvent", out checkUpComming);
if (checkUpComming != null && (Boolean)checkUpComming && !newTraining.CalEventId.Equals(""))
{
newTraining.IsRecommended = true;
}
newTraining.TrainingComplianceValue = Training.TRAINING_COMPLIANCE;
}
return trainingList;
}
/// <summary>
/// Handling the selection of the training and open his window
/// </summary>
/// <param name="_selectedTraining">The select training</param>
private void _trainingSeleciton_trainingSelectedEvent(Training _selectedTraining)
{
_currentPatient.PatientTreatment.CurrentTraining = _selectedTraining;
MainWindow.OpenTrainingWindow(_currentPatient, _selectedTraining);
//todo - start download gdb files
//
}
/// <summary>
/// Report training compliance, use only when compliance pass the value
/// <param name="training">Current training</param>
/// </summary>
public static async Task<string> ReportTrainingComplianceApiAsync(Training training)
{
if (!training.CalEventId.Equals(""))
{
Dictionary<string, string> _pairs = PairsDictinaryForApi(ApiType.ReportTrainingCompliance, "calGuid", training.CalGuid,
"eventId", training.CalEventId);
return await ConnectingApiAsync(_pairs);
}
return null;
}
/// <summary>
///
/// <param name="_exerciseId">Active instance of the KinectSensor</param>
/// </summary>
public static async Task<string> ReportExerciseScoreApiAsync(Exercise exercise, Training training)
{
if (!training.CalEventId.Equals(""))
{
Dictionary<string, string> _pairs = PairsDictinaryForApi(ApiType.ReportExercise, "exerciseId", exercise.ExerciseId.ToString(), "numRepitionTotal", exercise.ExerciseScore.TotalRepetitions.ToString(),
"numRepitionDone", exercise.ExerciseScore.TotalRepetitionsDone.ToString(), "motionQuality", exercise.ExerciseScore.MoitionQuality.ToString(),
"calGuid", training.CalGuid, "calEventId", training.CalEventId);
return await ConnectingApiAsync(_pairs);
}
return null;
}
///<summary>
///get current training score - num of repititions completed
///</summary>
public static int GetTrainingScore(Training CurrentTraining)
{
int numOfSuccess = 0;
int numOfExercises = 0;
foreach (var key in CurrentTraining.Playlist.Keys)
{
Exercise exercise = CurrentTraining.Playlist[key][1];
if (exercise.ExerciseScore != null && exercise.IsTraceable) //meaning that is a traceable
{
numOfExercises += exercise.ExerciseScore.TotalRepetitions;
numOfSuccess += exercise.ExerciseScore.TotalRepetitionsDone;
}
else
{
numOfExercises += exercise.Repetitions;
}
}
float scoreRep = (numOfSuccess * 100 )/ (float) numOfExercises;
//int scoreRep = (int)(t);
return (numOfExercises != 0) ? (int) scoreRep : 0;
}
