/// <summary>
        /// 
        /// </summary>
        internal void SendMeasurements()
        {
            if (this.Weight.HasValue)
            {
                aladdinService.StorageComponentImplService sc = new aladdinService.StorageComponentImplService();
                aladdinService.Measurement Measurement = new aladdinService.Measurement();
                Measurement.DateTime = App.getTaskById(this.ActiveTask.ID).DateTimeAssigned; // System.DateTime.Now;
                Measurement.TaskID = this.ActiveTask.ID;

                aladdinService.SystemParameter measurementType = new aladdinService.SystemParameter();
                measurementType.Code = Convert.ToString((int)Config.MeasurementTypeEnum.Weight);
                measurementType.Description = "Weight";
                Measurement.Type = measurementType;

                Measurement.Value = this.Weight.Value;
                Measurement.Units = "Kg";

                Measurement.LowerLimitSpecified = false;
                Measurement.UpperLimitSpecified = false;

                aladdinService.Measurement[] data = new aladdinService.Measurement[] { Measurement };
                aladdinService.OperationResult res = sc.StoreMeasurements(data, App.CurrentUserID);
                if (res.Status == 1)
                {
                    aladdinService.OperationResult taskChangeStatus = sc.ChangeTaskStatus(Convert.ToInt32(this.ActiveTask.ID), (int)Config.TaskStatusEnum.Completed, App.CurrentUserID);
                }

                AppCommands.MoveToPageCommand.Execute("MyTasksPage", null);
            }
        }
        /// <summary>
        /// 
        /// </summary>
        internal void SendMeasurements()
        {
            aladdinService.StorageComponentImplService sc = new aladdinService.StorageComponentImplService();
            aladdinService.SystemParameter measurementType = new aladdinService.SystemParameter();
            aladdinService.OperationResult res1 = new aladdinService.OperationResult();
            aladdinService.OperationResult res2 = new aladdinService.OperationResult();

            if (this.DiastolicBloodPressure.HasValue)
            {
                aladdinService.Measurement diastolicBP = new aladdinService.Measurement();
                diastolicBP.DateTime = App.getTaskById(this.ActiveTask.ID).DateTimeAssigned; // System.DateTime.Now;
                diastolicBP.TaskID = this.ActiveTask.ID;

                measurementType = new aladdinService.SystemParameter();
                measurementType.Code = Convert.ToString((int)Config.MeasurementTypeEnum.DiastolicBloodPressure);
                measurementType.Description = "Diastolic BP";

                diastolicBP.Type = measurementType;
                diastolicBP.Value = this.DiastolicBloodPressure.Value;
                diastolicBP.Units = "mmHg";
                diastolicBP.LowerLimitSpecified = false;
                diastolicBP.UpperLimitSpecified = false;

                aladdinService.Measurement[] diastolicBPData = new aladdinService.Measurement[] { diastolicBP };
                res1 = sc.StoreMeasurements(diastolicBPData, App.CurrentUserID);
            }

            if (this.SystolicBloodPressure.HasValue)
            {
                aladdinService.Measurement systolicBP = new aladdinService.Measurement();
                systolicBP.DateTime = App.getTaskById(this.ActiveTask.ID).DateTimeAssigned; // System.DateTime.Now;
                systolicBP.TaskID = this.ActiveTask.ID;

                measurementType = new aladdinService.SystemParameter();
                measurementType.Code = Convert.ToString((int)Config.MeasurementTypeEnum.SystolicBloodPressure);
                measurementType.Description = "Systolic BP";

                systolicBP.Type = measurementType;
                systolicBP.Value = this.SystolicBloodPressure.Value;
                systolicBP.Units = "mmHg";
                systolicBP.LowerLimitSpecified = false;
                systolicBP.UpperLimitSpecified = false;

                aladdinService.Measurement[] systolicBPData = new aladdinService.Measurement[] { systolicBP };
                res2 = sc.StoreMeasurements(systolicBPData, App.CurrentUserID);
            }

            if (res1.Status == 1 && res2.Status == 1)
            {
                aladdinService.OperationResult taskChangeStatus = sc.ChangeTaskStatus(Convert.ToInt32(this.ActiveTask.ID), (int)Config.TaskStatusEnum.Completed, App.CurrentUserID);
            }

            AppCommands.MoveToPageCommand.Execute("MyTasksPage", null);
        }
        internal void SendMeasurements()
        {
            if (this.Activity.Length > 0)
            {
                aladdinService.StorageComponent sc = new aladdinService.StorageComponent();
                aladdinService.SystemParameter measurementType = new aladdinService.SystemParameter();
                List<aladdinService.Measurement> dataList = new List<aladdinService.Measurement>(); // We use a dynamic array first, we still don't know how many (new) measurments we have to submit
                measurementType.Code = Convert.ToString((int)MeasurementTypeEnum.Activity);
                measurementType.Description = "Activity";

                List<string> dateLog = new List<string>(); // List of days for which we have already sent the data (history)
                List<string> dateLogNew = new List<string>(); // List of days for which we have new data to send (will be added to the history at the end)
                string date;

                // Load the history
                string logFile = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "\\activity.log";
                if (File.Exists(logFile))
                {
                    StreamReader r = new StreamReader(logFile);
                    while ((date = r.ReadLine()) != null)
                        dateLog.Add(date);
                    r.Close();
                }

                for (int day = 0; day < MAX_DAY; ++day)
                {
                    for (int hour = 0; hour < 24; ++hour)
                    {
                        // Build the timestamp of this measurement
                        DateTime dt = new DateTime(System.DateTime.Now.Year, System.DateTime.Now.Month, System.DateTime.Now.Day, hour, 0, 0, 0);
                        dt = dt.AddDays(-1 - day);

                        // Process the measurement only if its day is not present in the history
                        if (dateLog.IndexOf(String.Format("{0:d/M/yyyy}", dt)) == -1)
                        {
                            aladdinService.Measurement Measurement = new aladdinService.Measurement();

                            Measurement.DateTime = dt;
                            Measurement.TaskID = this.ActiveTask.ID;
                            Measurement.Type = measurementType;
                            Measurement.Value = this.Activity[day, hour];
                            Measurement.Units = "steps/day";
                            Measurement.LowerLimitSpecified = false;
                            Measurement.UpperLimitSpecified = false;

                            dataList.Add(Measurement);

                            // Update the list of days with new data
                            date = String.Format("{0:d/M/yyyy}", dt);
                            if (dateLogNew.IndexOf(date) == -1)
                                dateLogNew.Add(date);
                        }
                    }
                }

                // Create an array (StoreMeasurements requires an array parameter) with the right size and fill it with the measurements
                aladdinService.Measurement[] data = new aladdinService.Measurement[dataList.Count()];
                for (int i = 0; i < dataList.Count(); ++i)
                    data[i] = dataList[i];

                // Save measuremnts in a local .csv file
                /*
                StreamWriter sw2;
                sw2 = File.CreateText("aladdin_activity.csv");
                for (int i = 0; i < dataList.Count(); ++i)
                {
                    sw2.Write("'" + data[i].DateTime.ToString() + "',");
                    sw2.WriteLine("'" + data[i].Value.ToString() + "'");
                }
                sw2.Close();
                */

                aladdinService.OperationResult res = sc.StoreMeasurements(data, App.CurrentUserID);
                if (res.Status == 1)
                {
                    aladdinService.OperationResult taskChangeStatus = sc.ChangeTaskStatus(Convert.ToInt32(this.ActiveTask.ID), (int)TaskStatusEnum.Completed, App.CurrentUserID);

                    // Update the history
                    StreamWriter sw;
                    sw = File.AppendText(logFile);
                    foreach (string s in dateLogNew)
                        sw.WriteLine(s);
                    sw.Close();
                }

                AppCommands.MoveToPageCommand.Execute("MyTasksPage", null);
            }
        }