示例#1
0
        /// <summary>
        /// Checks if the command is a delegated command for the given device.
        /// </summary>
        /// <param name="device">Device to check.</param>
        /// <param name="execution">Command execution to check.</param>
        /// <returns><c>true</c> if command is handled as a delegated command, otherwise <c>false</c>.</returns>
        private static string ValidateChallenges(Models.State.Device device, Execution execution)
        {
            if (device != null && !device.Disabled)
            {
                // Get any challenges
                var challenges = device.Traits
                                 .Where(x => x.Commands.ContainsKey(execution.Command) && x.Challenge != null)
                                 .Select(x => x.Challenge);

                // Evaluate all challenges
                foreach (var challenge in challenges)
                {
                    // Missing challenge answer
                    if (execution.Challenge == null)
                    {
                        return(challenge.ChallengeNeededPhrase);
                    }

                    // Validate challenge answer
                    if (!challenge.Validate(execution.Challenge))
                    {
                        // Challenge rejected
                        return(challenge.ChallengeRejectedPhrase);
                    }
                }
            }

            // All challenges passed
            return(null);
        }
示例#2
0
        public IActionResult Create(DeviceViewModel viewModel)
        {
            if (_deviceRepository.Contains(viewModel.Id))
            {
                ModelState.AddModelError("Id", "Device Id already exists");
            }

            // Set new values
            var device = new Models.State.Device
            {
                Id              = viewModel.Id,
                Type            = viewModel.Type,
                Disabled        = viewModel.Disabled,
                WillReportState = viewModel.WillReportState,
                RoomHint        = viewModel.RoomHint,
                Name            = new NameInfo
                {
                    Name = viewModel.Name
                },
                Traits = new List <DeviceTrait>()
            };

            // Default names
            if (!string.IsNullOrEmpty(viewModel.DefaultNames))
            {
                device.Name.DefaultNames = viewModel.DefaultNames.Split(',').Select(x => x.Trim()).ToList();
            }
            else
            {
                device.Name.DefaultNames = new List <string>();
            }

            // Nicknames
            if (!string.IsNullOrEmpty(viewModel.Nicknames))
            {
                device.Name.Nicknames = viewModel.Nicknames.Split(',').Select(x => x.Trim()).ToList();
            }
            else
            {
                device.Name.Nicknames = new List <string>();
            }

            // Device Info
            if (!string.IsNullOrEmpty(viewModel.Manufacturer) ||
                !string.IsNullOrEmpty(viewModel.Model) ||
                !string.IsNullOrEmpty(viewModel.HwVersion) ||
                !string.IsNullOrEmpty(viewModel.SwVersion))
            {
                if (device.DeviceInfo == null)
                {
                    device.DeviceInfo = new DeviceInfo();
                }

                device.DeviceInfo.Manufacturer = !string.IsNullOrEmpty(viewModel.Manufacturer) ? viewModel.Manufacturer : null;
                device.DeviceInfo.Model        = !string.IsNullOrEmpty(viewModel.Model) ? viewModel.Model : null;
                device.DeviceInfo.HwVersion    = !string.IsNullOrEmpty(viewModel.HwVersion) ? viewModel.HwVersion : null;
                device.DeviceInfo.SwVersion    = !string.IsNullOrEmpty(viewModel.SwVersion) ? viewModel.SwVersion : null;
            }
            else
            {
                device.DeviceInfo = null;
            }

            // Final validation
            foreach (var error in DeviceValidator.Validate(device))
            {
                ModelState.AddModelError(string.Empty, error);
            }

            if (!ModelState.IsValid)
            {
                return(RedirectToAction("Create"));
            }

            // Save changes
            _deviceRepository.Add(device);

            return(RedirectToAction("Index"));
        }