public async Task RegisterAsyncNewTest()
{
//arrange
var dbConnection = new UnitTestDbConnection();
Database.SetInitializer(new CreateFreshDbInitializer());
var dsb = new DeviceSettingBuilder(dbConnection);
var deviceSetting = new DeviceSetting
{
Name = "Unit Test Device Setting",
UniqueIdentifier = "DEVICE_SETTING1"
};
//act
var result = await dsb.RegisterAsync(deviceSetting, CancellationToken.None);
DeviceSetting setting;
using (var context = new ZvsContext(dbConnection))
{
setting =
await
context.DeviceSettings.FirstOrDefaultAsync(
o => o.UniqueIdentifier == deviceSetting.UniqueIdentifier);
}
//assert
Console.WriteLine(result.Message);
Assert.IsFalse(result.HasError, result.Message);
Assert.IsNotNull(setting, "Expected new device setting saved to DB");
}
private void ChangeFeatureSettingValue(DeviceSetting newSetting)
{
if (this._enabledSwitch.On)
{
this._feature.SettingsValueDictionary = this._feature.EnableDictionary;
}
else
{
//if (!this._datePickerView.Hidden)
if (!this._intervalPickerView.Hidden)
{
this._feature.SettingsValueDictionary = this._feature.DisableTimerDictionary;
}
else
{
this._feature.SettingsValueDictionary = this._feature.DisableDictionary;
}
}
if (this._device.ChangeFeatureSettingValue != null)
{
this._device.ChangeFeatureSettingValue(this._device, this._feature, newSetting);
}
this.NavigationController.PopViewController(true);
}
private void DoRead(bool fouceRead)
{
if (!ReadDone || fouceRead)
{
try{
if (spt == null || !spt.connected)
{
connectDevice();
}
devInfo = new DeviceInfo(spt.SendGetInfo());
devSetting = new DeviceSetting(spt.SentGetSetting());
string tempListstr = spt.SentGetRecords();
TempList = new DeviceTempList(tempListstr, devInfo.usedSpace, devInfo.RecordDateTime, devSetting.recordIntervalInSecond);
//Console.WriteLine(temps);
//string s = TempSenHelper.GetTempListCString(tempList, spt.ItemCount, devInfo.RecordDateTime, devSetting.recordInterval);
}catch (Exception ex) {
ReadDone = false;
Console.WriteLine(ex.Message + ex.StackTrace);
throw new Exception("do read failed.");
}
}
if (devInfo != null && devSetting != null && TempList != null)
{
ReadDone = true;
}
}
public void ConnectDevice4()
{
DeviceUsageEnum currentUsage = DeviceUsageEnum.出库;
var item = SV.DeviceDictonary.FirstOrDefault(p => p.Key.Usage == currentUsage);
DeviceSetting setting = item.Key;
if (!setting.IsSettingValid())
{
SV.Logger.Info($"{currentUsage.ToString()}设备: 配置无效，无法连接。");
return;
}
DeviceProxy deviceProxy = item.Value;
deviceProxy.Connected += () => { this.OnDeviceConnected(_frmExWarehouse); };
deviceProxy.Closing += () => { this.OnDeviceDisconnected(_frmExWarehouse); };
int status = deviceProxy.ConnectViaNetwork(item.Key.DeviceIpAddress, item.Key.DevicePort);
if (status == 0)
{
deviceProxy.IsConnected = true;
SV.Logger.Info($"{currentUsage.ToString()}设备: 成功建立连接。");
}
}
public static DateTime GetNextCheckTime(DeviceSetting setting, DateTime StartTime, Foresight.DataAccess.Device device, out DateTime EndTime)
{
DateTime ResultTime = DateTime.MinValue;
EndTime = DateTime.MinValue;
if (device.CheckCycle.Equals(Utility.EnumModel.DeviceCycleType.day.ToString()))
{
EndTime = StartTime.AddDays(device.CheckCount);
}
else if (device.CheckCycle.Equals(Utility.EnumModel.DeviceCycleType.month.ToString()))
{
EndTime = StartTime.AddMonths(device.CheckCount);
}
if (setting == null || string.IsNullOrEmpty(setting.Parameters1) || string.IsNullOrEmpty(setting.Parameters2))
{
ResultTime = EndTime;
}
else if (setting.Parameters2.Equals(Utility.EnumModel.DeviceCycleType.day.ToString()))
{
int beforecount = 0;
int.TryParse(setting.Parameters1, out beforecount);
ResultTime = EndTime.AddDays(-beforecount);
}
else if (setting.Parameters2.Equals(Utility.EnumModel.DeviceCycleType.month.ToString()))
{
int beforecount = 0;
int.TryParse(setting.Parameters1, out beforecount);
ResultTime = EndTime.AddMonths(-beforecount);
}
return(ResultTime);
}
public DeviceSetting SaveOrUpdate(DeviceSetting entity)
{
DeviceSetting returnObject = null;
UsingGlobalDb((context) => {
DeviceSetting overridingSetting = context.DeviceSettings.FirstOrDefault(a => a.Usage == entity.Usage);
if (overridingSetting != null)
{
overridingSetting.DeviceIpAddress = entity.DeviceIpAddress;
overridingSetting.DevicePort = entity.DevicePort;
context.SaveChanges();
// 返回对象
returnObject = overridingSetting;
}
else
{
context.DeviceSettings.Add(entity);
context.SaveChanges();
returnObject = entity;
}
});
return(returnObject);
}
private void AddDeviceSettingButton_Click(object sender, EventArgs e)
{
DeviceSetting setting = new DeviceSetting();
PushSetting(setting);
FDeviceSettingsListBox.Items.Add(setting);
}
public async Task RegisterNewDeviceSettingTest()
{
//Arrange
var dbConnection = new UnitTestDbConnection();
Database.SetInitializer(new CreateFreshDbInitializer());
var adapterBuilder = new AdapterSettingBuilder(dbConnection, CancellationToken.None);
var deviceSetting = new DeviceSetting
{
Name = "Device Setting 1",
ValueType = DataType.STRING,
Value = "Hello World"
};
//act
var result = await adapterBuilder.RegisterDeviceSettingAsync(deviceSetting);
DeviceSetting setting;
using (var context = new ZvsContext(dbConnection))
{
setting = await context.DeviceSettings.FirstOrDefaultAsync();
}
//assert
Console.WriteLine(result.Message);
Assert.IsFalse(result.HasError);
Assert.IsNotNull(setting, "Setting not saved!");
Assert.IsTrue(setting.Name == deviceSetting.Name, "Device setting name mismatch");
}
public async Task<bool> UpdateDeviceAsync(DeviceSetting deviceSetting)
{
try
{
if (deviceSetting.Discriminator == "Binary")
{
await _hubProxy.Invoke("binaryDeviceUpdate", deviceSetting.DeviceId, deviceSetting.BinarySetting);
Debug.WriteLine($"{nameof(RealTimeService)}.{nameof(UpdateDeviceAsync)} binary device updated, setting {deviceSetting.BinarySetting}");
return true;
}
if (deviceSetting.Discriminator == "Continous")
{
await
_hubProxy.Invoke("continousDeviceUpdate", deviceSetting.DeviceId, deviceSetting.ContinousSetting);
Debug.WriteLine($"{nameof(RealTimeService)}.{nameof(UpdateDeviceAsync)} continous device updated, setting {deviceSetting.ContinousSetting}");
return true;
}
Debug.WriteLine($"{nameof(RealTimeService)}.{nameof(UpdateDeviceAsync)} unknown discriminator");
return false;
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(RealTimeService)}.{nameof(UpdateDeviceAsync)} ex: {e.GetType()}, msg: {e.Message}");
return false;
}
}
private void OpenCalibration(RoomLineGraphInfo roomLineGraphInfo)
{
var dialogParametr = new DialogParameters
{
{ "model", roomLineGraphInfo }
};
DeviceSetting setting = null;
_dialogService.ShowModal("CalibrationView", dialogParametr, x =>
{
if (x.Result == ButtonResult.OK)
{
setting = x.Parameters.GetValue <DeviceSetting>("model");
setting.Id = roomLineGraphInfo.Setting.Id;
setting.ActiveDeviceId = roomLineGraphInfo.DeviceClient.ActiveDevice.Id;
Task.Run(async() =>
{
await _deviceRepository.UpdateOrCreateSetting(setting);
});
}
});
if (setting != null)
{
roomLineGraphInfo.SetSetting(setting.TemperatureRange, setting.HumidityRange);
}
}
public int TestSocketConnect(string ipString, string portString)
{
DeviceSetting setting = new DeviceSetting()
{
DeviceIpAddress = ipString, DevicePort = portString
};
if (!setting.IsSettingValid())
{
return(-2);
}
else
{
RFID_StandardProtocol Reader = new RFID_StandardProtocol();
Socket temp = null;
int status = Reader.Socket_ConnectSocket(ref temp, ipString, portString.ToDefaultInt32());
if (status == RFID_StandardProtocol.SUCCESS)
{
temp.Close();
temp.Dispose();
return(0); //连接成功(connect success)
}
else
{
temp.Close();
temp.Dispose();
return(-1); //连接失败(connect fail)
}
}
}
// Update is called once per frame
//void Update()
//{
// if (Input.GetKeyDown(KeyCode.P))
// {
// Screen.fullScreen = !Screen.fullScreen;
// }
//}
/// <summary>
/// 获取系统设置
/// </summary>
public static void GetSystemSetting()
{
string path = Application.dataPath + ConfigPath;
if (!File.Exists(path))
{
CreateSystemSettingXml();
}
else
{
systemSetting = SerializeHelper.DeserializeFromFile <SystemSetting>(path);
}
Log.Error("SystemSettingHelper.GetSystemSetting" + systemSetting.IsShowLeftTopo);
resolutionSetting = systemSetting.ResolutionSetting;
cinemachineSetting = systemSetting.CinemachineSetting;
communicationSetting = systemSetting.CommunicationSetting;
versionSetting = systemSetting.VersionSetting;
refreshSetting = systemSetting.RefreshSetting;
assetLoadSetting = systemSetting.AssetLoadSetting;
honeyWellSetting = systemSetting.HoneyWellSetting;
deviceSetting = systemSetting.DeviceSetting;
historyPathSetting = systemSetting.HistoryPathSetting;
alarmSetting = systemSetting.AlarmSetting;
///如果版本号不一致，自动更新
if (versionSetting.VersionNumber != SystemSettingHelper.instance.versionNum)
{
versionSetting.VersionNumber = SystemSettingHelper.instance.versionNum;
SaveSystemSetting();
}
locationSetting = systemSetting.LocationSetting;
debugSetting = systemSetting.DebugSetting;
}
//private DateTime plasmaGeneoratorStartTime;
public PlasmaGeneratorGroup(PrimaryPlasmaGenerator primary, SecondaryPlasmaGenerator second, DeviceSetting setting)
{
Primary = primary;
Second = second;
this.setting = setting;
plasmaGeneratorTimer = new Timer(switchEq, null, 10000, 10000);
}
/// <summary>
/// デバイス設定を保存する
/// </summary>
public static void Save(DeviceSetting deviceSettig)
{
ActionModeData.Save(deviceSettig.ActionMode);
SnoreSensitivityData.Save(deviceSettig.SnoreSensitivity);
SuppressionStrengthData.Save(deviceSettig.SuppressionStrength);
SuppressionOperationMaxTimeData.Save(deviceSettig.SuppressionOperationMaxTime);
SuppressionStartTimeData.Save(deviceSettig.SuppressionStartTime);
}
private void UpdateDeviceSettingButton_Click(object sender, EventArgs e)
{
if (FDeviceSettingsListBox.SelectedIndex >= 0)
{
DeviceSetting setting = new DeviceSetting();
PushSetting(setting);
FDeviceSettingsListBox.Items[FDeviceSettingsListBox.SelectedIndex] = setting;
}
}
public void saveSettings()
{
if (settings == null)
{
Console.WriteLine("NO SETTINGS??");
return;
}
/***************************
* SAVE DEVICE
*/
settings.deviceSettings.Clear();
foreach (IDevice device in devices)
{
DeviceSetting devsettings = new DeviceSetting();
//device
devsettings.DeviceName = device.getDeviceName();
if (device.driver == null)
{
device.driver = new EmptyDriver();
}
devsettings.DriverName = device.driver.getDriverName();
//driver
devsettings.DeviceLogin = device.driver.Login;
devsettings.DevicePassword = device.driver.Password;
devsettings.DeviceURI = device.driver.URI;
settings.deviceSettings.Add(devsettings);
}
/***************************
* SAVE VIEW
*/
settings.viewSettings.Clear();
foreach (CameraView view in views)
{
ViewSetting viewsettings = new ViewSetting();
//device
if (view.getCurrentDevice() != null)
{
viewsettings.DeviceName = view.getCurrentDevice().getDeviceName();
}
else
{
viewsettings.DeviceName = "";
}
settings.viewSettings.Add(viewsettings);
}
settings.SaveToFile(settingsPath + "/settings.xml");
}
/// <summary>
/// Method to map device setting
/// </summary>
/// <param name="register">Register</param>
/// <returns></returns>
private DeviceSetting MapDeviceSetting(Register register)
{
var device = new DeviceSetting
{
Scanner = new ScannerSetting
{
UseScanner = register.Scanner,
UseOposScanner = register.Opos_Scanner,
Name = register.Scanner_Name,
Port = register.Scanner_Port,
Setting = register.Scanner_Setting
},
CashDrawer = new CashDrawerSetting
{
UseCashDrawer = register.Cash_Drawer,
UseOposCashDrawer = register.Opos_Cash_Drawer,
Name = register.Cash_Drawer_Name,
OpenCode = register.Cash_Drawer_Open_Code
},
CustomerDisplay = new CustomerDisplaySetting
{
UseCustomerDisplay = register.Customer_Display,
UseOposCustomerDisplay = register.Opos_Customer_Display,
Name = register.Customer_Display_Name,
DisplayCode = register.Customer_Display_Code,
Port = register.Customer_Display_Port,
DisplayLen = register.Customer_Display_Len
},
Receipt = new ReceiptSetting
{
UseReceiptPrinter = register.Receipt_Printer,
UseOposReceiptPrinter = register.Opos_Receipt_Printer,
ReceiptDriver = register.ReceiptDriver,
Name = register.ReceiptPrinterName
},
Report = new ReportSetting
{
UseReportPrinter = register.Report_Printer,
UseOposReportPrinter = register.Opos_Report_Printer,
Name = register.Report_Printer_Name,
Driver = register.Report_Printer_Driver,
Font = register.Report_Printer_font,
FontSize = register.Report_Printer_font_size
},
Msr = new MsrSetting
{
UseMsr = register.MSR,
UseOposMsr = register.Opos_MSR,
Name = register.MSR_Name
}
};
return(device);
}
public TRAY_FORM()
{
_shutdown = false;
_userSession = new UserSession();
_deviceSetting = new DeviceSetting(_userSession);
_serverSetting = new ServerSetting(_userSession);
_employees = new Employees(_deviceSetting, _userSession);
_companies = new Companies(_userSession);
InitializeComponent();
}
/// <summary>
/// シーン開始イベントハンドラ
/// </summary>
protected override void Start()
{
base.Start();
if (TempDeviceSetting == null)
{
TempDeviceSetting = UserDataManager.Setting.DeviceSettingData.Load();
}
showCurrentSettingInfo();
}
private void DeviceSettingsListBox_SelectedIndexChanged(object sender, EventArgs e)
{
DeviceSetting setting = FDeviceSettingsListBox.SelectedItem as DeviceSetting;
if (setting != null)
{
FDeviceNameTextBox.Text = setting.DeviceName;
FSettingNameTextBox.Text = setting.SettingName;
FSettingValueTextBox.Text = setting.SettingValue;
}
}
public static bool IsSettingValid(this DeviceSetting setting)
{
IPAddress testIP = IPAddress.Any;
if (!IPAddress.TryParse(setting.DeviceIpAddress, out testIP))
{
return(false);
}
return(IsIPAddressValid(testIP) && IsPortValid(setting.DevicePort));
}
public async Task <Result> RegisterAsync(DeviceSetting deviceSetting, CancellationToken cancellationToken)
{
if (deviceSetting == null)
{
return(Result.ReportError("deviceSetting is null"));
}
using (var context = new ZvsContext(EntityContextConnection))
{
var setting = await context.DeviceSettings
.Include(o => o.Options)
.FirstOrDefaultAsync(d => d.UniqueIdentifier == deviceSetting.UniqueIdentifier, cancellationToken);
var changed = false;
if (setting == null)
{
context.DeviceSettings.Add(deviceSetting);
changed = true;
}
else
{
PropertyChangedEventHandler handler = (s, a) => changed = true;
setting.PropertyChanged += handler;
setting.Name = deviceSetting.Name;
setting.Description = deviceSetting.Description;
setting.ValueType = deviceSetting.ValueType;
setting.Value = deviceSetting.Value;
setting.PropertyChanged -= handler;
var added = deviceSetting.Options.Where(option => setting.Options.All(o => o.Name != option.Name)).ToList();
foreach (var option in added)
{
setting.Options.Add(option);
changed = true;
}
var removed = setting.Options.Where(option => deviceSetting.Options.All(o => o.Name != option.Name)).ToList();
foreach (var option in removed)
{
context.DeviceSettingOptions.Local.Remove(option);
changed = true;
}
}
if (changed)
{
return(await context.TrySaveChangesAsync(cancellationToken));
}
return(Result.ReportSuccess("Nothing to update"));
}
}
public virtual void TestInitialize()
{
TestAccount = CreateTestAccount();
// TestUser = CreateTestUser();
TestDeviceCategory = CreateTestDeviceCategory();
TestDeviceType = CreateTestDeviceType();
TestManufacturer = CreateTestManufacturer();
TestDevice = CreateTestDevice();
TestRoom = CreateTestRoom();
TestOwnedDevice = CreateTestOwnedDevice();
TestDeviceSetting = CreateTestDeviceSetting();
}
public void AddSetting(DeviceSetting setting)
{
if (this.Settings == null)
{
this.Settings = new ItemsDictionary <DeviceSetting>();
}
if (setting != null && setting.Id != null)
{
this.Settings.Add(setting.Id, setting);
}
}
public async Task RegisterAsyncOptionRemoveTest()
{
//arrange
var dbConnection = new UnitTestDbConnection();
Database.SetInitializer(new CreateFreshDbInitializer());
var dsb = new DeviceSettingBuilder(dbConnection);
var deviceSetting = new DeviceSetting
{
Name = "Unit Test Device Setting",
UniqueIdentifier = "DEVICE_SETTING1"
};
var option1 = new DeviceSettingOption
{
Name = "Option 1"
};
var option2 = new DeviceSettingOption
{
Name = "Option 2"
};
deviceSetting.Options.Add(option1);
deviceSetting.Options.Add(option2);
using (var context = new ZvsContext(dbConnection))
{
context.DeviceSettings.Add(deviceSetting);
await context.SaveChangesAsync();
}
deviceSetting.Options.Remove(option2);
//act
var result = await dsb.RegisterAsync(deviceSetting, CancellationToken.None);
DeviceSetting setting;
using (var context = new ZvsContext(dbConnection))
{
setting = await context.DeviceSettings
.Include(o => o.Options)
.FirstOrDefaultAsync(o => o.UniqueIdentifier == deviceSetting.UniqueIdentifier);
}
//assert
Console.WriteLine(result.Message);
Assert.IsFalse(result.HasError, result.Message);
Assert.IsNotNull(setting, "Expected new device setting saved to DB");
Assert.IsTrue(setting.Options.Count == 1, "Expected 1 option!");
Assert.IsTrue(setting.Options[0].Name == option1.Name);
}
public async Task RegisterRemovedDeviceSettingOptionTest()
{
//Arrange
var dbConnection = new UnitTestDbConnection();
Database.SetInitializer(new CreateFreshDbInitializer());
var adapterBuilder = new AdapterSettingBuilder(dbConnection, CancellationToken.None);
var deviceSetting = new DeviceSetting
{
Name = "Device Setting 1",
ValueType = DataType.STRING,
Value = "Hello World"
};
var option1 = new DeviceSettingOption
{
Name = "Option 1",
};
var option2 = new DeviceSettingOption
{
Name = "Option 2",
};
deviceSetting.Options.Add(option1);
deviceSetting.Options.Add(option2);
using (var context = new ZvsContext(dbConnection))
{
context.DeviceSettings.Add(deviceSetting);
await context.SaveChangesAsync();
}
deviceSetting.Options.Remove(option2);
//act
var result = await adapterBuilder.RegisterDeviceSettingAsync(deviceSetting);
DeviceSetting setting;
using (var context = new ZvsContext(dbConnection))
{
setting = await context.DeviceSettings
.Include(o => o.Options)
.FirstOrDefaultAsync();
}
//assert
Console.WriteLine(result.Message);
Assert.IsFalse(result.HasError);
Assert.IsNotNull(setting, "Setting not found");
Assert.IsTrue(setting.Options.Count == 1, "Expected 2 options");
Assert.IsTrue(setting.Options[0].Name == option1.Name, "Name mismatch");
}
public DeviceSetting CreateTestDeviceSetting(string deviceSettingName = TestDeviceSettingName)
{
var newTestDeviceSetting = new DeviceSetting
{
DeviceSettingName = deviceSettingName,
DeviceSettingValue = TestDeviceSettingValue,
OwnedDeviceId = TestOwnedDevice.OwnedDeviceId
};
DeviceSettingService.Insert(newTestDeviceSetting);
newTestDeviceSetting = DeviceSettingService.Search(deviceSettingName).First();
return(newTestDeviceSetting);
}
public SystemSetting()
{
ResolutionSetting = new ResolutionSetting();
CinemachineSetting = new CinemachineSetting();
CommunicationSetting = new CommunicationSetting();
VersionSetting = new VersionSetting();
RefreshSetting = new RefreshSetting();
AssetLoadSetting = new AssetLoadSetting();
HoneyWellSetting = new HoneyWellSetting();
DeviceSetting = new DeviceSetting();
HistoryPathSetting = new HistoryPathSetting();
LocationSetting = new LocationSetting();
DebugSetting = new DebugSetting();
AlarmSetting = new AlarmSetting();
}
/// <summary>
/// 为最先调用函数
/// </summary>
/// <param name="settings">通道设置列表</param>
public static void CANSetDeviceInfo(ref List <DeviceInfoModel> settings)
{
var infos = new List <DeviceSetting>();
foreach (var setting in settings)
{
var info = new DeviceSetting();
info.BaudRate = setting.BaudRate * 1000;
info.HardwareIndex = setting.HardwareIndex;
info.DeviceName = Encoding.Default.GetBytes(setting.DeviceName.PadLeft(32, '0'));
info.DevicePort = (CANPort)setting.DevicePort;
infos.Add(info);
}
CanInteraction.CANSetDeviceInfo(infos.Count, infos.ToArray());
}
private void SetTime()
{
DateTime?dateTime = null;
if (!this._enabledSwitch.On)
{
//dateTime = NSDateToDateTime(this._datePickerView.Date);
dateTime = DateTime.Now.AddMinutes(this._intervalPickerView.Value.TotalMinutes);
}
this._feature.PromptValue = null;
//if (!this._datePickerView.Hidden && dateTime != null)
// this._feature.PromptValue = DateTimeUtil.DateTimeInEnglish(dateTime.Value, allCaps:false);
if (!this._intervalPickerView.Hidden && dateTime != null)
{
this._feature.PromptValue = this._intervalPickerView.ValueAsString(); //DateTimeUtil.DateTimeInEnglish(dateTime.Value, allCaps: false);
}
var originalSetting = this._feature?.Feature?.Setting;
if (originalSetting != null)
{
var setting = new DeviceSetting()
{
Id = originalSetting.Id, Values = new ItemsDictionary <DeviceSettingValue>()
};
//HARDCODED
setting.Values.Add("ProgramDisable", new DeviceSettingValue()
{
Value = this._enabledSwitch.On ?
this._feature.EnableValue :
(this._disableIndefCheckbox.Checked ? this._feature.DisableValue : this._feature.DisableTimerValue)
});
if (!this._enabledSwitch.On && !this._disableIndefCheckbox.Checked && dateTime != null)
{
//TODO: round to nearest 1/2 hour?
var durationEnd = dateTime.Value;
setting.Values.Add("EndDateTimeUtc", new DeviceSettingValue()
{
Value = DateTimeUtil.ToUtcDateString(durationEnd)
});
}
//set the values for the setting
this.ChangeFeatureSettingValue(setting);
}
}
protected override void CloseDialogOnOk(IDialogParameters parameters)
{
var room = new DeviceSetting();
if (double.TryParse(Temperature.Replace(".", ","), out double t))
{
}
if (double.TryParse(Humidity.Replace(".", ","), out double h))
{
}
room.SetSetting(t, h);
Result = ButtonResult.OK;
parameters = new DialogParameters();
parameters.Add("model", room);
CloseDialog(parameters);
}
private async Task DeviceUpdated_MainThread(DeviceSetting deviceSetting)
{
if (deviceSetting.DeviceId == _deviceViewModel.DeviceId)
{
try
{
if (ChangeSettingButton.IsVisible && !ChangeSettingButton.IsEnabled)
{
ChangeSettingButton.IsEnabled = true;
}
}
catch (Exception e)
{
Debug.WriteLine(
$"{nameof(DevicePage)}.{nameof(RealTimeService_DeviceUpdated)}, ex: {e.GetType()}, msg: {e.Message}");
}
if (!deviceSetting.Success)
_notifyPage.DisplayAlert("Error", "Could not change setting!");
else if (_deviceViewModel.Discriminator == "Binary")
{
_deviceViewModel.BinarySetting = deviceSetting.BinarySetting;
StatusLabel.Text = _deviceViewModel.Status;
await PutNewModel(_deviceViewModel);
}
else if (_deviceViewModel.Discriminator == "Continous")
{
_deviceViewModel.ContinousSetting = deviceSetting.ContinousSetting;
StatusLabel.Text = _deviceViewModel.Status;
await PutNewModel(_deviceViewModel);
}
else
{
Debug.WriteLine(
$"{nameof(DevicePage)}.{nameof(RealTimeService_DeviceUpdated)}, unknown view model {nameof(_deviceViewModel.Discriminator)} - {_deviceViewModel.Discriminator}");
}
}
}
private void RealTimeService_DeviceUpdated(object sender, DeviceSetting deviceSetting)
{
Debug.WriteLine($"{nameof(DevicePage)}.{nameof(RealTimeService_DeviceUpdated)}, id: {deviceSetting.DeviceId}, handling: {deviceSetting.DeviceId == _deviceViewModel.DeviceId}");
Device.BeginInvokeOnMainThread(() => DeviceUpdated_MainThread(deviceSetting));
}
