public IEnumerable<JObject> ToJsonForYdiff(RegisteredDevice device, KnowledgeGenerator knowledgeGenerator) { yield return new JObject { { "accepted", true }, { "accountId", this.Account.Id }, { "amount", this.Amount }, { "categoryId", this.Category.Id }, { "checkNumber", null }, { "cleared", this.Cleared ? "Cleared" : "Uncleared" }, { "date", DateTime.Today.ToString("yyyy-MM-dd") }, { "dateEnteredFromSchedule", null }, { "entityId", this.Id }, { "entityType", "transaction" }, { "entityVersion", $"{device.ShortDeviceId}-{knowledgeGenerator.GetNext()}" }, { "flag", null }, { "importedPayee", null }, { "isTombstone", false }, { "madeWithKnowledge", null }, { "memo", this.Memo }, { "payeeId", this.Payee.Id }, { "subTransactions", new JArray() }, { "targetAccountId", null }, { "transferTransactionId", null } }; }
public async void Search() { if (firstAdapter == null) { return; } await firstAdapter.ScanAsync(); //firstAdapter.AvailableNetworksChanged += FirstAdapter_AvailableNetworksChanged; var qualifyingWifi = firstAdapter.NetworkReport.AvailableNetworks.Where(N => N.Ssid.ToLower().StartsWith("ioespt-thing")); foreach (WiFiAvailableNetwork deviceWifi in qualifyingWifi) { RegisteredDevice FoundDevice = new RegisteredDevice() { Status = DeviceStatus.UnProvisioned, ConnectedTo = "None", GivenName = deviceWifi.Ssid, ChipId = "Unknown", FirmwareName = "Unknown", FirmwareVersion = "Unknown", ModuleType = "Unknown" }; if (DeviceFound != null) { DeviceFound(this, new DeviceFoundEventArgs(FoundDevice)); } } }
public void Work(string log, RegisteredDevice device) { if (device.DeviceParseMethod == "Regex") { if (_regexParser.Work(log, device.RegexStatements, ref values)) { CheckToProcesses(device.Id, true); } else { _errorLogService.Create(new ErrorLog { Date = DateTime.Now.ToString(), Level = "Level=Error", ErrorMessage = "Message=Log is not parsed" }); } } else if (device.DeviceParseMethod == "Code") { if (_codeParser.Work(log, ref values)) { CheckToProcesses(device.Id, true); } else { _errorLogService.Create(new ErrorLog { Date = DateTime.Now.ToString(), Level = "Level=Error", ErrorMessage = "Message=Log is not parsed" }); } } }
public bool SaveVideoPartial(MemoryStream FilePartial, string DeviceIdName, DateTime CaptureStart, bool IsFinished = false, DateTime?CaptureFinish = null) { //Will append this stream to the end of the other file RegisteredDevice Camera = _RegisteredDeviceService.GetDeviceByName(DeviceIdName); var footage = _FootageStorageService.GetFootage(Camera.IdRegisteredDevice, CaptureStart); return(false); }
public IEnumerable<JObject> ToJsonForYdiff(RegisteredDevice device, KnowledgeGenerator knowledgeGenerator) { var json = this.Transaction.GetJson(); json["isTombstone"] = true; json["entityVersion"] = $"{device.ShortDeviceId}-{knowledgeGenerator.GetNext()}"; yield return json; }
private async Task <List <AuthenticatedWebSocketConnection> > GetOnlinePairedDevices( RegisteredDevice device, AnperiDbContext dbContext) { IEnumerable <int> pairedDeviceIds = await GetPairedDeviceIds(device, dbContext); lock (_activeConnections) { return(_activeConnections.Where(c => pairedDeviceIds.Contains(c.Key)).Select(c => c.Value).ToList()); } }
public async Task DeleteDevice(RegisteredDevice device) { if (device != null) { using (var uow = new UnitOfWork <RegisteredDevice, RomiDbContext>()) { await Task.Run(() => uow.Repository().Delete(device)); } } }
public AuthenticatedWebSocketConnection(HttpContext context, WebSocket socket, byte[] buffer, RegisteredDevice device, AnperiDbContext dbContext, ILogger <AnperiWebSocketMiddleware> logger, AnperiWebSocketMiddleware anperiManager, List <AuthenticatedWebSocketConnection> onlinePairedDevices) { _context = context; _socket = socket; _buffer = buffer; _device = device; _logger = logger; _anperiManager = anperiManager; _db = dbContext; _loggedInPairedDevices = onlinePairedDevices ?? new List <AuthenticatedWebSocketConnection>(); }
public static IDevice MakeDevice(string DeviceType, RegisteredDevice DeviceDetails) { switch(DeviceType) { case "IOESPT-Display": return new DisplayDevice() { DeviceDetails = DeviceDetails }; case "IOESPT-Thermometer": return new ThermometerDevice() { DeviceDetails = DeviceDetails }; default: return new UnknownDevice() { DeviceDetails = DeviceDetails }; } }
public async Task <IActionResult> DeviceId([FromBody] RegisterViewModel viewModel) { var logger = await _tableService.GetLogger(viewModel.Id, viewModel.Password); var result = new RegisteredDevice { Find = logger != null, Id = logger?.DeviceId, Name = logger?.Name }; return(new JsonResult(result)); }
private void btnAddORSave_Click(object sender, EventArgs e) { try { if (!IPAddress.TryParse(txtIP.Text, out _)) { MessageBox.Show("IP address is incorrect!"); return; } if (string.IsNullOrEmpty(txtName.Text) || string.IsNullOrEmpty(txtHostname.Text)) { MessageBox.Show("Hostname/Name cannot be empty!"); return; } if (cbType.SelectedItem == null) { MessageBox.Show("Select type, it cannot be empty!"); return; } var type = (DeviceType)Enum.Parse(typeof(DeviceType), cbType.SelectedItem.ToString()); bool?ret = null; switch (currWork) { case TypeOfWork.FromScannedDevice: case TypeOfWork.AddDevice: RegisteredDevice.AddRegisteredDevice(txtIP.Text, txtName.Text, txtHostname.Text, type, (short)numPort.Value); break; case TypeOfWork.UpdateDevice: ret = RegisteredDevice.UpdateRegisteredDevice(txtName.Text, type, (short)numPort.Value, RegisteredDevicePK); break; } if (ret == null) { DialogResult = DialogResult.OK; } if (ret != null && ret == true) { DialogResult = DialogResult.OK; } else if (ret != null && ret == false) { MessageBox.Show("Internal error! Could not update device!"); } } catch (Exception ex) { MessageBox.Show($"Internal error! {ex.Message}"); } }
public async Task <ActionResult> Update(RegisteredDevice device) { try { await _database.Update(device); return(Ok()); } catch (Exception e) { _logger.LogError("Failed to update object {@Object} with error {@Exception}", device, e.Message); return(Conflict()); } }
public IEnumerable<JObject> ToJsonForYdiff(RegisteredDevice device, KnowledgeGenerator knowledgeGenerator) { yield return new JObject { { "budgeted", this.Amount }, { "categoryId", this.Category.Id }, { "entityId", $"MCB/{this.MonthAndYear.Year}-{this.MonthAndYear.Month}/{this.Category.Id}" }, { "entityType", "monthlyCategoryBudget" }, { "entityVersion", $"{device.ShortDeviceId}-{knowledgeGenerator.GetNext()}" }, { "isTombstone", false }, { "madeWithKnowledge", null }, { "note", this.Note }, { "overspendingHandling", null }, { "parentMonthlyBudgetId", $"MB/{this.MonthAndYear.Year}-{this.MonthAndYear.Month}" } }; }
public IActionResult VerifyOTP(VerifyOTPReq req) { VerifyOTPResp resp = new VerifyOTPResp(); try { if (RequestValidator.VerifyOTP(req)) { if (UserCRUD.IsValidUser(req.user_id)) { if (DeviceCRUD.VerifyOTP(req.device_id, req.user_id, Convert.ToString(req.otp)) || req.otp == 1111) { var user = UserCRUD.GetUser(req.user_id); // DeviceCRUD.NulifyOTP(req.device_id, req.user_id, Convert.ToString(req.otp)); RegisteredDevice device = DeviceCRUD.GetDevice(req.device_id); resp.name = user.Name; resp.status_code = Ok().StatusCode; resp.status_message = StatusMessage.Success; resp.token = JwtToken.GenerateJwtToken(device); } else { resp.status_code = Unauthorized().StatusCode; resp.status_message = StatusMessage.UnAuthorised; } } else { resp.status_code = BadRequest().StatusCode; resp.status_message = StatusMessage.BadRequest; } } else { resp.status_code = BadRequest().StatusCode; resp.status_message = StatusMessage.BadRequest; } } catch (Exception es) { resp.status_code = 500; resp.status_message = StatusMessage.InternalServerError; } return(Ok(resp)); }
public static string GenerateJwtToken(RegisteredDevice device) { var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(AppSetting.Secret)); var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256); var claims = new[] { new Claim(ClaimTypes.Name, device.User.Name), new Claim(ClaimTypes.Authentication, device.UserId.ToString()), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()) }; var token = new JwtSecurityToken(issuer: "Test", audience: "Test2", claims: claims, expires: DateTime.Now.AddMinutes(60), signingCredentials: credentials); return(new JwtSecurityTokenHandler().WriteToken(token)); }
public IEnumerable<JObject> ToJsonForYdiff(RegisteredDevice device, KnowledgeGenerator knowledgeGenerator) { yield return new JObject { { "name", this.Name }, { "autoFillCategoryId", null }, { "isTombstone", false }, { "madeWithKnowledge", null }, { "entityVersion", $"{device.ShortDeviceId}-{knowledgeGenerator.GetNext()}" }, { "enabled", true }, { "isResolvedConflict", false }, { "autoFillMemo", string.Empty }, { "autoFillAmount", 0m }, { "entityId", this.Id }, { "entityType", "payee" }, { "targetAccountId", null } }; }
public IActionResult GenerateOTP(GenerateOTPReq req) { BaseResponse resp = new BaseResponse(); try { if (RequestValidator.GenerateOTP(req)) { if (UserCRUD.IsValidUser(req.user_id)) { var device = DeviceCRUD.GetDevice(req.device_id, req.user_id, req.os_type); if (device == null) { device = new RegisteredDevice() { DeviceId = req.device_id, UserId = req.user_id, OsType = req.os_type, LastUpdate = DateTime.Now, Otp = "1111" }; } DeviceCRUD.AddDeviceIfNotExist(device); resp.status_code = Ok().StatusCode; resp.status_message = StatusMessage.Success; } else { resp.status_code = Unauthorized().StatusCode; resp.status_message = StatusMessage.UnAuthorised; } } else { resp.status_code = BadRequest().StatusCode; resp.status_message = StatusMessage.BadRequest; } } catch (Exception es) { resp.status_code = 500; resp.status_message = StatusMessage.InternalServerError; } return(Ok(resp)); }
private void UpdateRegisteredDevices() { registeredDevices = RegisteredDevice.GetRegisteredDevices(); lstRegisterDevices.Items.Clear(); foreach (var item in registeredDevices) { item.Deconstruct(out var collection); var lstItem = new ListViewItem(); lstItem.SubItems.AddRange(Array.ConvertAll(collection, (KeyValuePair <string, string> i) => { return(new ListViewItem.ListViewSubItem() { Text = i.Value, Name = i.Key }); })); lstItem.SubItems.RemoveAt(0); lstRegisterDevices.Items.Add(lstItem); } checker.UpdateDevices(registeredDevices); }
public static long AddDeviceIfNotExist(RegisteredDevice device) { using (var db = new Entities()) { db.RegisteredDevice.Attach(device); if (device.Id > 0) { db.Entry(device).State = EntityState.Modified; db.Entry(device).Property(x => x.RegisteredOn).IsModified = false; db.Entry(device).Property(x => x.Otp).IsModified = false; } else { device.RegisteredOn = DateTime.Now; db.Entry(device).State = EntityState.Added; } device.LastUpdate = DateTime.Now; db.SaveChanges(); return(device.Id); } }
private async void SsdpClient_DeviceFound(object sender, DeviceFoundEventArgs e) { if (e.Device.DeviceType.manufacturer == "IOESPT") { var foundDevice = devices.FirstOrDefault(D => D.DeviceDetails.ChipId == e.Device.DeviceType.serialNumber); Uri uri = new Uri(e.Device.URLBase); if (foundDevice != null) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () => { foundDevice.DeviceDetails.Status = DeviceStatus.Online; foundDevice.DeviceDetails.Ip = uri.Host; }); } else { //We have a new device online var newDevice = new RegisteredDevice(); newDevice.ChipId = e.Device.DeviceType.serialNumber; newDevice.FirmwareName = e.Device.DeviceType.modelName; newDevice.ModuleType = e.Device.DeviceType.modelName; newDevice.FirmwareVersion = e.Device.DeviceType.modelNumber; newDevice.GivenName = e.Device.DeviceType.friendlyName; newDevice.Status = DeviceStatus.Online; newDevice.ConnectedTo = "None"; newDevice.Ip = uri.Host; db.InsertNewDevice(newDevice); await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () => { devices.Add(DeviceTypeFactory.MakeDevice(newDevice.FirmwareName, newDevice)); }); } } }
public static IDevice MakeDevice(string DeviceType, RegisteredDevice DeviceDetails) { switch (DeviceType) { case "IOESPT-Display": return(new DisplayDevice() { DeviceDetails = DeviceDetails }); case "IOESPT-Thermometer": return(new ThermometerDevice() { DeviceDetails = DeviceDetails }); default: return(new UnknownDevice() { DeviceDetails = DeviceDetails }); } }
private async Task <IEnumerable <int> > GetPairedDeviceIds(RegisteredDevice device, AnperiDbContext dbContext) { return(await Task.Run(() => { IEnumerable <int> pairedDeviceIds; if (device is Host) { pairedDeviceIds = dbContext.HostPeripherals.Where(hp => hp.HostId == device.Id) .Select(hp => hp.PeripheralId); } else if (device is Peripheral) { pairedDeviceIds = dbContext.HostPeripherals.Where(hp => hp.PeripheralId == device.Id) .Select(hp => hp.HostId); } else { throw new NotImplementedException( $"The device type {device.GetType().AssemblyQualifiedName} is not implemented in GetPairedDeviceIds"); } return pairedDeviceIds.ToList(); })); }
public async Task Update(RegisteredDevice registeredDevice) { _logger.LogDebug("Update request, update: {@registeredDevice}", registeredDevice); var collection = GetCollection(); await collection.ReplaceOneAsync(doc => doc.DeviceAddress == registeredDevice.DeviceAddress, registeredDevice); }
public async Task Create(RegisteredDevice registeredDevice) { _logger.LogDebug("Create request, creating: {@registeredDevice}", registeredDevice); var collection = GetCollection(); await collection.InsertOneAsync(registeredDevice); }
private async Task <WebSocketCloseStatus> LoginDevice(HttpContext context, WebSocket socket, byte[] buffer, RegisteredDevice device, AnperiDbContext dbContext) { await socket.SendJson(SharedJsonApiObjectFactory.CreateLoginResponse(true, device.Name)); List <AuthenticatedWebSocketConnection> connectedPairedDevices = await GetOnlinePairedDevices(device, dbContext); var connection = new AuthenticatedWebSocketConnection(context, socket, buffer, device, dbContext, _logger, this, connectedPairedDevices); lock (_syncRootActiveConnections) { _activeConnections.Add(connection.Device.Id, connection); } WebSocketCloseStatus closeStatus; try { await OnDeviceLoggedIn(connection, dbContext); closeStatus = await connection.Run(_options.Value.RequestCancelToken); } catch (WebSocketException se) { if (!(se.InnerException is BadHttpRequestException)) { throw; } closeStatus = WebSocketCloseStatus.Empty; _logger.LogWarning( $"BadHttpRequestException occured while handling a websocket: {se.Message} -> {se.InnerException.Message}"); } finally { if (!connection.IsAborted) { await RemoveLoggedInDevice(connection, dbContext); } } return(closeStatus); }
public DeviceFoundEventArgs(RegisteredDevice device) { Device = device; }
public void DeleteDevice(RegisteredDevice device) { db.Table <RegisteredDevice>().Delete(C => C.ChipId == device.ChipId); }
private async Task HandleWebSocket(HttpContext ctx, AnperiDbContext dbContext) { WebSocket socket = await ctx.WebSockets.AcceptWebSocketAsync(); var buffer = new byte[_options.Value.WsBufferSize]; WebSocketApiResult apiObjectResult = await socket.ReceiveApiMessage(buffer, _options.Value.RequestCancelToken); bool authFailed = true; WebSocketCloseStatus closeStatus = WebSocketCloseStatus.Empty; if (apiObjectResult.Obj == null) { await socket.SendJson( SharedJsonApiObjectFactory.CreateError(apiObjectResult.JsonException.Message), _options.Value.RequestCancelToken); } else { if (apiObjectResult.Obj.context == JsonApiContextTypes.server && apiObjectResult.Obj.message_type == JsonApiMessageTypes.request) { apiObjectResult.Obj.data.TryGetValue(nameof(JsonLoginData.device_type), out string typeString); if (Enum.TryParse(typeString, out SharedJsonDeviceType type) && Enum.TryParse(apiObjectResult.Obj.message_code, out SharedJsonRequestCode code)) { RegisteredDevice device = null; switch (code) { case SharedJsonRequestCode.login: if (!apiObjectResult.Obj.data.TryGetValue("token", out string token)) { await socket.SendJson( SharedJsonApiObjectFactory.CreateError("Error retrieving token from request.")); } else { switch (type) { case SharedJsonDeviceType.host: device = dbContext.Hosts.SingleOrDefault(d => d.Token == token); break; case SharedJsonDeviceType.peripheral: device = dbContext.Peripherals.SingleOrDefault(d => d.Token == token); break; default: await socket.SendJson( SharedJsonApiObjectFactory.CreateError( "You need to be a host or peripheral.")); break; } if (device != null) { AuthenticatedWebSocketConnection activeConn; lock (_activeConnections) { _activeConnections.TryGetValue(device.Id, out activeConn); } if (activeConn != null) { activeConn.Abort(); await RemoveLoggedInDevice(activeConn, dbContext); } closeStatus = await LoginDevice(ctx, socket, buffer, device, dbContext); authFailed = false; } } break; case SharedJsonRequestCode.register: switch (type) { case SharedJsonDeviceType.host: device = new Host(); break; case SharedJsonDeviceType.peripheral: device = new Peripheral(); break; default: await socket.SendJson( SharedJsonApiObjectFactory.CreateError( "You need to be a host or peripheral.")); break; } if (device != null) { device.Token = Cryptography.CreateAuthToken(); if (apiObjectResult.Obj.data.TryGetValue("name", out string name)) { device.Name = name; } else { await socket.SendJson( SharedJsonApiObjectFactory.CreateError( "A device registration requires a name!")); } if (string.IsNullOrWhiteSpace(device.Name)) { device.Name = "devices want a name :("; } dbContext.RegisteredDevices.Add(device); await dbContext.SaveChangesAsync(); await socket.SendJson( SharedJsonApiObjectFactory.CreateRegisterResponse(device.Token, device.Name)); closeStatus = await LoginDevice(ctx, socket, buffer, device, dbContext); authFailed = false; } break; default: await socket.SendJson( SharedJsonApiObjectFactory.CreateError("Only login and register are valid here.")); break; } } else { await socket.SendJson( SharedJsonApiObjectFactory.CreateError( "Error parsing correct login or register parameters.")); } } } if (authFailed) { await socket.SendJson(SharedJsonApiObjectFactory.CreateLoginResponse(false, null)); CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1000)); await socket.CloseAsync(WebSocketCloseStatus.PolicyViolation, "Authentication failed.", cts.Token); } else if (_options.Value.RequestCancelToken.IsCancellationRequested) { CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1000)); await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Server is shutting down.", cts.Token); } else { await socket.CloseAsync(closeStatus, apiObjectResult.SocketResult.CloseStatusDescription, CancellationToken.None); } }
public void InsertNewDevice(RegisteredDevice device) { db.Insert(device); }
private void ToolBtnsForRegisteredDevices_Click(object sender, EventArgs e) { try { if (IsWorkingBW()) { MessageBox.Show("Some of the workers are load. Please wait..."); return; } if (!(new object[] { addToRegisteredDeviceListToolStripMenuItem, btnAddDevice }.Any(s => s == sender)) && lstRegisterDevices.SelectedItems.Count != 1) { MessageBox.Show("Before perform operations with devices, select one!", "Error", MessageBoxButtons.OK); return; } TypeOfWork? work = null; NameValueCollection nameValue = new NameValueCollection(); if (sender == addToRegisteredDeviceListToolStripMenuItem) { var sel = listVAddr.SelectedItems[0]; nameValue.Add("IP", sel.SubItems["IP"].Text); nameValue.Add("Hostname", sel.SubItems["Hostname"].Text); work = TypeOfWork.FromScannedDevice; } else if (sender == btnAddDevice) { work = TypeOfWork.AddDevice; } else if (sender == btnShowDeviceInf) { var registeredDevicePK = int.Parse(lstRegisterDevices.SelectedItems[0].SubItems["RegisteredDevicePK"].Text); var registeredDevice = registeredDevices.Find(r => r.RegisteredDevicePK == registeredDevicePK); using (var form = new ShowInfoForm(registeredDevice)) { form.ShowDialog(); } return; } else if (sender == btnUpdDevice) { var sel = lstRegisterDevices.SelectedItems[0]; nameValue.Add("RegisteredDevicePK", sel.SubItems["RegisteredDevicePK"].Text); nameValue.Add("IP", sel.SubItems["IP"].Text); nameValue.Add("Hostname", sel.SubItems["Hostname"].Text); nameValue.Add("Name", sel.SubItems["Name"].Text); nameValue.Add("Type", sel.SubItems["Type"].Text); nameValue.Add("Port", sel.SubItems["Port"].Text); work = TypeOfWork.UpdateDevice; } else if (sender == btnDelDevice) { var registeredDevicePK = int.Parse(lstRegisterDevices.SelectedItems[0].SubItems["RegisteredDevicePK"].Text); var ret = RegisteredDevice.RemoveRegisteredDevice(registeredDevicePK); if (ret) { UpdateRegisteredDevices(); } else { MessageBox.Show("Internal error! Could not remove this device!"); } return; } if (!work.HasValue) { return; } using (var form = new RegisterForm(work.Value, nameValue)) { var ret = form.ShowDialog(); if (ret == DialogResult.OK) { UpdateRegisteredDevices(); } } } catch (Exception ex) { MessageBox.Show($"Internal error occur! {ex.Message}"); LoggingHelper.LogEntry(SystemCategories.GeneralError, $"{ex.Message} {ex.StackTrace}"); } }
public ShowInfoForm(RegisteredDevice device) { InitializeComponent(); pbCPU.Maximum = 100; pbCPU.Minimum = 0; pbRAM.Maximum = 100; pbRAM.Minimum = 0; pbDisk.Maximum = 100; pbDisk.Minimum = 0; for (int i = 0; i < MAXItems; ++i) { CPUValues.Add(new ObservableValue()); RAMValues.Add(new ObservableValue()); } CPU_RAM_usage.AxisX.Add(new Axis { Title = "Time", ShowLabels = false, }); CPU_RAM_usage.AxisY.Add(new Axis { Title = "%, Load", MaxValue = 100, MinValue = 0 }); CPU_RAM_usage.LegendLocation = LegendLocation.Right; CPU_RAM_usage.Series.Add(new LineSeries() { Values = RAMValues, Title = "RAM", }); CPU_RAM_usage.Series.Add(new LineSeries() { Values = CPUValues, Title = "CPU", }); chartInterfaces.AxisX.Add(new Axis { Title = "Time", ShowLabels = false, }); chartInterfaces.AxisY.Add(new Axis { Title = "In/Out", MinValue = 0 }); chartInterfaces.LegendLocation = LegendLocation.Right; this.device = device; switch (device.Type) { case DeviceType.PC: lblPCIP.Text = device.IP; lblPCHost.Text = device.Hostname; tabControl.SelectedTab = tpPC; break; case DeviceType.Router: lblIPRouter.Text = device.IP; lblHostRouter.Text = device.Hostname; tabControl.SelectedTab = tpRouter; break; #region Switch //case DeviceType.Switch: // tabControl.SelectedTab = tpSwitch; // break; #endregion #region Printer //case DeviceType.Printer: // tabControl.SelectedTab = tpPrinter; // break; #endregion default: { MessageBox.Show("Incorrect device type!"); DialogResult = DialogResult.Abort; break; } } }
public async Task <IActionResult> RegisterDevice(string host, [FromBody] RegisteredDevice device) { throw new NotImplementedException(); }
public async Task <IActionResult> DeleteDevice([FromBody] RegisteredDevice deviceInterface) { throw new NotImplementedException(); }