Пример #1
0
        /// <summary>
        ///     Autos the advance.
        /// </summary>
        public async void CheckAutoAdvance()
        {
            try
            {
                await Page.PopPage();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            finally
            {
                if (HaccpAppSettings.SharedInstance.DeviceSettings.AutoAdvance)
                {
                    MessagingCenter.Send(new AutoAdvanceLocationMessage
                    {
                        CurrentId = SelectedItem.ItemId
                    }, HaccpConstant.AutoadvancelocationMessage);
                }

                IsBusy = false;
                RecordCommand.ChangeCanExecute();
            }
        }
Пример #2
0
        /// <summary>
        ///     Executes the record command.
        /// </summary>
        private async void ExecuteRecordCommand()
        {
            if (IsBusy)
            {
                return;
            }

            try
            {
                bool connected;
                bool gotTemperartureReading;
                if (HaccpAppSettings.SharedInstance.IsWindows)
                {
                    gotTemperartureReading = WindowsBLEManager.SharedInstance.GotTemperartureReading;
                    connected = WindowsBLEManager.SharedInstance.HasAnyPairedDevice;
                }
                else
                {
                    connected = BLEManager.SharedInstance.IsConnected;
                    gotTemperartureReading = BLEManager.SharedInstance.GotTemperartureReading;
                }

                if (!IsManualEntryOn && !connected)
                {
                    if (HaccpAppSettings.SharedInstance.IsWindows)
                    {
                        return;
                    }
                    if (!BLEManager.SharedInstance.Adapter.IsBluetoothEnabled)
                    {
                        await Page.ShowAlert(string.Empty, HACCPUtil.GetResourceString("TurnONBluetoothonyourdevice"));

                        return;
                    }
                    await Page.ShowAlert(string.Empty, HACCPUtil.GetResourceString("Blue2TurnOnMessage"));

                    return;
                }


                if (!IsManualEntryOn && !gotTemperartureReading)
                {
                    return;
                }

                if (IsManualEntryOn && string.IsNullOrEmpty(ManualTemperature))
                {
                    await Page.ShowAlert(string.Empty, HACCPUtil.GetResourceString("SpecifyTemperature"));

                    return;
                }
                if (IsManualEntryOn)
                {
                    try
                    {
                        double.Parse(ManualTemperature);
                    }
                    catch
                    {
                        Page.ShowAlert(string.Empty, HACCPUtil.GetResourceString("Specifyavalidtemperaturevalue"));
                        return;
                    }
                }
                else if (DisplayBlue2Temperature == HACCPUtil.GetResourceString("ConnectBlue2Label") ||
                         DisplayBlue2Temperature == HACCPUtil.GetResourceString("Blue2SleepString") ||
                         DisplayBlue2Temperature == HACCPUtil.GetResourceString("Blue2LowString") ||
                         DisplayBlue2Temperature == HACCPUtil.GetResourceString("Blue2HighString") &&
                         DisplayBlue2Temperature == HACCPUtil.GetResourceString("Blue2BatteryString"))
                {
                    await Page.ShowAlert(string.Empty, HACCPUtil.GetResourceString("InvalidTemperatureAlert"));

                    return;
                }

                var allowedMax = HaccpAppSettings.SharedInstance.DeviceSettings.TempScale == 0 ? 9999.9 : 5537.7;
                var allowedMin = HaccpAppSettings.SharedInstance.DeviceSettings.TempScale == 0 ? -9999.9 : -5537.7;

                if (IsManualEntryOn)
                {
                    if (ManualEntryTemperature > allowedMax || ManualEntryTemperature < allowedMin)
                    {
                        await Page.ShowAlert(string.Empty, HACCPUtil.GetResourceString("InvalidTemperatureAlert"));

                        return;
                    }
                }
                else
                {
                    var lastReading = HaccpAppSettings.SharedInstance.IsWindows
                        ? WindowsBLEManager.SharedInstance.LastReading
                        : BLEManager.SharedInstance.LastReading;
                    var lastunit = HaccpAppSettings.SharedInstance.IsWindows
                        ? WindowsBLEManager.SharedInstance.LastUnit
                        : BLEManager.SharedInstance.LastUnit;

                    if (TemperatureUnit == TemperatureUnit.Celcius && lastunit != TemperatureUnit.Celcius)
                    {
                        lastReading = HACCPUtil.ConvertFahrenheitToCelsius(lastReading);
                    }
                    else if (TemperatureUnit == TemperatureUnit.Fahrenheit && lastunit != TemperatureUnit.Fahrenheit)
                    {
                        lastReading = HACCPUtil.ConvertCelsiusToFahrenheit(lastReading);
                    }

                    Blue2Temperature = lastReading;
                }

                IsBusy = true;
                RecordCommand.ChangeCanExecute();


                var temp = IsManualEntryOn ? ManualEntryTemperature : Blue2Temperature;

                var minTemp = HACCPUtil.ConvertToDouble(SelectedItem.Min);
                var maxTemp = HACCPUtil.ConvertToDouble(SelectedItem.Max);

                var convertedTemp = temp;
                if (TemperatureUnit == TemperatureUnit.Celcius)
                {
                    minTemp = Math.Round(HACCPUtil.ConvertFahrenheitToCelsius(minTemp));
                    maxTemp = Math.Round(HACCPUtil.ConvertFahrenheitToCelsius(maxTemp));
                    //convertedTemp = HACCPUtil.ConvertFahrenheitToCelsius (temp);
                }


                if (convertedTemp >= minTemp && convertedTemp <= maxTemp &&
                    HaccpAppSettings.SharedInstance.DeviceSettings.SkipRecordPreview)
                {
                    var  date = DateTime.Now;
                    long ccpid;
                    long.TryParse(SelectedItem.Ccpid, out ccpid);
                    var location = dataStore.GetLocationById(SelectedItem.LocationId);

                    if (TemperatureUnit == TemperatureUnit.Celcius)
                    {
                        convertedTemp = HACCPUtil.ConvertCelsiusToFahrenheit(temp);
                    }

                    var itemTemperature = new ItemTemperature
                    {
                        IsManualEntry = IsManualEntryOn ? (short)1 : (short)0,
                        ItemID        = SelectedItem.ItemId,
                        Temperature   = convertedTemp.ToString("0.0"),
                        ItemName      = SelectedItem.Name,
                        Max           = SelectedItem.Max,
                        Min           = SelectedItem.Min,
                        CorrAction    = HACCPUtil.GetResourceString("None"),
                        LocationID    = SelectedItem.LocationId,
                        Ccp           = SelectedItem.Ccp,
                        CCPID         = ccpid,
                        IsNA          = 0,
                        Hour          = date.Hour.ToString(),
                        Day           = date.Day.ToString(),
                        Minute        = date.Minute.ToString(),
                        Month         = date.Month.ToString(),
                        Sec           = date.Second.ToString(),
                        Year          = date.Year.ToString(),
                        SiteID        = HaccpAppSettings.SharedInstance.SiteSettings.SiteId,
                        UserName      = HaccpAppSettings.SharedInstance.UserName,
                        DeviceId      = HaccpAppSettings.SharedInstance.DeviceId,
                        MenuID        = HaccpAppSettings.SharedInstance.SiteSettings.MenuId,
                        TZID          = HaccpAppSettings.SharedInstance.SiteSettings.TimeZoneId,
                        LocName       = location.Name,
                        Note          = NoteText,
                        Blue2ID       = SelectedItem.Blue2Id
                    };
                    dataStore.AddTemperature(itemTemperature);

                    SelectedItem.RecordStatus = 1;
                    dataStore.RecordLocationItem(SelectedItem);
                    if (HaccpAppSettings.SharedInstance.IsWindows)
                    {
                        WindowsBLEManager.SharedInstance.ResetBlue2AutoOff();
                    }
                    else
                    {
                        BLEManager.SharedInstance.ResetBlue2AutoOff();
                    }

                    MessagingCenter.Send(SelectedItem, HaccpConstant.RecorditemMessage);
                    dataStore.UpdateLocationItemRecordStatus(SelectedItem.LocationId);
                    MessagingCenter.Send(new MenuLocationId
                    {
                        LocationId = SelectedItem.LocationId
                    }, HaccpConstant.MenulocationMessage);

                    MessagingCenter.Send(new RecordSaveCompleteToast(), HaccpConstant.ToastMessage);
                }
                else
                {
                    SelectedItem.IsManualEntry       = IsManualEntryOn;
                    SelectedItem.RecordedTemperature = temp.ToString("0.0");
                    SelectedItem.TemperatureUnit     = TemperatureUnit;
                    SelectedItem.Blue2Id             = IsManualEntryOn ? string.Empty : Blue2Id;
                    SelectedItem.Note = NoteText;
                    if (HaccpAppSettings.SharedInstance.IsWindows)
                    {
                        WindowsBLEManager.SharedInstance.ResetBlue2AutoOff();
                    }
                    else
                    {
                        BLEManager.SharedInstance.ResetBlue2AutoOff();
                    }


                    await Page.NavigateToWithSelectedObject(PageEnum.RecordComplete, true, SelectedItem);

                    IsBusy = false;
                    RecordCommand.ChangeCanExecute();
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("Error on recording {0}", ex.Message);
            }
        }