private void SaveTrainRecord(EvaluteResult record)
        {
            Application.Current.Dispatcher.Invoke(new Action(() =>
            {
                if (MessageBox.Show("是否保存评测结果?","提示",MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                {
                    try
                    {
                        EvaluteDetail ed = new EvaluteDetail();
                        ed.EvaluteDetailDate = DateTime.Now;
                        ed.EvaluteDate = DateTime.Now.Date;
                        if (record.MaxValue.HasValue) ed.MaxV = record.MaxValue.Value;
                        if (record.LastValue.HasValue) ed.LastValue = record.LastValue.Value;
                        if (record.MaxValue.HasValue && record.MaxValue.Value > 0 && record.LastValue.HasValue)
                        {
                            ed.FatigueIndex =(record.MaxValue.Value - record.LastValue.Value) / record.MaxValue.Value;
                        }
                        ed.ModeId = (int)record.EvaluteMode;
                        ed.ActionId = (int)record.EvaluteAction;
                        ed.PatientID = ModuleConstant.PatientId;
                        ed.Interval = Time;
                        if (Mode == EvaluateModeEnum.Range)
                        {
                            ed.TargetValue = Angle;
                        }
                        else
                        {
                            ed.TargetValue = Power;
                        }
                        StringBuilder sb = new StringBuilder();
                        if (record.TargetLine != null)
                        {
                            for (int i = 0; i < record.TargetLine.Length; i++)
                            {
                                if (i == 0)
                                {
                                    sb.Append(record.TargetLine[i].ToString("#0.00"));
                                }
                                else
                                {
                                    sb.Append("|").Append(record.TargetLine[i].ToString("#0.00"));
                                }
                            }
                            ed.Record = sb.ToString();
                        }

                        sb = new StringBuilder();
                       
                        if (record.RealLine != null)
                        {
                            for (int i = 0; i < record.RealLine.Length; i++)
                            {
                                if (i == 0)
                                {
                                    sb.Append(record.RealLine[i].ToString("#0.00"));
                                }
                                else
                                {
                                    sb.Append("|").Append(record.RealLine[i].ToString("#0.00"));
                                }
                            }
                            ed.Record2 = sb.ToString();
                        }
                        

                        MySession.Session.Save(ed);
                        MySession.Session.Flush();

                        if (Mode == EvaluateModeEnum.Range)
                        {
                            FitModeEnum fitMode = FitModeEnum.RotationFit;
                            int? minValue = null;
                            int? maxValue = null;

                            if (Action == EvaluateActionEnum.RotationRangeLeft)
                            {
                                fitMode = FitModeEnum.RotationFit;
                                maxValue = (int)record.MaxValue.Value;
                            }
                            else if (Action == EvaluateActionEnum.RotationRangeRight)
                            {
                                fitMode = FitModeEnum.RotationFit;
                                minValue = (int)record.MaxValue.Value * -1;
                            }
                            else if (Action == EvaluateActionEnum.RangeBend)
                            {
                                fitMode = FitModeEnum.ProtrusiveOrBendFit;
                                minValue = (int)record.MaxValue.Value * -1;
                            }
                            else if (Action == EvaluateActionEnum.RangeProtrusive)
                            {
                                fitMode = FitModeEnum.ProtrusiveOrBendFit;
                                maxValue = (int)record.MaxValue.Value;
                            }

                            var result = (from fr in MySession.Query<FitRecord>()
                                          where fr.PatientID == ModuleConstant.PatientId
                                          && fr.PushRodValue <= LumbarRobotController.RobotController.PushRodAngle + 1
                                          && fr.PushRodValue >= LumbarRobotController.RobotController.PushRodAngle - 1
                                          select fr).OrderByDescending(x => x.CreateTime);
                            FitRecord fitRecord;

                            if (result.Count() > 0)
                            {
                                fitRecord = result.First();
                            }
                            else
                            {
                                fitRecord = new FitRecord();
                                fitRecord.Id = Guid.NewGuid().ToString("N");
                                fitRecord.PatientID = ModuleConstant.PatientId;
                                fitRecord.MinAngle = 0;
                                fitRecord.MinAngle = 0;
                            }

                            fitRecord.ModeID = (int)fitMode;
                            fitRecord.CreateTime = DateTime.Now;
                            fitRecord.PushRodValue = LumbarRobotController.RobotController.PushRodAngle;
                            if (minValue.HasValue)
                            {
                                fitRecord.MinAngle = minValue.Value;
                            }
                            if (maxValue.HasValue)
                            {
                                fitRecord.MaxAngle = maxValue.Value;
                            }

                            MySession.Session.SaveOrUpdate(fitRecord);
                            MySession.Session.Flush();

                            if (fitRecord.ModeID == (int)Common.Enums.FitModeEnum.ProtrusiveOrBendFit)
                            {
                                eilelc21.FltMinusValue = fitRecord.MinAngle;
                                eilelc21.FltValu = fitRecord.MaxAngle;
                            }
                            else if (fitRecord.ModeID == (int)Common.Enums.FitModeEnum.RotationFit)
                            {
                                eilelc21.FltMinusValue = fitRecord.MinAngle;
                                eilelc21.FltValu = fitRecord.MaxAngle;
                            }

                            eilelc21.Rest();
                        }



                    }
                    catch { }
                }
            }));
        }
        private void SaveFitRecord(FitResult fitResult)
        {
            Application.Current.Dispatcher.Invoke(new Action(() =>
            {
                try
                {
                    FitRecord record = new FitRecord();
                    record.Id = Guid.NewGuid().ToString("N");
                    record.PatientID = ModuleConstant.PatientId;
                    record.ModeID = (int)fitResult.FitMode;
                    record.CreateTime = DateTime.Now;
                    record.PushRodValue = LumbarRobotController.RobotController.PushRodAngle;
                    if (fitResult.FitMode == Common.Enums.FitModeEnum.ProtrusiveOrBendFit)
                    {
                        if (fitResult.BendMinAngle.HasValue) record.MinAngle = (int)(fitResult.BendMinAngle.Value);
                        if (fitResult.BendMaxAngle.HasValue) record.MaxAngle = (int)(fitResult.BendMaxAngle.Value);
                    }
                    else if (fitResult.FitMode == Common.Enums.FitModeEnum.RotationFit)
                    {
                        if (fitResult.RotateMinAngle.HasValue) record.MinAngle = (int)fitResult.RotateMinAngle.Value;
                        if (fitResult.RotateMaxAngle.HasValue) record.MaxAngle = (int)fitResult.RotateMaxAngle.Value;
                    }
                    else  if (fitResult.FitMode == Common.Enums.FitModeEnum.ProtrusiveOrBendStrengthEvaluation)
                    {
                        if (fitResult.BendMin.HasValue) record.MinAngle = (int)(fitResult.BendMin.Value);
                        if (fitResult.BendMax.HasValue) record.MaxAngle = (int)(fitResult.BendMax.Value);
                    }
                    else
                    {
                        if (fitResult.RotateMin.HasValue) record.MinAngle = (int)fitResult.RotateMin.Value;
                        if (fitResult.RotateMax.HasValue) record.MaxAngle = (int)fitResult.RotateMax.Value;
                    }

                    MySession.Session.Save(record);
                    MySession.Session.Flush();
                }
                catch { }
            }));
        }